From 9ed2f80910160bbf8051d91cd74c82d4619885b4 Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Mon, 10 Nov 2008 01:08:07 +0000 Subject: [PATCH] Rename isGVNonLazyPtr to isIndirectSym to reflect how it will be used. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@58949 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/MachineRelocation.h | 30 +++++++++++++++--------------- include/llvm/Target/TargetJITInfo.h | 12 ++++++------ lib/Target/ARM/ARMCodeEmitter.cpp | 2 +- lib/Target/ARM/ARMJITInfo.cpp | 4 ++-- lib/Target/ARM/ARMJITInfo.h | 8 ++++---- lib/Target/X86/X86CodeEmitter.cpp | 26 +++++++++++++------------- lib/Target/X86/X86JITInfo.cpp | 4 ++-- lib/Target/X86/X86JITInfo.h | 10 +++++----- 8 files changed, 48 insertions(+), 48 deletions(-) diff --git a/include/llvm/CodeGen/MachineRelocation.h b/include/llvm/CodeGen/MachineRelocation.h index 80cd035445b..2181e20aeb9 100644 --- a/include/llvm/CodeGen/MachineRelocation.h +++ b/include/llvm/CodeGen/MachineRelocation.h @@ -39,7 +39,7 @@ class MachineRelocation { enum AddressType { isResult, // Relocation has be transformed into its result pointer. isGV, // The Target.GV field is valid. - isGVNonLazyPtr, // Relocation of a Mac OS X NonLazy indirect reference. + isIndirectSym, // Relocation of an indirect symbol. isBB, // Relocation of BB address. isExtSym, // The Target.ExtSym field is valid. isConstPool, // Relocation of constant pool address. @@ -56,7 +56,7 @@ class MachineRelocation { union { void *Result; // If this has been resolved to a resolved pointer - GlobalValue *GV; // If this is a pointer to a GV or a GV nonlazy ptr + 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 @@ -96,19 +96,19 @@ public: return Result; } - /// MachineRelocation::getGVNonLazyPtr - Return a relocation entry for a - /// Mac OS X non-lazy GlobalValue indirect reference. - static MachineRelocation getGVNonLazyPtr(intptr_t offset, - unsigned RelocationType, - GlobalValue *GV, intptr_t cst = 0, - bool NeedStub = 0, - bool GOTrelative = 0) { + /// MachineRelocation::getIndirectSymbol - Return a relocation entry for an + /// indirect symbol. + static MachineRelocation getIndirectSymbol(intptr_t offset, + unsigned RelocationType, + GlobalValue *GV, intptr_t cst = 0, + bool NeedStub = 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 = isGVNonLazyPtr; + Result.AddrType = isIndirectSym; Result.NeedStub = NeedStub; Result.GOTRelative = GOTrelative; Result.TargetResolve = false; @@ -222,10 +222,10 @@ public: return AddrType == isGV; } - /// isGlobalValueNonLazyPtr - Return true if this relocation is the address - /// of a Mac OS X non-lazy indirect reference. - bool isGlobalValueNonLazyPtr() const { - return AddrType == isGVNonLazyPtr; + /// 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. @@ -275,7 +275,7 @@ public: /// getGlobalValue - If this is a global value reference, return the /// referenced global. GlobalValue *getGlobalValue() const { - assert((isGlobalValue() || isGlobalValueNonLazyPtr()) && + assert((isGlobalValue() || isIndirectSymbol()) && "This is not a global value reference!"); return Target.GV; } diff --git a/include/llvm/Target/TargetJITInfo.h b/include/llvm/Target/TargetJITInfo.h index 45aae06e3f3..0ae24169b86 100644 --- a/include/llvm/Target/TargetJITInfo.h +++ b/include/llvm/Target/TargetJITInfo.h @@ -40,12 +40,12 @@ namespace llvm { /// virtual void replaceMachineCodeForFunction(void *Old, void *New) = 0; - /// emitGlobalValueNonLazyPtr - Use the specified MachineCodeEmitter object - /// to emit a Mac OS X non-lazy pointer which contains the address of the - /// specified ptr. - virtual void *emitGlobalValueNonLazyPtr(const GlobalValue* GV, void *ptr, - MachineCodeEmitter &MCE) { - assert(0 && "This target doesn't implement emitGlobalValueNonLazyPtr!"); + /// emitGlobalValueIndirectSym - Use the specified MachineCodeEmitter object + /// to emit an indirect symbol which contains the address of the specified + /// ptr. + virtual void *emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr, + MachineCodeEmitter &MCE) { + assert(0 && "This target doesn't implement emitGlobalValueIndirectSym!"); return 0; } diff --git a/lib/Target/ARM/ARMCodeEmitter.cpp b/lib/Target/ARM/ARMCodeEmitter.cpp index 92d8713bca7..ddd2564d9ef 100644 --- a/lib/Target/ARM/ARMCodeEmitter.cpp +++ b/lib/Target/ARM/ARMCodeEmitter.cpp @@ -337,7 +337,7 @@ void ARMCodeEmitter::emitConstPoolInstruction(const MachineInstr &MI) { if (GV) { assert(!ACPV->isStub() && "Don't know how to deal this yet!"); if (ACPV->isNonLazyPointer()) - MCE.addRelocation(MachineRelocation::getGVNonLazyPtr( + MCE.addRelocation(MachineRelocation::getIndirectSymbol( MCE.getCurrentPCOffset(), ARM::reloc_arm_machine_cp_entry, GV, (intptr_t)ACPV, false)); else diff --git a/lib/Target/ARM/ARMJITInfo.cpp b/lib/Target/ARM/ARMJITInfo.cpp index c88d864ac71..3ce311784da 100644 --- a/lib/Target/ARM/ARMJITInfo.cpp +++ b/lib/Target/ARM/ARMJITInfo.cpp @@ -129,8 +129,8 @@ ARMJITInfo::getLazyResolverFunction(JITCompilerFn F) { return ARMCompilationCallback; } -void *ARMJITInfo::emitGlobalValueNonLazyPtr(const GlobalValue *GV, void *Ptr, - MachineCodeEmitter &MCE) { +void *ARMJITInfo::emitGlobalValueIndirectSym(const GlobalValue *GV, void *Ptr, + MachineCodeEmitter &MCE) { MCE.startGVStub(GV, 4, 4); MCE.emitWordLE((intptr_t)Ptr); return MCE.finishGVStub(GV); diff --git a/lib/Target/ARM/ARMJITInfo.h b/lib/Target/ARM/ARMJITInfo.h index fe1ea1029e2..a35611eaa3a 100644 --- a/lib/Target/ARM/ARMJITInfo.h +++ b/lib/Target/ARM/ARMJITInfo.h @@ -51,10 +51,10 @@ namespace llvm { /// virtual void replaceMachineCodeForFunction(void *Old, void *New); - /// emitGlobalValueNonLazyPtr - Use the specified MachineCodeEmitter object - /// to emit a Mac OS X non-lazy pointer which contains the address of the - /// specified ptr. - virtual void *emitGlobalValueNonLazyPtr(const GlobalValue *GV, void *Ptr, + /// emitGlobalValueIndirectSym - Use the specified MachineCodeEmitter object + /// to emit an indirect symbol which contains the address of the specified + /// ptr. + virtual void *emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr, MachineCodeEmitter &MCE); /// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a diff --git a/lib/Target/X86/X86CodeEmitter.cpp b/lib/Target/X86/X86CodeEmitter.cpp index fabb67ee2df..f8bff1ac2f4 100644 --- a/lib/Target/X86/X86CodeEmitter.cpp +++ b/lib/Target/X86/X86CodeEmitter.cpp @@ -73,7 +73,7 @@ namespace { void emitPCRelativeBlockAddress(MachineBasicBlock *MBB); void emitGlobalAddress(GlobalValue *GV, unsigned Reloc, intptr_t Disp = 0, intptr_t PCAdj = 0, - bool NeedStub = false, bool IsNonLazy = false); + bool NeedStub = false, bool Indirect = false); void emitExternalSymbolAddress(const char *ES, unsigned Reloc); void emitConstPoolAddress(unsigned CPI, unsigned Reloc, intptr_t Disp = 0, intptr_t PCAdj = 0); @@ -155,15 +155,15 @@ void Emitter::emitGlobalAddress(GlobalValue *GV, unsigned Reloc, intptr_t Disp /* = 0 */, intptr_t PCAdj /* = 0 */, bool NeedStub /* = false */, - bool isNonLazy /* = false */) { + bool Indirect /* = false */) { intptr_t RelocCST = 0; if (Reloc == X86::reloc_picrel_word) RelocCST = PICBaseOffset; else if (Reloc == X86::reloc_pcrel_word) RelocCST = PCAdj; - MachineRelocation MR = isNonLazy - ? MachineRelocation::getGVNonLazyPtr(MCE.getCurrentPCOffset(), Reloc, - GV, RelocCST, NeedStub) + MachineRelocation MR = Indirect + ? MachineRelocation::getIndirectSymbol(MCE.getCurrentPCOffset(), Reloc, + GV, RelocCST, NeedStub) : MachineRelocation::getGV(MCE.getCurrentPCOffset(), Reloc, GV, RelocCST, NeedStub); MCE.addRelocation(MR); @@ -289,9 +289,9 @@ void Emitter::emitDisplacementField(const MachineOperand *RelocOp, unsigned rt = Is64BitMode ? X86::reloc_pcrel_word : (IsPIC ? X86::reloc_picrel_word : X86::reloc_absolute_word); bool NeedStub = isa(RelocOp->getGlobal()); - bool isNonLazy = gvNeedsNonLazyPtr(RelocOp->getGlobal()); + bool Indirect = gvNeedsNonLazyPtr(RelocOp->getGlobal()); emitGlobalAddress(RelocOp->getGlobal(), rt, RelocOp->getOffset(), - PCAdj, NeedStub, isNonLazy); + PCAdj, NeedStub, Indirect); } else if (RelocOp->isCPI()) { unsigned rt = Is64BitMode ? X86::reloc_pcrel_word : X86::reloc_picrel_word; emitConstPoolAddress(RelocOp->getIndex(), rt, @@ -610,9 +610,9 @@ void Emitter::emitInstruction(const MachineInstr &MI, rt = X86::reloc_absolute_dword; // FIXME: add X86II flag? if (MO1.isGlobal()) { bool NeedStub = isa(MO1.getGlobal()); - bool isNonLazy = gvNeedsNonLazyPtr(MO1.getGlobal()); + bool Indirect = gvNeedsNonLazyPtr(MO1.getGlobal()); emitGlobalAddress(MO1.getGlobal(), rt, MO1.getOffset(), 0, - NeedStub, isNonLazy); + NeedStub, Indirect); } else if (MO1.isSymbol()) emitExternalSymbolAddress(MO1.getSymbolName(), rt); else if (MO1.isCPI()) @@ -688,9 +688,9 @@ void Emitter::emitInstruction(const MachineInstr &MI, rt = X86::reloc_absolute_word; // FIXME: add X86II flag? if (MO1.isGlobal()) { bool NeedStub = isa(MO1.getGlobal()); - bool isNonLazy = gvNeedsNonLazyPtr(MO1.getGlobal()); + bool Indirect = gvNeedsNonLazyPtr(MO1.getGlobal()); emitGlobalAddress(MO1.getGlobal(), rt, MO1.getOffset(), 0, - NeedStub, isNonLazy); + NeedStub, Indirect); } else if (MO1.isSymbol()) emitExternalSymbolAddress(MO1.getSymbolName(), rt); else if (MO1.isCPI()) @@ -726,9 +726,9 @@ void Emitter::emitInstruction(const MachineInstr &MI, rt = X86::reloc_absolute_word; // FIXME: add X86II flag? if (MO.isGlobal()) { bool NeedStub = isa(MO.getGlobal()); - bool isNonLazy = gvNeedsNonLazyPtr(MO.getGlobal()); + bool Indirect = gvNeedsNonLazyPtr(MO.getGlobal()); emitGlobalAddress(MO.getGlobal(), rt, MO.getOffset(), 0, - NeedStub, isNonLazy); + NeedStub, Indirect); } else if (MO.isSymbol()) emitExternalSymbolAddress(MO.getSymbolName(), rt); else if (MO.isCPI()) diff --git a/lib/Target/X86/X86JITInfo.cpp b/lib/Target/X86/X86JITInfo.cpp index dee5deb2106..951999640ab 100644 --- a/lib/Target/X86/X86JITInfo.cpp +++ b/lib/Target/X86/X86JITInfo.cpp @@ -413,8 +413,8 @@ X86JITInfo::getLazyResolverFunction(JITCompilerFn F) { return X86CompilationCallback; } -void *X86JITInfo::emitGlobalValueNonLazyPtr(const GlobalValue* GV, void *ptr, - MachineCodeEmitter &MCE) { +void *X86JITInfo::emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr, + MachineCodeEmitter &MCE) { #if defined (X86_64_JIT) MCE.startGVStub(GV, 8, 8); MCE.emitWordLE((unsigned)(intptr_t)ptr); diff --git a/lib/Target/X86/X86JITInfo.h b/lib/Target/X86/X86JITInfo.h index 65a417dde84..dd266364333 100644 --- a/lib/Target/X86/X86JITInfo.h +++ b/lib/Target/X86/X86JITInfo.h @@ -37,11 +37,11 @@ namespace llvm { /// virtual void replaceMachineCodeForFunction(void *Old, void *New); - /// emitGlobalValueNonLazyPtr - Use the specified MachineCodeEmitter object - /// to emit a Mac OS X non-lazy pointer which contains the address of the - /// specified ptr. - virtual void *emitGlobalValueNonLazyPtr(const GlobalValue* GV, void *ptr, - MachineCodeEmitter &MCE); + /// emitGlobalValueIndirectSym - Use the specified MachineCodeEmitter object + /// to emit an indirect symbol which contains the address of the specified + /// ptr. + virtual void *emitGlobalValueIndirectSym(const GlobalValue* GV, void *ptr, + MachineCodeEmitter &MCE); /// emitFunctionStub - Use the specified MachineCodeEmitter object to emit a /// small native function that simply calls the function at the specified -- 2.11.0