//
//===----------------------------------------------------------------------===//
-#include "PPC32JITInfo.h"
#include "PPC32TargetMachine.h"
+#include "PPC32Relocations.h"
#include "PowerPC.h"
#include "llvm/Module.h"
#include "llvm/CodeGen/MachineCodeEmitter.h"
#include "llvm/Support/Debug.h"
using namespace llvm;
-namespace {
- class JITResolver {
- MachineCodeEmitter &MCE;
-
- // LazyCodeGenMap - Keep track of call sites for functions that are to be
- // lazily resolved.
- std::map<unsigned, Function*> LazyCodeGenMap;
-
- // LazyResolverMap - Keep track of the lazy resolver created for a
- // particular function so that we can reuse them if necessary.
- std::map<Function*, unsigned> LazyResolverMap;
-
- public:
- JITResolver(MachineCodeEmitter &mce) : MCE(mce) {}
- unsigned getLazyResolver(Function *F);
- unsigned addFunctionReference(unsigned Address, Function *F);
-
- private:
- unsigned emitStubForFunction(Function *F);
- static void CompilationCallback();
- unsigned resolveFunctionReference(unsigned RetAddr);
- };
-
- static JITResolver &getResolver(MachineCodeEmitter &MCE) {
- static JITResolver *TheJITResolver = 0;
- if (TheJITResolver == 0)
- TheJITResolver = new JITResolver(MCE);
- return *TheJITResolver;
- }
-}
-
-unsigned JITResolver::getLazyResolver(Function *F) {
- std::map<Function*, unsigned>::iterator I = LazyResolverMap.lower_bound(F);
- if (I != LazyResolverMap.end() && I->first == F) return I->second;
-
- unsigned Stub = emitStubForFunction(F);
- LazyResolverMap.insert(I, std::make_pair(F, Stub));
- return Stub;
-}
-
-/// addFunctionReference - This method is called when we need to emit the
-/// address of a function that has not yet been emitted, so we don't know the
-/// address. Instead, we emit a call to the CompilationCallback method, and
-/// keep track of where we are.
-///
-unsigned JITResolver::addFunctionReference(unsigned Address, Function *F) {
- LazyCodeGenMap[Address] = F;
- return (intptr_t)&JITResolver::CompilationCallback;
-}
-
-unsigned JITResolver::resolveFunctionReference(unsigned RetAddr) {
- std::map<unsigned, Function*>::iterator I = LazyCodeGenMap.find(RetAddr);
- assert(I != LazyCodeGenMap.end() && "Not in map!");
- Function *F = I->second;
- LazyCodeGenMap.erase(I);
- return MCE.forceCompilationOf(F);
-}
-
-/// emitStubForFunction - This method is used by the JIT when it needs to emit
-/// the address of a function for a function whose code has not yet been
-/// generated. In order to do this, it generates a stub which jumps to the lazy
-/// function compiler, which will eventually get fixed to call the function
-/// directly.
-///
-unsigned JITResolver::emitStubForFunction(Function *F) {
- std::cerr << "PPC32CodeEmitter::emitStubForFunction() unimplemented!\n";
- abort();
- return 0;
-}
-
-void JITResolver::CompilationCallback() {
- std::cerr << "PPC32CodeEmitter: CompilationCallback() unimplemented!";
- abort();
-}
-
namespace {
class PPC32CodeEmitter : public MachineFunctionPass {
TargetMachine &TM;
MachineCodeEmitter &MCE;
+ /// MovePCtoLROffset - When/if we see a MovePCtoLR instruction, we record
+ /// its address in the function into this pointer.
+ void *MovePCtoLROffset;
+
// Tracks which instruction references which BasicBlock
std::vector<std::pair<const BasicBlock*,
std::pair<unsigned*,MachineInstr*> > > BBRefs;
/// getMachineOpValue - evaluates the MachineOperand of a given MachineInstr
///
- int64_t getMachineOpValue(MachineInstr &MI, MachineOperand &MO);
-
- unsigned getAddressOfExternalFunction(Function *F);
+ int getMachineOpValue(MachineInstr &MI, MachineOperand &MO);
public:
PPC32CodeEmitter(TargetMachine &T, MachineCodeEmitter &M)
///
bool PPC32TargetMachine::addPassesToEmitMachineCode(FunctionPassManager &PM,
MachineCodeEmitter &MCE) {
- // Keep as `true' until this is a functional JIT to allow llvm-gcc to build
- return true;
-
// Machine code emitter pass for PowerPC
PM.add(new PPC32CodeEmitter(*this, MCE));
// Delete machine code for this function after emitting it
}
bool PPC32CodeEmitter::runOnMachineFunction(MachineFunction &MF) {
+ MovePCtoLROffset = 0;
MCE.startFunction(MF);
MCE.emitConstantPool(MF.getConstantPool());
for (MachineFunction::iterator BB = MF.begin(), E = MF.end(); BB != E; ++BB)
// Resolve branches to BasicBlocks for the entire function
for (unsigned i = 0, e = BBRefs.size(); i != e; ++i) {
- long Location = BBLocations[BBRefs[i].first];
+ intptr_t Location = BBLocations[BBRefs[i].first];
unsigned *Ref = BBRefs[i].second.first;
MachineInstr *MI = BBRefs[i].second.second;
- DEBUG(std::cerr << "Fixup @ " << std::hex << Ref << " to 0x" << Location
- << " in instr: " << std::dec << *MI);
+ DEBUG(std::cerr << "Fixup @ " << (void*)Ref << " to " << (void*)Location
+ << " in instr: " << *MI);
for (unsigned ii = 0, ee = MI->getNumOperands(); ii != ee; ++ii) {
MachineOperand &op = MI->getOperand(ii);
if (op.isPCRelativeDisp()) {
for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E; ++I){
MachineInstr &MI = *I;
unsigned Opcode = MI.getOpcode();
- if (Opcode == PPC::IMPLICIT_DEF)
- continue; // pseudo opcode, no side effects
- else if (Opcode == PPC::MovePCtoLR) {
- // This can be simplified: the resulting 32-bit code is 0x48000005
- MachineInstr *MI = BuildMI(PPC::BL, 1).addImm(1);
- emitWord(getBinaryCodeForInstr(*MI));
- delete MI;
- } else
+ switch (MI.getOpcode()) {
+ default:
emitWord(getBinaryCodeForInstr(*I));
+ break;
+ case PPC::IMPLICIT_DEF:
+ break; // pseudo opcode, no side effects
+ case PPC::MovePCtoLR:
+ assert(MovePCtoLROffset == 0 &&
+ "Multiple MovePCtoLR instructions in the function?");
+ MovePCtoLROffset = (void*)(intptr_t)MCE.getCurrentPCValue();
+ emitWord(0x48000005); // bl 1
+ break;
+ }
}
}
-unsigned PPC32CodeEmitter::getAddressOfExternalFunction(Function *F) {
- static std::map<Function*, unsigned> ExternalFn2Addr;
- std::map<Function*, unsigned>::iterator Addr = ExternalFn2Addr.find(F);
-
- if (Addr == ExternalFn2Addr.end())
- ExternalFn2Addr[F] = MCE.forceCompilationOf(F);
- return ExternalFn2Addr[F];
-}
-
static unsigned enumRegToMachineReg(unsigned enumReg) {
switch (enumReg) {
- case PPC::R0 : case PPC::F0 : return 0;
- case PPC::R1 : case PPC::F1 : return 1;
- case PPC::R2 : case PPC::F2 : return 2;
- case PPC::R3 : case PPC::F3 : return 3;
- case PPC::R4 : case PPC::F4 : return 4;
- case PPC::R5 : case PPC::F5 : return 5;
- case PPC::R6 : case PPC::F6 : return 6;
- case PPC::R7 : case PPC::F7 : return 7;
+ case PPC::R0 : case PPC::F0 : case PPC::CR0: return 0;
+ case PPC::R1 : case PPC::F1 : case PPC::CR1: return 1;
+ case PPC::R2 : case PPC::F2 : case PPC::CR2: return 2;
+ case PPC::R3 : case PPC::F3 : case PPC::CR3: return 3;
+ case PPC::R4 : case PPC::F4 : case PPC::CR4: return 4;
+ case PPC::R5 : case PPC::F5 : case PPC::CR5: return 5;
+ case PPC::R6 : case PPC::F6 : case PPC::CR6: return 6;
+ case PPC::R7 : case PPC::F7 : case PPC::CR7: return 7;
case PPC::R8 : case PPC::F8 : return 8;
case PPC::R9 : case PPC::F9 : return 9;
case PPC::R10: case PPC::F10: return 10;
}
}
-int64_t PPC32CodeEmitter::getMachineOpValue(MachineInstr &MI,
- MachineOperand &MO) {
- int64_t rv = 0; // Return value; defaults to 0 for unhandled cases
+int PPC32CodeEmitter::getMachineOpValue(MachineInstr &MI, MachineOperand &MO) {
+
+ int rv = 0; // Return value; defaults to 0 for unhandled cases
// or things that get fixed up later by the JIT.
if (MO.isRegister()) {
rv = enumRegToMachineReg(MO.getReg());
} else if (MO.isImmediate()) {
rv = MO.getImmedValue();
} else if (MO.isGlobalAddress()) {
- GlobalValue *GV = MO.getGlobal();
- rv = MCE.getGlobalValueAddress(GV);
- if (rv == 0) {
- if (Function *F = dyn_cast<Function>(GV)) {
- if (F->isExternal())
- rv = getAddressOfExternalFunction(F);
- else {
- // Function has not yet been code generated! Use lazy resolution.
- getResolver(MCE).addFunctionReference(MCE.getCurrentPCValue(), F);
- rv = getResolver(MCE).getLazyResolver(F);
- }
- } else if (GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
- if (GVar->isExternal()) {
- rv = MCE.getGlobalValueAddress(MO.getSymbolName());
- if (!rv) {
- std::cerr << "PPC32CodeEmitter: External global addr not found: "
- << *GVar;
- abort();
- }
- } else {
- std::cerr << "PPC32CodeEmitter: global addr not found: " << *GVar;
- abort();
- }
- }
- }
- if (MO.isPCRelative()) { // Global variable reference
- rv = (rv - MCE.getCurrentPCValue()) >> 2;
+ unsigned Reloc = 0;
+ if (MI.getOpcode() == PPC::CALLpcrel)
+ Reloc = PPC::reloc_pcrel_bx;
+ else if (MI.getOpcode() == PPC::LOADHiAddr) {
+ Reloc = PPC::reloc_absolute_loadhi;
+ } else if (MI.getOpcode() == PPC::LA) {
+ Reloc = PPC::reloc_absolute_la;
+ } else {
+ assert(0 && "Unknown instruction for relocation!");
}
+ MCE.addRelocation(MachineRelocation(MCE.getCurrentPCOffset(),
+ Reloc, MO.getGlobal(),
+ -((intptr_t)MovePCtoLROffset+4)));
} else if (MO.isMachineBasicBlock()) {
const BasicBlock *BB = MO.getMachineBasicBlock()->getBasicBlock();
unsigned* CurrPC = (unsigned*)(intptr_t)MCE.getCurrentPCValue();
} else if (MO.isConstantPoolIndex()) {
unsigned index = MO.getConstantPoolIndex();
rv = MCE.getConstantPoolEntryAddress(index);
- } else if (MO.isFrameIndex()) {
- std::cerr << "PPC32CodeEmitter: error: Frame index unhandled!\n";
- abort();
} else {
std::cerr << "ERROR: Unknown type of MachineOperand: " << MO << "\n";
abort();
}
// Special treatment for global symbols: constants and vars
- if (MO.isConstantPoolIndex() || MO.isGlobalAddress()) {
+ if ((MO.isConstantPoolIndex() || MO.isGlobalAddress()) &&
+ MI.getOpcode() != PPC::CALLpcrel) {
unsigned Opcode = MI.getOpcode();
- int64_t MBBLoc = BBLocations[MI.getParent()->getBasicBlock()];
+ assert(MovePCtoLROffset && "MovePCtoLR not seen yet?");
+
if (Opcode == PPC::LOADHiAddr) {
- // LoadHiAddr wants hi16(addr - mbb)
- rv = (rv - MBBLoc) >> 16;
+ // LoadHiAddr wants hi16(addr - &MovePCtoLR)
+ rv >>= 16;
} else if (Opcode == PPC::LWZ || Opcode == PPC::LA ||
Opcode == PPC::LFS || Opcode == PPC::LFD) {
- // These load opcodes want lo16(addr - mbb)
- rv = (rv - MBBLoc) & 0xffff;
+ // These load opcodes want lo16(addr - &MovePCtoLR)
+ rv &= 0xffff;
}
}
-
return rv;
}
-void PPC32JITInfo::replaceMachineCodeForFunction (void *Old, void *New) {
- std::cerr << "PPC32JITInfo::replaceMachineCodeForFunction not implemented\n";
- abort();
-}
-
#include "PPC32GenCodeEmitter.inc"
projects / oota-llvm.git / blobdiff