const_cast<Function*>(dyn_cast<Function>(CPR->getValue())))
Result = PTOGV(getPointerToFunctionOrStub(F));
else
- Result = PTOGV(getPointerToGlobal(CPR->getValue()));
+ Result = PTOGV(getOrEmitGlobalVariable(
+ cast<GlobalVariable>(CPR->getValue())));
} else {
assert(0 && "Unknown constant pointer type!");
// Allocate some memory for it!
unsigned Size = TD.getTypeSize(Ty);
addGlobalMapping(I, new char[Size]);
- NumInitBytes += Size;
DEBUG(std::cerr << "Global '" << I->getName() << "' -> "
<< (void*)GlobalAddress[I] << "\n");
// EmitGlobalVariable - This method emits the specified global variable to the
// address specified in GlobalAddresses, or allocates new memory if it's not
// already in the map.
-void ExecutionEngine::EmitGlobalVariable(GlobalVariable *GV) {
+void ExecutionEngine::EmitGlobalVariable(const GlobalVariable *GV) {
void *&GA = GlobalAddress[GV];
+ const Type *ElTy = GV->getType()->getElementType();
if (GA == 0) {
// If it's not already specified, allocate memory for the global.
- GA = new char[getTargetData().getTypeSize(GV->getType()->getElementType())];
+ GA = new char[getTargetData().getTypeSize(ElTy)];
}
+
InitializeMemory(GV->getInitializer(), GA);
+ NumInitBytes += getTargetData().getTypeSize(ElTy);
++NumGlobals;
}
//===----------------------------------------------------------------------===//
#include "JIT.h"
+#include "llvm/DerivedTypes.h"
#include "llvm/Function.h"
+#include "llvm/GlobalVariable.h"
#include "llvm/ModuleProvider.h"
#include "llvm/CodeGen/MachineCodeEmitter.h"
#include "llvm/CodeGen/MachineFunction.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Target/TargetJITInfo.h"
+#include "Support/DynamicLinker.h"
using namespace llvm;
JIT::JIT(ModuleProvider *MP, TargetMachine &tm, TargetJITInfo &tji)
<< "' doesn't support machine code emission!\n";
abort();
}
-
- emitGlobals();
}
JIT::~JIT() {
isAlreadyCodeGenerating = true;
PM.run(*F);
isAlreadyCodeGenerating = false;
+
+ // If the function referred to a global variable that had not yet been
+ // emitted, it allocates memory for the global, but doesn't emit it yet. Emit
+ // all of these globals now.
+ while (!PendingGlobals.empty()) {
+ const GlobalVariable *GV = PendingGlobals.back();
+ PendingGlobals.pop_back();
+ EmitGlobalVariable(GV);
+ }
}
/// getPointerToFunction - This method is used to get the address of the
/// specified function, compiling it if neccesary.
///
void *JIT::getPointerToFunction(Function *F) {
- void *&Addr = GlobalAddress[F]; // Check if function already code gen'd
- if (Addr) return Addr;
+ if (void *Addr = getPointerToGlobalIfAvailable(F))
+ return Addr; // Check if function already code gen'd
// Make sure we read in the function if it exists in this Module
MP->materializeFunction(F);
- if (F->isExternal())
- return Addr = getPointerToNamedFunction(F->getName());
+ if (F->isExternal()) {
+ void *Addr = getPointerToNamedFunction(F->getName());
+ addGlobalMapping(F, Addr);
+ return Addr;
+ }
runJITOnFunction(F);
+
+ void *Addr = getPointerToGlobalIfAvailable(F);
assert(Addr && "Code generation didn't add function to GlobalAddress table!");
return Addr;
}
//
void *JIT::getPointerToFunctionOrStub(Function *F) {
// If we have already code generated the function, just return the address.
- std::map<const GlobalValue*, void *>::iterator I = GlobalAddress.find(F);
- if (I != GlobalAddress.end()) return I->second;
+ if (void *Addr = getPointerToGlobalIfAvailable(F))
+ return Addr;
// If the target supports "stubs" for functions, get a stub now.
if (void *Ptr = TJI.getJITStubForFunction(F, *MCE))
return getPointerToFunction(F);
}
+/// getOrEmitGlobalVariable - Return the address of the specified global
+/// variable, possibly emitting it to memory if needed. This is used by the
+/// Emitter.
+void *JIT::getOrEmitGlobalVariable(const GlobalVariable *GV) {
+ void *Ptr = getPointerToGlobalIfAvailable(GV);
+ if (Ptr) return Ptr;
+
+ // If the global is external, just remember the address.
+ if (GV->isExternal()) {
+ Ptr = GetAddressOfSymbol(GV->getName().c_str());
+ if (Ptr == 0) {
+ std::cerr << "Could not resolve external global address: "
+ << GV->getName() << "\n";
+ abort();
+ }
+ } else {
+ // If the global hasn't been emitted to memory yet, allocate space. We will
+ // actually initialize the global after current function has finished
+ // compilation.
+ Ptr =new char[getTargetData().getTypeSize(GV->getType()->getElementType())];
+ PendingGlobals.push_back(GV);
+ }
+ addGlobalMapping(GV, Ptr);
+ return Ptr;
+}
+
+
/// recompileAndRelinkFunction - This method is used to force a function
/// which has already been compiled, to be compiled again, possibly
/// after it has been modified. Then the entry to the old copy is overwritten
/// just like JIT::getPointerToFunction().
///
void *JIT::recompileAndRelinkFunction(Function *F) {
- void *&Addr = GlobalAddress[F]; // Check if function already code gen'd
+ void *OldAddr = getPointerToGlobalIfAvailable(F);
- // If it's not already compiled (this is kind of weird) there is no
- // reason to patch it up.
- if (!Addr) { return getPointerToFunction (F); }
+ // If it's not already compiled there is no reason to patch it up.
+ if (OldAddr == 0) { return getPointerToFunction(F); }
- void *OldAddr = Addr;
- Addr = 0;
+ // Delete the old function mapping.
+ addGlobalMapping(F, 0);
+
+ // Destroy the machine code for this function. FIXME: this should be
+ // incorporated into the code generator!
MachineFunction::destruct(F);
+
+ // Recodegen the function
runJITOnFunction(F);
+
+ // Update state, forward the old function to the new function.
+ void *Addr = getPointerToGlobalIfAvailable(F);
assert(Addr && "Code generation didn't add function to GlobalAddress table!");
TJI.replaceMachineCodeForFunction(OldAddr, Addr);
return Addr;
projects / oota-llvm.git / commitdiff