X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineRelocation.h;h=244b466e172826a465e2ed6143cd04cba3aa7b97;hb=425e951734c3a0615e22ec94ffa51cc16ce6e483;hp=fc853d131725209c5308100d8ac540fd3eed8b3c;hpb=7ed47a13356daed2a34cd2209a31f92552e3bdd8;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineRelocation.h b/include/llvm/CodeGen/MachineRelocation.h index fc853d13172..244b466e172 100644 --- a/include/llvm/CodeGen/MachineRelocation.h +++ b/include/llvm/CodeGen/MachineRelocation.h @@ -39,6 +39,7 @@ 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. @@ -48,24 +49,25 @@ 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 + 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 : 4; // 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 @@ -77,9 +79,9 @@ public: /// 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; @@ -87,15 +89,36 @@ 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(intptr_t offset,unsigned RelocationType, + static MachineRelocation getBB(uintptr_t offset,unsigned RelocationType, MachineBasicBlock *MBB, intptr_t cst = 0) { assert((RelocationType & ~63) == 0 && "Relocation type too large!"); MachineRelocation Result; @@ -103,8 +126,9 @@ public: Result.ConstantVal = cst; Result.TargetReloType = RelocationType; Result.AddrType = isBB; - Result.DoesntNeedFnStub = false; + Result.MayNeedFarStub = false; Result.GOTRelative = false; + Result.TargetResolve = false; Result.Target.MBB = MBB; return Result; } @@ -112,17 +136,19 @@ public: /// 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; } @@ -130,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; } @@ -147,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; } @@ -193,15 +223,21 @@ public: return AddrType == isGV; } + /// 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; } - /// isString - Return true if this is a constant string. + /// isExternalSymbol - Return true if this is a constant string. /// - bool isString() const { + bool isExternalSymbol() const { return AddrType == isExtSym; } @@ -223,19 +259,27 @@ 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; } @@ -246,8 +290,8 @@ public: /// 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; }