X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineRelocation.h;h=244b466e172826a465e2ed6143cd04cba3aa7b97;hb=980bddfb1c26e2e9374d1645f9ae26c44742606f;hp=58b4f87bc5326cdd5e85de11b8b10c1a2a5a3fb5;hpb=52b510b4c4f36f58c4aa37a1f835eb95e89e0adb;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineRelocation.h b/include/llvm/CodeGen/MachineRelocation.h index 58b4f87bc53..244b466e172 100644 --- a/include/llvm/CodeGen/MachineRelocation.h +++ b/include/llvm/CodeGen/MachineRelocation.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. // //===----------------------------------------------------------------------===// // @@ -19,6 +19,7 @@ namespace llvm { class GlobalValue; +class MachineBasicBlock; /// MachineRelocation - This represents a target-specific relocation value, /// produced by the code emitter. This relocation is resolved after the has @@ -38,6 +39,8 @@ class MachineRelocation { enum AddressType { isResult, // Relocation has be transformed into its result pointer. isGV, // The Target.GV field is valid. + isIndirectSym, // Relocation of an indirect symbol. + isBB, // Relocation of BB address. isExtSym, // The Target.ExtSym field is valid. isConstPool, // Relocation of constant pool address. isJumpTable, // Relocation of jump table address. @@ -46,30 +49,39 @@ class MachineRelocation { /// Offset - This is the offset from the start of the code buffer of the /// relocation to perform. - intptr_t Offset; + uintptr_t Offset; /// ConstantVal - A field that may be used by the target relocation type. intptr_t ConstantVal; union { - void *Result; // If this has been resolved to a resolved pointer - GlobalValue *GV; // If this is a pointer to an LLVM global - const char *ExtSym; // If this is a pointer to a named symbol - unsigned Index; // Constant pool / jump table index - unsigned GOTIndex; // Index in the GOT of this symbol/global + void *Result; // If this has been resolved to a resolved pointer + GlobalValue *GV; // If this is a pointer to a GV or an indirect ref. + MachineBasicBlock *MBB; // If this is a pointer to a LLVM BB + const char *ExtSym; // If this is a pointer to a named symbol + unsigned Index; // Constant pool / jump table index + unsigned GOTIndex; // Index in the GOT of this symbol/global } Target; - unsigned TargetReloType : 6; // The target relocation ID. - AddressType AddrType : 3; // The field of Target to use. - bool DoesntNeedFnStub : 1; // True if we don't need a fn stub. + unsigned TargetReloType : 6; // The target relocation ID + AddressType AddrType : 4; // The field of Target to use + bool MayNeedFarStub : 1; // True if this relocation may require a far-stub bool GOTRelative : 1; // Should this relocation be relative to the GOT? + bool TargetResolve : 1; // True if target should resolve the address public: + // Relocation types used in a generic implementation. Currently, relocation + // entries for all things use the generic VANILLA type until they are refined + // into target relocation types. + enum RelocationType { + VANILLA + }; + /// MachineRelocation::getGV - Return a relocation entry for a GlobalValue. /// - static MachineRelocation getGV(intptr_t offset, unsigned RelocationType, + static MachineRelocation getGV(uintptr_t offset, unsigned RelocationType, GlobalValue *GV, intptr_t cst = 0, - bool DoesntNeedFunctionStub = 0, + bool MayNeedFarStub = 0, bool GOTrelative = 0) { assert((RelocationType & ~63) == 0 && "Relocation type too large!"); MachineRelocation Result; @@ -77,26 +89,66 @@ public: Result.ConstantVal = cst; Result.TargetReloType = RelocationType; Result.AddrType = isGV; - Result.DoesntNeedFnStub = DoesntNeedFunctionStub; + Result.MayNeedFarStub = MayNeedFarStub; + Result.GOTRelative = GOTrelative; + Result.TargetResolve = false; + Result.Target.GV = GV; + return Result; + } + + /// MachineRelocation::getIndirectSymbol - Return a relocation entry for an + /// indirect symbol. + static MachineRelocation getIndirectSymbol(uintptr_t offset, + unsigned RelocationType, + GlobalValue *GV, intptr_t cst = 0, + bool MayNeedFarStub = 0, + bool GOTrelative = 0) { + assert((RelocationType & ~63) == 0 && "Relocation type too large!"); + MachineRelocation Result; + Result.Offset = offset; + Result.ConstantVal = cst; + Result.TargetReloType = RelocationType; + Result.AddrType = isIndirectSym; + Result.MayNeedFarStub = MayNeedFarStub; Result.GOTRelative = GOTrelative; + Result.TargetResolve = false; Result.Target.GV = GV; return Result; } + /// MachineRelocation::getBB - Return a relocation entry for a BB. + /// + static MachineRelocation getBB(uintptr_t offset,unsigned RelocationType, + MachineBasicBlock *MBB, intptr_t cst = 0) { + assert((RelocationType & ~63) == 0 && "Relocation type too large!"); + MachineRelocation Result; + Result.Offset = offset; + Result.ConstantVal = cst; + Result.TargetReloType = RelocationType; + Result.AddrType = isBB; + Result.MayNeedFarStub = false; + Result.GOTRelative = false; + Result.TargetResolve = false; + Result.Target.MBB = MBB; + return Result; + } + /// MachineRelocation::getExtSym - Return a relocation entry for an external /// symbol, like "free". /// - static MachineRelocation getExtSym(intptr_t offset, unsigned RelocationType, + static MachineRelocation getExtSym(uintptr_t offset, unsigned RelocationType, const char *ES, intptr_t cst = 0, - bool GOTrelative = 0) { + bool GOTrelative = 0, + bool NeedStub = true) { assert((RelocationType & ~63) == 0 && "Relocation type too large!"); MachineRelocation Result; Result.Offset = offset; Result.ConstantVal = cst; Result.TargetReloType = RelocationType; Result.AddrType = isExtSym; - Result.DoesntNeedFnStub = false; + Result.MayNeedFarStub = NeedStub; Result.GOTRelative = GOTrelative; + Result.TargetResolve = false; Result.Target.ExtSym = ES; return Result; } @@ -104,16 +156,18 @@ public: /// MachineRelocation::getConstPool - Return a relocation entry for a constant /// pool entry. /// - static MachineRelocation getConstPool(intptr_t offset,unsigned RelocationType, - unsigned CPI, intptr_t cst = 0) { + static MachineRelocation getConstPool(uintptr_t offset,unsigned RelocationType, + unsigned CPI, intptr_t cst = 0, + bool letTargetResolve = false) { assert((RelocationType & ~63) == 0 && "Relocation type too large!"); MachineRelocation Result; Result.Offset = offset; Result.ConstantVal = cst; Result.TargetReloType = RelocationType; Result.AddrType = isConstPool; - Result.DoesntNeedFnStub = false; + Result.MayNeedFarStub = false; Result.GOTRelative = false; + Result.TargetResolve = letTargetResolve; Result.Target.Index = CPI; return Result; } @@ -121,16 +175,18 @@ public: /// MachineRelocation::getJumpTable - Return a relocation entry for a jump /// table entry. /// - static MachineRelocation getJumpTable(intptr_t offset,unsigned RelocationType, - unsigned JTI, intptr_t cst = 0) { + static MachineRelocation getJumpTable(uintptr_t offset,unsigned RelocationType, + unsigned JTI, intptr_t cst = 0, + bool letTargetResolve = false) { assert((RelocationType & ~63) == 0 && "Relocation type too large!"); MachineRelocation Result; Result.Offset = offset; Result.ConstantVal = cst; Result.TargetReloType = RelocationType; Result.AddrType = isJumpTable; - Result.DoesntNeedFnStub = false; + Result.MayNeedFarStub = false; Result.GOTRelative = false; + Result.TargetResolve = letTargetResolve; Result.Target.Index = JTI; return Result; } @@ -154,15 +210,34 @@ public: return ConstantVal; } + /// setConstantVal - Set the constant value associated with this relocation. + /// This is often an offset from the symbol. + /// + void setConstantVal(intptr_t val) { + ConstantVal = val; + } + /// isGlobalValue - Return true if this relocation is a GlobalValue, as /// opposed to a constant string. bool isGlobalValue() const { return AddrType == isGV; } - /// isString - Return true if this is a constant string. + /// isIndirectSymbol - Return true if this relocation is the address an + /// indirect symbol + bool isIndirectSymbol() const { + return AddrType == isIndirectSym; + } + + /// isBasicBlock - Return true if this relocation is a basic block reference. + /// + bool isBasicBlock() const { + return AddrType == isBB; + } + + /// isExternalSymbol - Return true if this is a constant string. /// - bool isString() const { + bool isExternalSymbol() const { return AddrType == isExtSym; } @@ -184,26 +259,39 @@ public: return GOTRelative; } - /// doesntNeedFunctionStub - This function returns true if the JIT for this - /// target is capable of directly handling the relocated instruction without - /// using a stub function. It is always conservatively correct for this flag - /// to be false, but targets can improve their compilation callback functions - /// to handle more general cases if they want improved performance. - bool doesntNeedFunctionStub() const { - return DoesntNeedFnStub; + /// mayNeedFarStub - This function returns true if the JIT for this target may + /// need either a stub function or an indirect global-variable load to handle + /// the relocated GlobalValue reference. For example, the x86-64 call + /// instruction can only call functions within +/-2GB of the call site. + /// Anything farther away needs a longer mov+call sequence, which can't just + /// be written on top of the existing call. + bool mayNeedFarStub() const { + return MayNeedFarStub; + } + + /// letTargetResolve - Return true if the target JITInfo is usually + /// responsible for resolving the address of this relocation. + bool letTargetResolve() const { + return TargetResolve; } /// getGlobalValue - If this is a global value reference, return the /// referenced global. GlobalValue *getGlobalValue() const { - assert(isGlobalValue() && "This is not a global value reference!"); + assert((isGlobalValue() || isIndirectSymbol()) && + "This is not a global value reference!"); return Target.GV; } + MachineBasicBlock *getBasicBlock() const { + assert(isBasicBlock() && "This is not a basic block reference!"); + return Target.MBB; + } + /// getString - If this is a string value, return the string reference. /// - const char *getString() const { - assert(isString() && "This is not a string reference!"); + const char *getExternalSymbol() const { + assert(isExternalSymbol() && "This is not an external symbol reference!"); return Target.ExtSym; }