1 /*

     2  * Copyright (c) 1999, 2007, Oracle and/or its affiliates. All rights reserved.

     3  * Copyright 2009 Red Hat, Inc.

     4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     5  *

     6  * This code is free software; you can redistribute it and/or modify it

     7  * under the terms of the GNU General Public License version 2 only, as

     8  * published by the Free Software Foundation.

     9  *

    10  * This code is distributed in the hope that it will be useful, but WITHOUT

    11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    13  * version 2 for more details (a copy is included in the LICENSE file that

    14  * accompanied this code).

    15  *

    16  * You should have received a copy of the GNU General Public License version

    17  * 2 along with this work; if not, write to the Free Software Foundation,

    18  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    19  *

    20  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    21  * or visit www.oracle.com if you need additional information or have any

    22  * questions.

    23  *

    24  */

    25 

    26 #include "incls/_precompiled.incl"

    27 #include "incls/_sharkMemoryManager.cpp.incl"

    28 

    29 using namespace llvm;

    30 

    31 void SharkMemoryManager::AllocateGOT() {

    32   mm()->AllocateGOT();

    33 }

    34 

    35 unsigned char* SharkMemoryManager::getGOTBase() const {

    36   return mm()->getGOTBase();

    37 }

    38 

    39 unsigned char* SharkMemoryManager::allocateStub(const GlobalValue* F,

    40                                                 unsigned StubSize,

    41                                                 unsigned Alignment) {

    42   return mm()->allocateStub(F, StubSize, Alignment);

    43 }

    44 

    45 unsigned char* SharkMemoryManager::startFunctionBody(const Function* F,

    46                                                      uintptr_t& ActualSize) {

    47   return mm()->startFunctionBody(F, ActualSize);

    48 }

    49 

    50 void SharkMemoryManager::endFunctionBody(const Function* F,

    51                                          unsigned char* FunctionStart,

    52                                          unsigned char* FunctionEnd) {

    53   mm()->endFunctionBody(F, FunctionStart, FunctionEnd);

    54 

    55   SharkEntry *entry = get_entry_for_function(F);

    56   if (entry != NULL)

    57     entry->set_code_limit(FunctionEnd);

    58 }

    59 

    60 unsigned char* SharkMemoryManager::startExceptionTable(const Function* F,

    61                                                        uintptr_t& ActualSize) {

    62   return mm()->startExceptionTable(F, ActualSize);

    63 }

    64 

    65 void SharkMemoryManager::endExceptionTable(const Function* F,

    66                                            unsigned char* TableStart,

    67                                            unsigned char* TableEnd,

    68                                            unsigned char* FrameRegister) {

    69   mm()->endExceptionTable(F, TableStart, TableEnd, FrameRegister);

    70 }

    71 

    72 void SharkMemoryManager::setMemoryWritable() {

    73   mm()->setMemoryWritable();

    74 }

    75 

    76 void SharkMemoryManager::setMemoryExecutable() {

    77   mm()->setMemoryExecutable();

    78 }

    79 

    80 #if SHARK_LLVM_VERSION >= 27

    81 void SharkMemoryManager::deallocateExceptionTable(void *ptr) {

    82   mm()->deallocateExceptionTable(ptr);

    83 }

    84 

    85 void SharkMemoryManager::deallocateFunctionBody(void *ptr) {

    86   mm()->deallocateFunctionBody(ptr);

    87 }

    88 #else

    89 void SharkMemoryManager::deallocateMemForFunction(const Function* F) {

    90   return mm()->deallocateMemForFunction(F);

    91 }

    92 #endif

    93 

    94 uint8_t* SharkMemoryManager::allocateGlobal(uintptr_t Size,

    95                                             unsigned int Alignment) {

    96   return mm()->allocateGlobal(Size, Alignment);

    97 }

    98 

    99 #if SHARK_LLVM_VERSION < 27

   100 void* SharkMemoryManager::getDlsymTable() const {

   101   return mm()->getDlsymTable();

   102 }

   103 

   104 void SharkMemoryManager::SetDlsymTable(void *ptr) {

   105   mm()->SetDlsymTable(ptr);

   106 }

   107 #endif

   108 

   109 void SharkMemoryManager::setPoisonMemory(bool poison) {

   110   mm()->setPoisonMemory(poison);

   111 }

   112 

   113 unsigned char *SharkMemoryManager::allocateSpace(intptr_t Size,

   114                                                  unsigned int Alignment) {

   115   return mm()->allocateSpace(Size, Alignment);

   116 }