RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-02 08:46:37 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Rename isGVNonLazyPtr to isIndirectSym to reflect how it will be used.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@58949 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Evan Cheng 2008-11-10 01:08:07 +00:00
parent 8f24cc237f
commit 9ed2f80910
8 changed files with 48 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
include/llvm/CodeGen/MachineRelocation.h
View File

@ -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;
}

12
include/llvm/Target/TargetJITInfo.h
View File

@ -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;
}

2
lib/Target/ARM/ARMCodeEmitter.cpp
View File

@ -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

4
lib/Target/ARM/ARMJITInfo.cpp
View File

@ -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);

8
lib/Target/ARM/ARMJITInfo.h
View File

@ -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

26
lib/Target/X86/X86CodeEmitter.cpp
View File

@ -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<Function>(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<Function>(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<Function>(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<Function>(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())

4
lib/Target/X86/X86JITInfo.cpp
View File

@ -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);

10
lib/Target/X86/X86JITInfo.h
View File

@ -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