X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineRelocation.h;h=244b466e172826a465e2ed6143cd04cba3aa7b97;hb=980bddfb1c26e2e9374d1645f9ae26c44742606f;hp=c43fcb64e0c3cbe74da40b21a0892f2b3e9d6497;hpb=1e3822c7761933b588048b8128b12d495d312703;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineRelocation.h b/include/llvm/CodeGen/MachineRelocation.h index c43fcb64e0c..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,61 +39,161 @@ 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, // The Target.ConstPool field is valid. + isConstPool, // Relocation of constant pool address. + isJumpTable, // Relocation of jump table address. isGOTIndex // The Target.GOTIndex field is valid. }; /// Offset - This is the offset from the start of the code buffer of the /// relocation to perform. - unsigned 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 ConstPool; // In this is a pointer to a constant pool entry - 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: - MachineRelocation(unsigned offset, unsigned RelocationType, GlobalValue *GV, - intptr_t cst = 0, bool DoesntNeedFunctionStub = 0, - bool GOTrelative = 0) - : Offset(offset), ConstantVal(cst), TargetReloType(RelocationType), - AddrType(isGV), DoesntNeedFnStub(DoesntNeedFunctionStub), - GOTRelative(GOTrelative){ + // 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(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!"); - Target.GV = GV; + MachineRelocation Result; + Result.Offset = offset; + Result.ConstantVal = cst; + Result.TargetReloType = RelocationType; + Result.AddrType = isGV; + Result.MayNeedFarStub = MayNeedFarStub; + Result.GOTRelative = GOTrelative; + Result.TargetResolve = false; + Result.Target.GV = GV; + return Result; } - MachineRelocation(unsigned offset, unsigned RelocationType, const char *ES, - intptr_t cst = 0, bool GOTrelative = 0) - : Offset(offset), ConstantVal(cst), TargetReloType(RelocationType), - AddrType(isExtSym), DoesntNeedFnStub(false), GOTRelative(GOTrelative) { + /// 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!"); - Target.ExtSym = ES; + 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(unsigned offset, unsigned RelocationType, unsigned CPI, - intptr_t cst = 0) - : Offset(offset), ConstantVal(cst), TargetReloType(RelocationType), - AddrType(isConstPool), DoesntNeedFnStub(false), GOTRelative(0) { + /// 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!"); - Target.ConstPool = CPI; + 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(uintptr_t offset, unsigned RelocationType, + const char *ES, intptr_t cst = 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.MayNeedFarStub = NeedStub; + Result.GOTRelative = GOTrelative; + Result.TargetResolve = false; + Result.Target.ExtSym = ES; + return Result; + } + + /// MachineRelocation::getConstPool - Return a relocation entry for a constant + /// pool entry. + /// + 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.MayNeedFarStub = false; + Result.GOTRelative = false; + Result.TargetResolve = letTargetResolve; + Result.Target.Index = CPI; + return Result; + } + + /// MachineRelocation::getJumpTable - Return a relocation entry for a jump + /// table entry. + /// + 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.MayNeedFarStub = false; + Result.GOTRelative = false; + Result.TargetResolve = letTargetResolve; + Result.Target.Index = JTI; + return Result; } /// getMachineCodeOffset - Return the offset into the code buffer that the /// relocation should be performed. - unsigned getMachineCodeOffset() const { + intptr_t getMachineCodeOffset() const { return Offset; } @@ -109,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 isString() const { + bool isBasicBlock() const { + return AddrType == isBB; + } + + /// isExternalSymbol - Return true if this is a constant string. + /// + bool isExternalSymbol() const { return AddrType == isExtSym; } @@ -127,32 +247,51 @@ public: return AddrType == isConstPool; } + /// isJumpTableIndex - Return true if this is a jump table reference. + /// + bool isJumpTableIndex() const { + return AddrType == isJumpTable; + } + /// isGOTRelative - Return true the target wants the index into the GOT of /// the symbol rather than the address of the symbol. bool isGOTRelative() const { 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; } @@ -160,7 +299,14 @@ public: /// the index into the constant pool. unsigned getConstantPoolIndex() const { assert(isConstantPoolIndex() && "This is not a constant pool reference!"); - return Target.ConstPool; + return Target.Index; + } + + /// getJumpTableIndex - If this is a jump table reference, return + /// the index into the jump table. + unsigned getJumpTableIndex() const { + assert(isJumpTableIndex() && "This is not a jump table reference!"); + return Target.Index; } /// getResultPointer - Once this has been resolved to point to an actual