class ModuleProvider;
class TargetData;
class Type;
-class IntrinsicLowering;
-
class ExecutionEngineState {
private:
// To avoid having libexecutionengine depend on the JIT and interpreter
// libraries, the JIT and Interpreter set these functions to ctor pointers
// at startup time if they are linked in.
- typedef ExecutionEngine *(*EECtorFn)(ModuleProvider*, IntrinsicLowering*);
+ typedef ExecutionEngine *(*EECtorFn)(ModuleProvider*);
static EECtorFn JITCtor, InterpCtor;
public:
const TargetData &getTargetData() const { return *TD; }
/// create - This is the factory method for creating an execution engine which
- /// is appropriate for the current machine. If specified, the
- /// IntrinsicLowering implementation should be allocated on the heap.
- static ExecutionEngine *create(ModuleProvider *MP, bool ForceInterpreter,
- IntrinsicLowering *IL = 0);
+ /// is appropriate for the current machine.
+ static ExecutionEngine *create(ModuleProvider *MP,
+ bool ForceInterpreter = false);
/// runFunction - Execute the specified function with the specified arguments,
/// and return the result.
/// NULL is returned.
///
ExecutionEngine *ExecutionEngine::create(ModuleProvider *MP,
- bool ForceInterpreter,
- IntrinsicLowering *IL) {
+ bool ForceInterpreter) {
ExecutionEngine *EE = 0;
// Unless the interpreter was explicitly selected, try making a JIT.
if (!ForceInterpreter && JITCtor)
- EE = JITCtor(MP, IL);
+ EE = JITCtor(MP);
// If we can't make a JIT, make an interpreter instead.
if (EE == 0 && InterpCtor)
- EE = InterpCtor(MP, IL);
+ EE = InterpCtor(MP);
- if (EE == 0)
- delete IL;
- else
+ if (EE) {
// Make sure we can resolve symbols in the program as well. The zero arg
// to the function tells DynamicLibrary to load the program, not a library.
sys::DynamicLibrary::LoadLibraryPermanently(0);
+ }
return EE;
}
/// create - Create a new interpreter object. This can never fail.
///
-ExecutionEngine *Interpreter::create(ModuleProvider *MP,
- IntrinsicLowering *IL) {
+ExecutionEngine *Interpreter::create(ModuleProvider *MP) {
Module *M;
try {
M = MP->materializeModule();
break;
}
- return new Interpreter(M, isLittleEndian, isLongPointer, IL);
+ return new Interpreter(M, isLittleEndian, isLongPointer);
}
//===----------------------------------------------------------------------===//
// Interpreter ctor - Initialize stuff
//
-Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
- IntrinsicLowering *il)
+Interpreter::Interpreter(Module *M, bool isLittleEndian, bool isLongPointer)
: ExecutionEngine(M),
TD("lli", isLittleEndian, isLongPointer ? 8 : 4, isLongPointer ? 8 : 4,
- isLongPointer ? 8 : 4), IL(il) {
+ isLongPointer ? 8 : 4) {
memset(&ExitValue, 0, sizeof(ExitValue));
setTargetData(TD);
initializeExternalFunctions();
emitGlobals();
- if (IL == 0) IL = new DefaultIntrinsicLowering();
+ IL = new DefaultIntrinsicLowering();
}
Interpreter::~Interpreter() {
namespace llvm {
+class IntrinsicLowering;
struct FunctionInfo;
template<typename T> class generic_gep_type_iterator;
class ConstantExpr;
std::vector<Function*> AtExitHandlers;
public:
- Interpreter(Module *M, bool isLittleEndian, bool isLongPointer,
- IntrinsicLowering *IL);
+ Interpreter(Module *M, bool isLittleEndian, bool isLongPointer);
~Interpreter();
/// runAtExitHandlers - Run any functions registered by the program's calls to
InterpCtor = create;
}
- /// create - Create an interpreter ExecutionEngine. This can never fail. The
- /// specified IntrinsicLowering implementation will be deleted when the
- /// Interpreter execution engine is destroyed.
+ /// create - Create an interpreter ExecutionEngine. This can never fail.
///
- static ExecutionEngine *create(ModuleProvider *M, IntrinsicLowering *IL);
+ static ExecutionEngine *create(ModuleProvider *M);
/// run - Start execution with the specified function and arguments.
///
TargetJITInfo &getJITInfo() const { return TJI; }
/// create - Create an return a new JIT compiler if there is one available
- /// for the current target. Otherwise, return null. If the JIT is created
- /// successfully, it takes responsibility for deleting the specified
- /// IntrinsicLowering implementation.
+ /// for the current target. Otherwise, return null.
///
- static ExecutionEngine *create(ModuleProvider *MP, IntrinsicLowering *IL = 0);
+ static ExecutionEngine *create(ModuleProvider *MP);
/// run - Start execution with the specified function and arguments.
///
/// create - Create an return a new JIT compiler if there is one available
/// for the current target. Otherwise, return null.
///
-ExecutionEngine *JIT::create(ModuleProvider *MP, IntrinsicLowering *IL) {
+ExecutionEngine *JIT::create(ModuleProvider *MP) {
if (MArch == 0) {
std::string Error;
MArch = TargetMachineRegistry::getClosestTargetForJIT(Error);
}
// Allocate a target...
- TargetMachine *Target = MArch->CtorFn(*MP->getModule(), IL, FeaturesStr);
+ TargetMachine *Target = MArch->CtorFn(*MP->getModule(), 0, FeaturesStr);
assert(Target && "Could not allocate target machine!");
// If the target supports JIT code generation, return a new JIT now.