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 // SharkMemoryManager wraps the LLVM JIT Memory Manager.  We could use

    27 // this to run our own memory allocation policies, but for now all we

    28 // use it for is figuring out where the resulting native code ended up.

    29 

    30 class SharkMemoryManager : public llvm::JITMemoryManager {

    31  public:

    32   SharkMemoryManager()

    33     : _mm(llvm::JITMemoryManager::CreateDefaultMemManager()) {}

    34 

    35  private:

    36   llvm::JITMemoryManager* _mm;

    37 

    38  private:

    39   llvm::JITMemoryManager* mm() const {

    40     return _mm;

    41   }

    42 

    43  private:

    44   std::map<const llvm::Function*, SharkEntry*> _entry_map;

    45 

    46  public:

    47   void set_entry_for_function(const llvm::Function* function,

    48                               SharkEntry*           entry) {

    49     _entry_map[function] = entry;

    50   }

    51   SharkEntry* get_entry_for_function(const llvm::Function* function) {

    52     return _entry_map[function];

    53   }

    54 

    55  public:

    56   void AllocateGOT();

    57   unsigned char* getGOTBase() const;

    58   unsigned char* allocateStub(const llvm::GlobalValue* F,

    59                               unsigned StubSize,

    60                               unsigned Alignment);

    61   unsigned char* startFunctionBody(const llvm::Function* F,

    62                                    uintptr_t& ActualSize);

    63   void endFunctionBody(const llvm::Function* F,

    64                        unsigned char* FunctionStart,

    65                        unsigned char* FunctionEnd);

    66   unsigned char* startExceptionTable(const llvm::Function* F,

    67                                      uintptr_t& ActualSize);

    68   void endExceptionTable(const llvm::Function* F,

    69                          unsigned char* TableStart,

    70                          unsigned char* TableEnd,

    71                          unsigned char* FrameRegister);

    72 #if SHARK_LLVM_VERSION < 27

    73   void* getDlsymTable() const;

    74   void SetDlsymTable(void *ptr);

    75 #endif

    76   void setPoisonMemory(bool);

    77   uint8_t* allocateGlobal(uintptr_t, unsigned int);

    78   void setMemoryWritable();

    79   void setMemoryExecutable();

    80 #if SHARK_LLVM_VERSION >= 27

    81   void deallocateExceptionTable(void *ptr);

    82   void deallocateFunctionBody(void *ptr);

    83 #else

    84   void deallocateMemForFunction(const llvm::Function* F);

    85 #endif

    86   unsigned char *allocateSpace(intptr_t Size,

    87                                unsigned int Alignment);

    88 };