X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FTarget%2FTargetJITInfo.h;h=044afd9b73926ef670e5729f9d769694c888fba6;hb=3574eca1b02600bac4e625297f4ecf745f4c4f32;hp=dee5a9537575d78f0cf6b292ed41476ef1d2c63b;hpb=55fc28076fa48723bd170e51638b3b5974ca0fa1;p=oota-llvm.git diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h index dee5a953757..044afd9b739 100644 --- a/include/llvm/Target/TargetJITInfo.h +++ b/include/llvm/Target/TargetJITInfo.h @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -17,27 +17,23 @@ #ifndef LLVM_TARGET_TARGETJITINFO_H #define LLVM_TARGET_TARGETJITINFO_H +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/DataTypes.h" #include -#include namespace llvm { class Function; - class FunctionPassManager; - class MachineBasicBlock; - class MachineCodeEmitter; + class GlobalValue; + class JITCodeEmitter; class MachineRelocation; /// TargetJITInfo - Target specific information required by the Just-In-Time /// code generator. class TargetJITInfo { + virtual void anchor(); public: virtual ~TargetJITInfo() {} - /// addPassesToJITCompile - Add passes to the specified pass manager to - /// implement a fast code generator for this target. - /// - virtual void addPassesToJITCompile(FunctionPassManager &PM) = 0; - /// replaceMachineCodeForFunction - Make it so that calling the function /// whose machine code is at OLD turns into a call to NEW, perhaps by /// overwriting OLD with a branch to NEW. This is used for self-modifying @@ -45,12 +41,39 @@ namespace llvm { /// virtual void replaceMachineCodeForFunction(void *Old, void *New) = 0; - /// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a + /// emitGlobalValueIndirectSym - Use the specified JITCodeEmitter object + /// to emit an indirect symbol which contains the address of the specified + /// ptr. + virtual void *emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr, + JITCodeEmitter &JCE) { + llvm_unreachable("This target doesn't implement " + "emitGlobalValueIndirectSym!"); + } + + /// Records the required size and alignment for a call stub in bytes. + struct StubLayout { + size_t Size; + size_t Alignment; + }; + /// Returns the maximum size and alignment for a call stub on this target. + virtual StubLayout getStubLayout() { + llvm_unreachable("This target doesn't implement getStubLayout!"); + } + + /// emitFunctionStub - Use the specified JITCodeEmitter object to emit a /// small native function that simply calls the function at the specified - /// address. Return the address of the resultant function. - virtual void *emitFunctionStub(void *Fn, MachineCodeEmitter &MCE) { - assert(0 && "This target doesn't implement emitFunctionStub!"); - return 0; + /// address. The JITCodeEmitter must already have storage allocated for the + /// stub. Return the address of the resultant function, which may have been + /// aligned from the address the JCE was set up to emit at. + virtual void *emitFunctionStub(const Function* F, void *Target, + JITCodeEmitter &JCE) { + llvm_unreachable("This target doesn't implement emitFunctionStub!"); + } + + /// getPICJumpTableEntry - Returns the value of the jumptable entry for the + /// specific basic block. + virtual uintptr_t getPICJumpTableEntry(uintptr_t BB, uintptr_t JTBase) { + llvm_unreachable("This target doesn't implement getPICJumpTableEntry!"); } /// LazyResolverFn - This typedef is used to represent the function that @@ -71,8 +94,7 @@ namespace llvm { /// function, and giving the JIT the target function used to do the lazy /// resolving. virtual LazyResolverFn getLazyResolverFunction(JITCompilerFn) { - assert(0 && "Not implemented for this target!"); - return 0; + llvm_unreachable("Not implemented for this target!"); } /// relocate - Before the JIT can run a block of code that has been emitted, @@ -82,31 +104,33 @@ namespace llvm { unsigned NumRelocs, unsigned char* GOTBase) { assert(NumRelocs == 0 && "This target does not have relocations!"); } + - /// resolveBBRefs - Resolve branches to BasicBlocks for the JIT emitted - /// function. - virtual void resolveBBRefs(MachineCodeEmitter &MCE) {} - - /// synchronizeICache - On some targets, the JIT emitted code must be - /// explicitly refetched to ensure correct execution. - virtual void synchronizeICache(const void *Addr, size_t len) {} - - /// addBBRef - Add a BasicBlock reference to be resolved after the function - /// is emitted. - void addBBRef(MachineBasicBlock *BB, intptr_t PC) { - BBRefs.push_back(std::make_pair(BB, PC)); + /// allocateThreadLocalMemory - Each target has its own way of + /// handling thread local variables. This method returns a value only + /// meaningful to the target. + virtual char* allocateThreadLocalMemory(size_t size) { + llvm_unreachable("This target does not implement thread local storage!"); } /// needsGOT - Allows a target to specify that it would like the - // JIT to manage a GOT for it. + /// JIT to manage a GOT for it. bool needsGOT() const { return useGOT; } + /// hasCustomConstantPool - Allows a target to specify that constant + /// pool address resolution is handled by the target. + virtual bool hasCustomConstantPool() const { return false; } + + /// hasCustomJumpTables - Allows a target to specify that jumptables + /// are emitted by the target. + virtual bool hasCustomJumpTables() const { return false; } + + /// allocateSeparateGVMemory - If true, globals should be placed in + /// separately allocated heap memory rather than in the same + /// code memory allocated by JITCodeEmitter. + virtual bool allocateSeparateGVMemory() const { return false; } protected: bool useGOT; - - // Tracks which instruction references which BasicBlock - std::vector > BBRefs; - }; } // End llvm namespace