include/llvm/Target/TargetJITInfo.h

   1 //===- Target/TargetJITInfo.h - Target Information for JIT ------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file exposes an abstract interface used by the Just-In-Time code
  11 // generator to perform target-specific activities, such as emitting stubs.  If
  12 // a TargetMachine supports JIT code generation, it should provide one of these
  13 // objects through the getJITInfo() method.
  14 //
  15 //===----------------------------------------------------------------------===//
  16
  17 #ifndef LLVM_TARGET_TARGETJITINFO_H
  18 #define LLVM_TARGET_TARGETJITINFO_H
  19
  20 #include <cassert>
  21 #include "llvm/Support/DataTypes.h"
  22
  23 namespace llvm {
  24   class Function;
  25   class GlobalValue;
  26   class MachineBasicBlock;
  27   class MachineCodeEmitter;
  28   class MachineRelocation;
  29
  30   /// TargetJITInfo - Target specific information required by the Just-In-Time
  31   /// code generator.
  32   class TargetJITInfo {
  33   public:
  34     virtual ~TargetJITInfo() {}
  35
  36     /// replaceMachineCodeForFunction - Make it so that calling the function
  37     /// whose machine code is at OLD turns into a call to NEW, perhaps by
  38     /// overwriting OLD with a branch to NEW.  This is used for self-modifying
  39     /// code.
  40     ///
  41     virtual void replaceMachineCodeForFunction(void *Old, void *New) = 0;
  42
  43     /// emitGlobalValueNonLazyPtr - Use the specified MachineCodeEmitter object
  44     /// to emit a Mac OS X non-lazy pointer which contains the address of the
  45     /// specified ptr.
  46     virtual void *emitGlobalValueNonLazyPtr(const GlobalValue* GV, void *ptr,
  47                                             MachineCodeEmitter &MCE) {
  48       assert(0 && "This target doesn't implement emitGlobalValueNonLazyPtr!");
  49       return 0;
  50     }
  51
  52     /// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a
  53     /// small native function that simply calls the function at the specified
  54     /// address.  Return the address of the resultant function.
  55     virtual void *emitFunctionStub(const Function* F, void *Fn,
  56                                    MachineCodeEmitter &MCE) {
  57       assert(0 && "This target doesn't implement emitFunctionStub!");
  58       return 0;
  59     }
  60
  61     /// getPICJumpTableEntry - Returns the value of the jumptable entry for the
  62     /// specific basic block.
  63     virtual intptr_t getPICJumpTableEntry(intptr_t BB, intptr_t JTBase) {
  64       assert(0 && "This target doesn't implement getPICJumpTableEntry!");
  65       return 0;
  66     }
  67
  68     /// LazyResolverFn - This typedef is used to represent the function that
  69     /// unresolved call points should invoke.  This is a target specific
  70     /// function that knows how to walk the stack and find out which stub the
  71     /// call is coming from.
  72     typedef void (*LazyResolverFn)();
  73
  74     /// JITCompilerFn - This typedef is used to represent the JIT function that
  75     /// lazily compiles the function corresponding to a stub.  The JIT keeps
  76     /// track of the mapping between stubs and LLVM Functions, the target
  77     /// provides the ability to figure out the address of a stub that is called
  78     /// by the LazyResolverFn.
  79     typedef void* (*JITCompilerFn)(void *);
  80
  81     /// getLazyResolverFunction - This method is used to initialize the JIT,
  82     /// giving the target the function that should be used to compile a
  83     /// function, and giving the JIT the target function used to do the lazy
  84     /// resolving.
  85     virtual LazyResolverFn getLazyResolverFunction(JITCompilerFn) {
  86       assert(0 && "Not implemented for this target!");
  87       return 0;
  88     }
  89
  90     /// relocate - Before the JIT can run a block of code that has been emitted,
  91     /// it must rewrite the code to contain the actual addresses of any
  92     /// referenced global symbols.
  93     virtual void relocate(void *Function, MachineRelocation *MR,
  94                           unsigned NumRelocs, unsigned char* GOTBase) {
  95       assert(NumRelocs == 0 && "This target does not have relocations!");
  96     }
  97
  98
  99     /// allocateThreadLocalMemory - Each target has its own way of
 100     /// handling thread local variables. This method returns a value only
 101     /// meaningful to the target.
 102     virtual char* allocateThreadLocalMemory(size_t size) {
 103       assert(0 && "This target does not implement thread local storage!");
 104       return 0;
 105     }
 106
 107     /// needsGOT - Allows a target to specify that it would like the
 108     // JIT to manage a GOT for it.
 109     bool needsGOT() const { return useGOT; }
 110
 111     /// hasCustomConstantPool - Allows a target to specify that constant
 112     /// pool address resolution is handled by the target.
 113     virtual bool hasCustomConstantPool() const { return false; }
 114
 115     /// allocateSeparateGVMemory - If true, globals should be placed in
 116     /// separately allocated heap memory rather than in the same
 117     /// code memory allocated by MachineCodeEmitter.
 118     virtual bool allocateSeparateGVMemory() const { return false; }
 119   protected:
 120     bool useGOT;
 121   };
 122 } // End llvm namespace
 123
 124 #endif