From ce4a70bd7608861e104b04265a0c71e5df8ecefe Mon Sep 17 00:00:00 2001 From: Evan Cheng Date: Sat, 8 Nov 2008 08:02:53 +0000 Subject: Rename startFunctionStub to startGVStub since it's also used for GV non-lazy ptr. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@58897 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/CodeGen/ELFWriter.cpp | 6 +++--- lib/CodeGen/MachOWriter.cpp | 6 +++--- lib/ExecutionEngine/JIT/JITEmitter.cpp | 12 ++++++------ lib/Target/ARM/ARMJITInfo.cpp | 10 +++++----- lib/Target/Alpha/AlphaJITInfo.cpp | 4 ++-- lib/Target/PowerPC/PPCJITInfo.cpp | 8 ++++---- lib/Target/X86/X86JITInfo.cpp | 18 +++++++++--------- 7 files changed, 32 insertions(+), 32 deletions(-) (limited to 'lib') diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp index 0b6e0b1..ea12d50 100644 --- a/lib/CodeGen/ELFWriter.cpp +++ b/lib/CodeGen/ELFWriter.cpp @@ -115,12 +115,12 @@ namespace llvm { /// JIT SPECIFIC FUNCTIONS - DO NOT IMPLEMENT THESE HERE! - void startFunctionStub(const GlobalValue* F, unsigned StubSize, - unsigned Alignment = 1) { + void startGVStub(const GlobalValue* F, unsigned StubSize, + unsigned Alignment = 1) { assert(0 && "JIT specific function called!"); abort(); } - void *finishFunctionStub(const GlobalValue *F) { + void *finishGVStub(const GlobalValue *F) { assert(0 && "JIT specific function called!"); abort(); return 0; diff --git a/lib/CodeGen/MachOWriter.cpp b/lib/CodeGen/MachOWriter.cpp index e90f1e9..613f680 100644 --- a/lib/CodeGen/MachOWriter.cpp +++ b/lib/CodeGen/MachOWriter.cpp @@ -142,12 +142,12 @@ namespace llvm { virtual void setModuleInfo(llvm::MachineModuleInfo* MMI) { } /// JIT SPECIFIC FUNCTIONS - DO NOT IMPLEMENT THESE HERE! - virtual void startFunctionStub(const GlobalValue* F, unsigned StubSize, - unsigned Alignment = 1) { + virtual void startGVStub(const GlobalValue* F, unsigned StubSize, + unsigned Alignment = 1) { assert(0 && "JIT specific function called!"); abort(); } - virtual void *finishFunctionStub(const GlobalValue* F) { + virtual void *finishGVStub(const GlobalValue* F) { assert(0 && "JIT specific function called!"); abort(); return 0; diff --git a/lib/ExecutionEngine/JIT/JITEmitter.cpp b/lib/ExecutionEngine/JIT/JITEmitter.cpp index 9062cee..7edeba2 100644 --- a/lib/ExecutionEngine/JIT/JITEmitter.cpp +++ b/lib/ExecutionEngine/JIT/JITEmitter.cpp @@ -517,9 +517,9 @@ namespace { void initJumpTableInfo(MachineJumpTableInfo *MJTI); void emitJumpTableInfo(MachineJumpTableInfo *MJTI); - virtual void startFunctionStub(const GlobalValue* F, unsigned StubSize, + virtual void startGVStub(const GlobalValue* GV, unsigned StubSize, unsigned Alignment = 1); - virtual void* finishFunctionStub(const GlobalValue *F); + virtual void* finishGVStub(const GlobalValue *GV); /// allocateSpace - Reserves space in the current block if any, or /// allocate a new one of the given size. @@ -1121,17 +1121,17 @@ void JITEmitter::emitJumpTableInfo(MachineJumpTableInfo *MJTI) { } } -void JITEmitter::startFunctionStub(const GlobalValue* F, unsigned StubSize, - unsigned Alignment) { +void JITEmitter::startGVStub(const GlobalValue* GV, unsigned StubSize, + unsigned Alignment) { SavedBufferBegin = BufferBegin; SavedBufferEnd = BufferEnd; SavedCurBufferPtr = CurBufferPtr; - BufferBegin = CurBufferPtr = MemMgr->allocateStub(F, StubSize, Alignment); + BufferBegin = CurBufferPtr = MemMgr->allocateStub(GV, StubSize, Alignment); BufferEnd = BufferBegin+StubSize+1; } -void *JITEmitter::finishFunctionStub(const GlobalValue* F) { +void *JITEmitter::finishGVStub(const GlobalValue* GV) { NumBytes += getCurrentPCOffset(); // Invalidate the icache if necessary. diff --git a/lib/Target/ARM/ARMJITInfo.cpp b/lib/Target/ARM/ARMJITInfo.cpp index 4118d6d..6ab0c92 100644 --- a/lib/Target/ARM/ARMJITInfo.cpp +++ b/lib/Target/ARM/ARMJITInfo.cpp @@ -135,9 +135,9 @@ ARMJITInfo::getLazyResolverFunction(JITCompilerFn F) { void *ARMJITInfo::emitGlobalValueNonLazyPtr(const GlobalValue *GV, void *Ptr, MachineCodeEmitter &MCE) { - MCE.startFunctionStub(GV, 4, 4); // FIXME: Rename this. + MCE.startGVStub(GV, 4, 4); MCE.emitWordLE((intptr_t)Ptr); - return MCE.finishFunctionStub(GV); + return MCE.finishGVStub(GV); } void *ARMJITInfo::emitFunctionStub(const Function* F, void *Fn, @@ -148,7 +148,7 @@ void *ARMJITInfo::emitFunctionStub(const Function* F, void *Fn, if (Fn != (void*)(intptr_t)ARMCompilationCallback) { // Branch to the corresponding function addr. // The stub is 8-byte size and 4-aligned. - MCE.startFunctionStub(F, 8, 4); + MCE.startGVStub(F, 8, 4); MCE.emitWordLE(0xe51ff004); // LDR PC, [PC,#-4] MCE.emitWordLE(addr); // addr of function } else { @@ -159,7 +159,7 @@ void *ARMJITInfo::emitFunctionStub(const Function* F, void *Fn, // // Branch and link to the compilation callback. // The stub is 16-byte size and 4-byte aligned. - MCE.startFunctionStub(F, 16, 4); + MCE.startGVStub(F, 16, 4); // Save LR so the callback can determine which stub called it. // The compilation callback is responsible for popping this prior // to returning. @@ -172,7 +172,7 @@ void *ARMJITInfo::emitFunctionStub(const Function* F, void *Fn, MCE.emitWordLE((intptr_t)ARMCompilationCallback); } - return MCE.finishFunctionStub(F); + return MCE.finishGVStub(F); } intptr_t ARMJITInfo::resolveRelocDestAddr(MachineRelocation *MR) const { diff --git a/lib/Target/Alpha/AlphaJITInfo.cpp b/lib/Target/Alpha/AlphaJITInfo.cpp index 4fd0ebc..8f36c1f 100644 --- a/lib/Target/Alpha/AlphaJITInfo.cpp +++ b/lib/Target/Alpha/AlphaJITInfo.cpp @@ -195,13 +195,13 @@ void *AlphaJITInfo::emitFunctionStub(const Function* F, void *Fn, MachineCodeEmitter &MCE) { //assert(Fn == AlphaCompilationCallback && "Where are you going?\n"); //Do things in a stupid slow way! - MCE.startFunctionStub(F, 19*4); + MCE.startGVStub(F, 19*4); void* Addr = (void*)(intptr_t)MCE.getCurrentPCValue(); for (int x = 0; x < 19; ++ x) MCE.emitWordLE(0); EmitBranchToAt(Addr, Fn); DOUT << "Emitting Stub to " << Fn << " at [" << Addr << "]\n"; - return MCE.finishFunctionStub(F); + return MCE.finishGVStub(F); } TargetJITInfo::LazyResolverFn diff --git a/lib/Target/PowerPC/PPCJITInfo.cpp b/lib/Target/PowerPC/PPCJITInfo.cpp index 89c6d49..b5de318 100644 --- a/lib/Target/PowerPC/PPCJITInfo.cpp +++ b/lib/Target/PowerPC/PPCJITInfo.cpp @@ -335,7 +335,7 @@ void *PPCJITInfo::emitFunctionStub(const Function* F, void *Fn, // call. The code is the same except for one bit of the last instruction. if (Fn != (void*)(intptr_t)PPC32CompilationCallback && Fn != (void*)(intptr_t)PPC64CompilationCallback) { - MCE.startFunctionStub(F, 7*4); + MCE.startGVStub(F, 7*4); intptr_t Addr = (intptr_t)MCE.getCurrentPCValue(); MCE.emitWordBE(0); MCE.emitWordBE(0); @@ -346,10 +346,10 @@ void *PPCJITInfo::emitFunctionStub(const Function* F, void *Fn, MCE.emitWordBE(0); EmitBranchToAt(Addr, (intptr_t)Fn, false, is64Bit); sys::Memory::InvalidateInstructionCache((void*)Addr, 7*4); - return MCE.finishFunctionStub(F); + return MCE.finishGVStub(F); } - MCE.startFunctionStub(F, 10*4); + MCE.startGVStub(F, 10*4); intptr_t Addr = (intptr_t)MCE.getCurrentPCValue(); if (is64Bit) { MCE.emitWordBE(0xf821ffb1); // stdu r1,-80(r1) @@ -374,7 +374,7 @@ void *PPCJITInfo::emitFunctionStub(const Function* F, void *Fn, MCE.emitWordBE(0); EmitBranchToAt(BranchAddr, (intptr_t)Fn, true, is64Bit); sys::Memory::InvalidateInstructionCache((void*)Addr, 10*4); - return MCE.finishFunctionStub(F); + return MCE.finishGVStub(F); } diff --git a/lib/Target/X86/X86JITInfo.cpp b/lib/Target/X86/X86JITInfo.cpp index ee46657..dee5deb 100644 --- a/lib/Target/X86/X86JITInfo.cpp +++ b/lib/Target/X86/X86JITInfo.cpp @@ -416,14 +416,14 @@ X86JITInfo::getLazyResolverFunction(JITCompilerFn F) { void *X86JITInfo::emitGlobalValueNonLazyPtr(const GlobalValue* GV, void *ptr, MachineCodeEmitter &MCE) { #if defined (X86_64_JIT) - MCE.startFunctionStub(GV, 8, 8); + MCE.startGVStub(GV, 8, 8); MCE.emitWordLE((unsigned)(intptr_t)ptr); MCE.emitWordLE((unsigned)(((intptr_t)ptr) >> 32)); #else - MCE.startFunctionStub(GV, 4, 4); + MCE.startGVStub(GV, 4, 4); MCE.emitWordLE((intptr_t)ptr); #endif - return MCE.finishFunctionStub(GV); + return MCE.finishGVStub(GV); } void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn, @@ -438,7 +438,7 @@ void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn, #endif if (NotCC) { #if defined (X86_64_JIT) - MCE.startFunctionStub(F, 13, 4); + MCE.startGVStub(F, 13, 4); MCE.emitByte(0x49); // REX prefix MCE.emitByte(0xB8+2); // movabsq r10 MCE.emitWordLE((unsigned)(intptr_t)Fn); @@ -447,15 +447,15 @@ void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn, MCE.emitByte(0xFF); // jmpq *r10 MCE.emitByte(2 | (4 << 3) | (3 << 6)); #else - MCE.startFunctionStub(F, 5, 4); + MCE.startGVStub(F, 5, 4); MCE.emitByte(0xE9); MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4); #endif - return MCE.finishFunctionStub(F); + return MCE.finishGVStub(F); } #if defined (X86_64_JIT) - MCE.startFunctionStub(F, 14, 4); + MCE.startGVStub(F, 14, 4); MCE.emitByte(0x49); // REX prefix MCE.emitByte(0xB8+2); // movabsq r10 MCE.emitWordLE((unsigned)(intptr_t)Fn); @@ -464,14 +464,14 @@ void *X86JITInfo::emitFunctionStub(const Function* F, void *Fn, MCE.emitByte(0xFF); // callq *r10 MCE.emitByte(2 | (2 << 3) | (3 << 6)); #else - MCE.startFunctionStub(F, 6, 4); + MCE.startGVStub(F, 6, 4); MCE.emitByte(0xE8); // Call with 32 bit pc-rel destination... MCE.emitWordLE((intptr_t)Fn-MCE.getCurrentPCValue()-4); #endif MCE.emitByte(0xCD); // Interrupt - Just a marker identifying the stub! - return MCE.finishFunctionStub(F); + return MCE.finishGVStub(F); } /// getPICJumpTableEntry - Returns the value of the jumptable entry for the -- cgit v1.1