TD = ((ARMTargetMachine&)MF.getTarget()).getTargetData();
JTI = ((ARMTargetMachine&)MF.getTarget()).getJITInfo();
MCPEs = &MF.getConstantPool()->getConstants();
- JTI->ResizeConstPoolMap(MCPEs->size());
+ JTI->Initialize(MCPEs);
do {
DOUT << "JITTing function '" << MF.getFunction()->getName() << "'\n";
}
void ARMCodeEmitter::emitInstruction(const MachineInstr &MI) {
- DOUT << "JIT: " << "0x" << MCE.getCurrentPCValue() << ":\t" << MI;
+ DOUT << "JIT: " << (void*)MCE.getCurrentPCValue() << ":\t" << MI;
NumEmitted++; // Keep track of the # of mi's emitted
if ((MI.getDesc().TSFlags & ARMII::FormMask) == ARMII::Pseudo)
GlobalValue *GV = ACPV->getGV();
if (GV) {
assert(!ACPV->isStub() && "Don't know how to deal this yet!");
- emitGlobalAddress(GV, ARM::reloc_arm_absolute, false);
- } else {
+ MCE.addRelocation(MachineRelocation::getGV(MCE.getCurrentPCOffset(),
+ ARM::reloc_arm_machine_cp_entry,
+ GV, CPIndex, false));
+ } else {
assert(!ACPV->isNonLazyPointer() && "Don't know how to deal this yet!");
emitExternalSymbolAddress(ACPV->getSymbol(), ARM::reloc_arm_absolute);
}
emitConstPoolInstruction(MI);
break;
case ARM::PICADD: {
+ // Remember of the address of the PC label for relocation later.
+ const MachineOperand &MO2 = MI.getOperand(2);
+ DOUT << "\t** LPC" << MO2.getImm() << " @ "
+ << (void*)MCE.getCurrentPCValue() << '\n';
+ JTI->addPCLabelAddr(MO2.getImm(), MCE.getCurrentPCValue());
+
// PICADD is just an add instruction that implicitly read pc.
unsigned Binary = getBinaryCodeForInstr(MI);
const TargetInstrDesc &TID = MI.getDesc();
else if (isStub()) O << "$stub";
if (Modifier) O << "(" << Modifier << ")";
if (PCAdjust != 0) {
- O << "-(LPIC" << LabelId << "+"
- << (unsigned)PCAdjust;
- if (AddCurrentAddress)
- O << "-.";
+ O << "-(LPC" << LabelId << "+" << (unsigned)PCAdjust;
+ if (AddCurrentAddress) O << "-.";
O << ")";
}
}
#define DEBUG_TYPE "jit"
#include "ARMJITInfo.h"
+#include "ARMConstantPoolValue.h"
#include "ARMRelocations.h"
#include "ARMSubtarget.h"
#include "llvm/Function.h"
return MCE.finishFunctionStub(F);
}
+intptr_t ARMJITInfo::resolveRelocationAddr(MachineRelocation *MR) const {
+ ARM::RelocationType RT = (ARM::RelocationType)MR->getRelocationType();
+ if (RT == ARM::reloc_arm_cp_entry)
+ return getConstantPoolEntryAddr(MR->getConstantPoolIndex());
+ else if (RT == ARM::reloc_arm_machine_cp_entry) {
+ const MachineConstantPoolEntry &MCPE = (*MCPEs)[MR->getConstantVal()];
+ assert(MCPE.isMachineConstantPoolEntry() &&
+ "Expecting a machine constant pool entry!");
+ ARMConstantPoolValue *ACPV =
+ static_cast<ARMConstantPoolValue*>(MCPE.Val.MachineCPVal);
+ assert((!ACPV->hasModifier() && !ACPV->mustAddCurrentAddress()) &&
+ "Can't handle this machine constant pool entry yet!");
+ intptr_t Addr = (intptr_t)(MR->getResultPointer());
+ Addr -= getPCLabelAddr(ACPV->getLabelId()) + ACPV->getPCAdjustment();
+ return Addr;
+ }
+ return (intptr_t)(MR->getResultPointer());
+}
+
/// relocate - Before the JIT can run a block of code that has been emitted,
/// it must rewrite the code to contain the actual addresses of any
/// referenced global symbols.
unsigned NumRelocs, unsigned char* GOTBase) {
for (unsigned i = 0; i != NumRelocs; ++i, ++MR) {
void *RelocPos = (char*)Function + MR->getMachineCodeOffset();
- ARM::RelocationType RT = (ARM::RelocationType)MR->getRelocationType();
// If this is a constpool relocation, get the address of the
// constpool_entry instruction.
- intptr_t ResultPtr = (RT == ARM::reloc_arm_cp_entry)
- ? getConstantPoolEntryAddr(MR->getConstantPoolIndex())
- : (intptr_t)MR->getResultPointer();
+ intptr_t ResultPtr = resolveRelocationAddr(MR);
switch ((ARM::RelocationType)MR->getRelocationType()) {
case ARM::reloc_arm_cp_entry:
case ARM::reloc_arm_relative: {
if (ResultPtr >= 0)
*((unsigned*)RelocPos) |= 1 << 23;
else {
- // otherwise, obtain the absolute value and set
+ // Otherwise, obtain the absolute value and set
// bit U(23) to 0.
ResultPtr *= -1;
*((unsigned*)RelocPos) &= 0xFF7FFFFF;
}
- // set the immed value calculated
+ // Set the immed value calculated.
*((unsigned*)RelocPos) |= (unsigned)ResultPtr;
- // set register Rn to PC
+ // Set register Rn to PC.
*((unsigned*)RelocPos) |= 0xF << 16;
break;
}
+ case ARM::reloc_arm_machine_cp_entry:
case ARM::reloc_arm_absolute: {
+ // These addresses have already been resolved.
*((unsigned*)RelocPos) += (unsigned)ResultPtr;
break;
}
#define ARMJITINFO_H
#include "llvm/Target/TargetJITInfo.h"
+#include "llvm/CodeGen/MachineConstantPool.h"
+#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/SmallVector.h"
namespace llvm {
class ARMJITInfo : public TargetJITInfo {
ARMTargetMachine &TM;
+ // MCPEs - List of the constant pool entries for the current machine
+ // function that's being processed.
+ const std::vector<MachineConstantPoolEntry> *MCPEs;
+
// ConstPoolId2AddrMap - A map from constant pool ids to the corresponding
// CONSTPOOL_ENTRY addresses.
SmallVector<intptr_t, 32> ConstPoolId2AddrMap;
+ // PCLabelMap - A map from PC labels to addresses.
+ DenseMap<unsigned, intptr_t> PCLabelMap;
+
public:
explicit ARMJITInfo(ARMTargetMachine &tm) : TM(tm) { useGOT = false; }
/// referenced global symbols.
virtual void relocate(void *Function, MachineRelocation *MR,
unsigned NumRelocs, unsigned char* GOTBase);
-
+
/// hasCustomConstantPool - Allows a target to specify that constant
/// pool address resolution is handled by the target.
virtual bool hasCustomConstantPool() const { return true; }
- /// ResizeConstPoolMap - Resize constant pool ids to CONSTPOOL_ENTRY
- /// addresses map.
- void ResizeConstPoolMap(unsigned Size) {
- ConstPoolId2AddrMap.resize(Size);
+ /// Initialize - Initialize internal stage. Get the list of constant pool
+ /// Resize constant pool ids to CONSTPOOL_ENTRY addresses map.
+ void Initialize(const std::vector<MachineConstantPoolEntry> *mcpes) {
+ MCPEs = mcpes;
+ ConstPoolId2AddrMap.resize(MCPEs->size());
}
/// getConstantPoolEntryAddr - The ARM target puts all constant
assert(CPI < ConstPoolId2AddrMap.size());
ConstPoolId2AddrMap[CPI] = Addr;
}
+
+ /// getPCLabelAddr - Retrieve the address of the PC label of the specified id.
+ intptr_t getPCLabelAddr(unsigned Id) const {
+ DenseMap<unsigned, intptr_t>::const_iterator I = PCLabelMap.find(Id);
+ assert(I != PCLabelMap.end());
+ return I->second;
+ }
+
+ /// addPCLabelAddr - Remember the address of the specified PC label.
+ void addPCLabelAddr(unsigned Id, intptr_t Addr) {
+ PCLabelMap.insert(std::make_pair(Id, Addr));
+ }
+
+ private:
+ /// resolveRelocationAddr - Resolve the resulting address of the relocation
+ /// if it's not already solved. Constantpool entries must be resolved by
+ /// ARM target.
+ intptr_t resolveRelocationAddr(MachineRelocation *MR) const;
};
}
// addresses are kept locally in a map.
reloc_arm_cp_entry,
+ // reloc_arm_machine_cp_entry - Relocation of a ARM machine constantpool
+ // entry.
+ reloc_arm_machine_cp_entry,
+
// reloc_arm_branch - Branch address relocation.
reloc_arm_branch
};
projects / oota-llvm.git / commitdiff