int main(int argc, char **argv) {
atexit(llvm_shutdown); // Call llvm_shutdown() on exit.
lav::parseArguments(argc, argv);
sys::PrintStackTraceOnErrorSignal();
// Load the bytecode...
// std::cout << std::endl << "Loading the bytecode..." << std::endl;
std::string ErrorMsg;
Module *mainModule = 0;
OwningPtr<MemoryBuffer> BufferPtr;
llvm::error_code ec =
MemoryBuffer::getFileOrSTDIN(InputFileName.c_str(), BufferPtr);
if (ec) {
lav::exit_error((std::string) "error loading program '%s': %s" +
InputFileName.c_str() + ec.message().c_str());
}
mainModule =
getLazyBitcodeModule(BufferPtr.get(), getGlobalContext(), &ErrorMsg);
if (mainModule) {
if (mainModule->MaterializeAllPermanently(&ErrorMsg)) {
delete mainModule;
mainModule = 0;
}
}
if (!mainModule)
lav::exit_error((std::string) "error loading program '%s': %s" +
InputFileName.c_str() + ErrorMsg.c_str());
std::cout << "Loading the bytecode... Completed " << std::endl << std::endl;
PassManager Passes;
Passes.add(new llvm::DataLayout(mainModule));
Passes.add(createFCFGSimplificationPass()); // Clean up after IPCP & DAE
// Passes.add(createLoopInfoPass()); //
Passes.add(llvm::createLoopSimplifyPass());
Passes.add(lav::createPetljePass()); //
if (EnableInline)
Passes.add(createAllInlinerPass(
Threshold)); //Inline malo vece funkcije, parametar inlininga od 200 do
//milijardu, ako je bez argumenta postavljeno je na
//milijardu
Passes.run(*mainModule);
Podaci p(mainModule);
p.UradiPosao();
BufferPtr.take();
std::cout << "Finished " << std::endl << std::endl;
return 0;
}
//===----------------------------------------------------------------------===//
// main Driver function
//
int main(int argc, char **argv, char * const *envp) {
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
LLVMContext &Context = getGlobalContext();
atexit(do_shutdown); // Call llvm_shutdown() on exit.
// If we have a native target, initialize it to ensure it is linked in and
// usable by the JIT.
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
cl::ParseCommandLineOptions(argc, argv,
"llvm interpreter & dynamic compiler\n");
// If the user doesn't want core files, disable them.
if (DisableCoreFiles)
sys::Process::PreventCoreFiles();
// Load the bitcode...
SMDiagnostic Err;
Module *Mod = ParseIRFile(InputFile, Err, Context);
if (!Mod) {
Err.print(argv[0], errs());
return 1;
}
// If not jitting lazily, load the whole bitcode file eagerly too.
std::string ErrorMsg;
if (NoLazyCompilation) {
if (Mod->MaterializeAllPermanently(&ErrorMsg)) {
errs() << argv[0] << ": bitcode didn't read correctly.\n";
errs() << "Reason: " << ErrorMsg << "\n";
exit(1);
}
}
EngineBuilder builder(Mod);
builder.setMArch(MArch);
builder.setMCPU(MCPU);
builder.setMAttrs(MAttrs);
builder.setRelocationModel(RelocModel);
builder.setCodeModel(CMModel);
builder.setErrorStr(&ErrorMsg);
builder.setJITMemoryManager(ForceInterpreter ? 0 :
JITMemoryManager::CreateDefaultMemManager());
builder.setEngineKind(ForceInterpreter
? EngineKind::Interpreter
: EngineKind::JIT);
// If we are supposed to override the target triple, do so now.
if (!TargetTriple.empty())
Mod->setTargetTriple(Triple::normalize(TargetTriple));
// Enable MCJIT if desired.
if (UseMCJIT && !ForceInterpreter) {
builder.setUseMCJIT(true);
builder.setJITMemoryManager(JITMemoryManager::CreateDefaultMemManager());
}
CodeGenOpt::Level OLvl = CodeGenOpt::Default;
switch (OptLevel) {
default:
errs() << argv[0] << ": invalid optimization level.\n";
return 1;
case ' ': break;
case '0': OLvl = CodeGenOpt::None; break;
case '1': OLvl = CodeGenOpt::Less; break;
case '2': OLvl = CodeGenOpt::Default; break;
case '3': OLvl = CodeGenOpt::Aggressive; break;
}
builder.setOptLevel(OLvl);
EE = builder.create();
if (!EE) {
if (!ErrorMsg.empty())
errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n";
else
errs() << argv[0] << ": unknown error creating EE!\n";
exit(1);
}
EE->RegisterJITEventListener(createOProfileJITEventListener());
EE->DisableLazyCompilation(NoLazyCompilation);
// If the user specifically requested an argv[0] to pass into the program,
// do it now.
if (!FakeArgv0.empty()) {
InputFile = FakeArgv0;
} else {
// Otherwise, if there is a .bc suffix on the executable strip it off, it
// might confuse the program.
if (StringRef(InputFile).endswith(".bc"))
InputFile.erase(InputFile.length() - 3);
}
// Add the module's name to the start of the vector of arguments to main().
InputArgv.insert(InputArgv.begin(), InputFile);
// Call the main function from M as if its signature were:
// int main (int argc, char **argv, const char **envp)
// using the contents of Args to determine argc & argv, and the contents of
// EnvVars to determine envp.
//
Function *EntryFn = Mod->getFunction(EntryFunc);
if (!EntryFn) {
errs() << '\'' << EntryFunc << "\' function not found in module.\n";
return -1;
}
// If the program doesn't explicitly call exit, we will need the Exit
// function later on to make an explicit call, so get the function now.
Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context),
Type::getInt32Ty(Context),
NULL);
// Reset errno to zero on entry to main.
errno = 0;
// Run static constructors.
EE->runStaticConstructorsDestructors(false);
if (NoLazyCompilation) {
for (Module::iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
Function *Fn = &*I;
if (Fn != EntryFn && !Fn->isDeclaration())
EE->getPointerToFunction(Fn);
}
}
// Run main.
int Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp);
// Run static destructors.
EE->runStaticConstructorsDestructors(true);
// If the program didn't call exit explicitly, we should call it now.
// This ensures that any atexit handlers get called correctly.
if (Function *ExitF = dyn_cast<Function>(Exit)) {
std::vector<GenericValue> Args;
GenericValue ResultGV;
ResultGV.IntVal = APInt(32, Result);
Args.push_back(ResultGV);
EE->runFunction(ExitF, Args);
errs() << "ERROR: exit(" << Result << ") returned!\n";
abort();
} else {
errs() << "ERROR: exit defined with wrong prototype!\n";
abort();
}
}
int main(int argc, char **argv, char **envp) {
atexit(llvm_shutdown); // Call llvm_shutdown() on exit.
llvm::InitializeNativeTarget();
parseArguments(argc, argv);
sys::PrintStackTraceOnErrorSignal();
if (Watchdog) {
if (MaxTime==0) {
klee_error("--watchdog used without --max-time");
}
int pid = fork();
if (pid<0) {
klee_error("unable to fork watchdog");
} else if (pid) {
fprintf(stderr, "KLEE: WATCHDOG: watching %d\n", pid);
fflush(stderr);
sys::SetInterruptFunction(interrupt_handle_watchdog);
double nextStep = util::getWallTime() + MaxTime*1.1;
int level = 0;
// Simple stupid code...
while (1) {
sleep(1);
int status, res = waitpid(pid, &status, WNOHANG);
if (res < 0) {
if (errno==ECHILD) { // No child, no need to watch but
// return error since we didn't catch
// the exit.
fprintf(stderr, "KLEE: watchdog exiting (no child)\n");
return 1;
} else if (errno!=EINTR) {
perror("watchdog waitpid");
exit(1);
}
} else if (res==pid && WIFEXITED(status)) {
return WEXITSTATUS(status);
} else {
double time = util::getWallTime();
if (time > nextStep) {
++level;
if (level==1) {
fprintf(stderr, "KLEE: WATCHDOG: time expired, attempting halt via INT\n");
kill(pid, SIGINT);
} else if (level==2) {
fprintf(stderr, "KLEE: WATCHDOG: time expired, attempting halt via gdb\n");
halt_via_gdb(pid);
} else {
fprintf(stderr, "KLEE: WATCHDOG: kill(9)ing child (I tried to be nice)\n");
kill(pid, SIGKILL);
return 1; // what more can we do
}
// Ideally this triggers a dump, which may take a while,
// so try and give the process extra time to clean up.
nextStep = util::getWallTime() + std::max(15., MaxTime*.1);
}
}
}
return 0;
}
}
sys::SetInterruptFunction(interrupt_handle);
// Load the bytecode...
std::string ErrorMsg;
Module *mainModule = 0;
#if LLVM_VERSION_CODE < LLVM_VERSION(3, 5)
OwningPtr<MemoryBuffer> BufferPtr;
error_code ec=MemoryBuffer::getFileOrSTDIN(InputFile.c_str(), BufferPtr);
if (ec) {
klee_error("error loading program '%s': %s", InputFile.c_str(),
ec.message().c_str());
}
mainModule = getLazyBitcodeModule(BufferPtr.get(), getGlobalContext(), &ErrorMsg);
if (mainModule) {
if (mainModule->MaterializeAllPermanently(&ErrorMsg)) {
delete mainModule;
mainModule = 0;
}
}
if (!mainModule)
klee_error("error loading program '%s': %s", InputFile.c_str(),
ErrorMsg.c_str());
#else
auto Buffer = MemoryBuffer::getFileOrSTDIN(InputFile.c_str());
if (!Buffer)
klee_error("error loading program '%s': %s", InputFile.c_str(),
Buffer.getError().message().c_str());
auto mainModuleOrError = getLazyBitcodeModule(Buffer->get(), getGlobalContext());
if (!mainModuleOrError) {
klee_error("error loading program '%s': %s", InputFile.c_str(),
mainModuleOrError.getError().message().c_str());
}
else {
// The module has taken ownership of the MemoryBuffer so release it
// from the std::unique_ptr
Buffer->release();
}
mainModule = *mainModuleOrError;
if (auto ec = mainModule->materializeAllPermanently()) {
klee_error("error loading program '%s': %s", InputFile.c_str(),
ec.message().c_str());
}
#endif
if (WithPOSIXRuntime) {
int r = initEnv(mainModule);
if (r != 0)
return r;
}
std::string LibraryDir = KleeHandler::getRunTimeLibraryPath(argv[0]);
Interpreter::ModuleOptions Opts(LibraryDir.c_str(),
/*Optimize=*/OptimizeModule,
/*CheckDivZero=*/CheckDivZero,
/*CheckOvershift=*/CheckOvershift);
switch (Libc) {
case NoLibc: /* silence compiler warning */
break;
case KleeLibc: {
// FIXME: Find a reasonable solution for this.
SmallString<128> Path(Opts.LibraryDir);
#if LLVM_VERSION_CODE >= LLVM_VERSION(3,3)
llvm::sys::path::append(Path, "klee-libc.bc");
#else
llvm::sys::path::append(Path, "libklee-libc.bca");
#endif
mainModule = klee::linkWithLibrary(mainModule, Path.c_str());
assert(mainModule && "unable to link with klee-libc");
break;
}
case UcLibc:
mainModule = linkWithUclibc(mainModule, LibraryDir);
break;
}
if (WithPOSIXRuntime) {
SmallString<128> Path(Opts.LibraryDir);
llvm::sys::path::append(Path, "libkleeRuntimePOSIX.bca");
klee_message("NOTE: Using model: %s", Path.c_str());
mainModule = klee::linkWithLibrary(mainModule, Path.c_str());
assert(mainModule && "unable to link with simple model");
}
// Get the desired main function. klee_main initializes uClibc
// locale and other data and then calls main.
Function *mainFn = mainModule->getFunction(EntryPoint);
if (!mainFn) {
llvm::errs() << "'" << EntryPoint << "' function not found in module.\n";
return -1;
}
// FIXME: Change me to std types.
int pArgc;
char **pArgv;
char **pEnvp;
if (Environ != "") {
std::vector<std::string> items;
std::ifstream f(Environ.c_str());
if (!f.good())
klee_error("unable to open --environ file: %s", Environ.c_str());
while (!f.eof()) {
std::string line;
std::getline(f, line);
line = strip(line);
if (!line.empty())
items.push_back(line);
}
f.close();
pEnvp = new char *[items.size()+1];
unsigned i=0;
for (; i != items.size(); ++i)
pEnvp[i] = strdup(items[i].c_str());
pEnvp[i] = 0;
} else {
pEnvp = envp;
}
pArgc = InputArgv.size() + 1;
pArgv = new char *[pArgc];
for (unsigned i=0; i<InputArgv.size()+1; i++) {
std::string &arg = (i==0 ? InputFile : InputArgv[i-1]);
unsigned size = arg.size() + 1;
char *pArg = new char[size];
std::copy(arg.begin(), arg.end(), pArg);
pArg[size - 1] = 0;
pArgv[i] = pArg;
}
std::vector<bool> replayPath;
if (ReplayPathFile != "") {
KleeHandler::loadPathFile(ReplayPathFile, replayPath);
}
Interpreter::InterpreterOptions IOpts;
IOpts.MakeConcreteSymbolic = MakeConcreteSymbolic;
KleeHandler *handler = new KleeHandler(pArgc, pArgv);
Interpreter *interpreter =
theInterpreter = Interpreter::create(IOpts, handler);
handler->setInterpreter(interpreter);
llvm::raw_ostream &infoFile = handler->getInfoStream();
for (int i=0; i<argc; i++) {
infoFile << argv[i] << (i+1<argc ? " ":"\n");
}
infoFile << "PID: " << getpid() << "\n";
const Module *finalModule =
interpreter->setModule(mainModule, Opts);
externalsAndGlobalsCheck(finalModule);
if (ReplayPathFile != "") {
interpreter->setReplayPath(&replayPath);
}
char buf[256];
time_t t[2];
t[0] = time(NULL);
strftime(buf, sizeof(buf), "Started: %Y-%m-%d %H:%M:%S\n", localtime(&t[0]));
infoFile << buf;
infoFile.flush();
if (!ReplayOutDir.empty() || !ReplayOutFile.empty()) {
assert(SeedOutFile.empty());
assert(SeedOutDir.empty());
std::vector<std::string> outFiles = ReplayOutFile;
for (std::vector<std::string>::iterator
it = ReplayOutDir.begin(), ie = ReplayOutDir.end();
it != ie; ++it)
KleeHandler::getOutFiles(*it, outFiles);
std::vector<KTest*> kTests;
for (std::vector<std::string>::iterator
it = outFiles.begin(), ie = outFiles.end();
it != ie; ++it) {
KTest *out = kTest_fromFile(it->c_str());
if (out) {
kTests.push_back(out);
} else {
llvm::errs() << "KLEE: unable to open: " << *it << "\n";
}
}
if (RunInDir != "") {
int res = chdir(RunInDir.c_str());
if (res < 0) {
klee_error("Unable to change directory to: %s", RunInDir.c_str());
}
}
unsigned i=0;
for (std::vector<KTest*>::iterator
it = kTests.begin(), ie = kTests.end();
it != ie; ++it) {
KTest *out = *it;
interpreter->setReplayOut(out);
llvm::errs() << "KLEE: replaying: " << *it << " (" << kTest_numBytes(out)
<< " bytes)"
<< " (" << ++i << "/" << outFiles.size() << ")\n";
// XXX should put envp in .ktest ?
interpreter->runFunctionAsMain(mainFn, out->numArgs, out->args, pEnvp);
if (interrupted) break;
}
interpreter->setReplayOut(0);
while (!kTests.empty()) {
kTest_free(kTests.back());
kTests.pop_back();
}
} else {
std::vector<KTest *> seeds;
for (std::vector<std::string>::iterator
it = SeedOutFile.begin(), ie = SeedOutFile.end();
it != ie; ++it) {
KTest *out = kTest_fromFile(it->c_str());
if (!out) {
llvm::errs() << "KLEE: unable to open: " << *it << "\n";
exit(1);
}
seeds.push_back(out);
}
for (std::vector<std::string>::iterator
it = SeedOutDir.begin(), ie = SeedOutDir.end();
it != ie; ++it) {
std::vector<std::string> outFiles;
KleeHandler::getOutFiles(*it, outFiles);
for (std::vector<std::string>::iterator
it2 = outFiles.begin(), ie = outFiles.end();
it2 != ie; ++it2) {
KTest *out = kTest_fromFile(it2->c_str());
if (!out) {
llvm::errs() << "KLEE: unable to open: " << *it2 << "\n";
exit(1);
}
seeds.push_back(out);
}
if (outFiles.empty()) {
llvm::errs() << "KLEE: seeds directory is empty: " << *it << "\n";
exit(1);
}
}
if (!seeds.empty()) {
llvm::errs() << "KLEE: using " << seeds.size() << " seeds\n";
interpreter->useSeeds(&seeds);
}
if (RunInDir != "") {
int res = chdir(RunInDir.c_str());
if (res < 0) {
klee_error("Unable to change directory to: %s", RunInDir.c_str());
}
}
interpreter->runFunctionAsMain(mainFn, pArgc, pArgv, pEnvp);
while (!seeds.empty()) {
kTest_free(seeds.back());
seeds.pop_back();
}
}
t[1] = time(NULL);
strftime(buf, sizeof(buf), "Finished: %Y-%m-%d %H:%M:%S\n", localtime(&t[1]));
infoFile << buf;
strcpy(buf, "Elapsed: ");
strcpy(format_tdiff(buf, t[1] - t[0]), "\n");
infoFile << buf;
// Free all the args.
for (unsigned i=0; i<InputArgv.size()+1; i++)
delete[] pArgv[i];
delete[] pArgv;
delete interpreter;
uint64_t queries =
*theStatisticManager->getStatisticByName("Queries");
uint64_t queriesValid =
*theStatisticManager->getStatisticByName("QueriesValid");
uint64_t queriesInvalid =
*theStatisticManager->getStatisticByName("QueriesInvalid");
uint64_t queryCounterexamples =
*theStatisticManager->getStatisticByName("QueriesCEX");
uint64_t queryConstructs =
*theStatisticManager->getStatisticByName("QueriesConstructs");
uint64_t instructions =
*theStatisticManager->getStatisticByName("Instructions");
uint64_t forks =
*theStatisticManager->getStatisticByName("Forks");
handler->getInfoStream()
<< "KLEE: done: explored paths = " << 1 + forks << "\n";
// Write some extra information in the info file which users won't
// necessarily care about or understand.
if (queries)
handler->getInfoStream()
<< "KLEE: done: avg. constructs per query = "
<< queryConstructs / queries << "\n";
handler->getInfoStream()
<< "KLEE: done: total queries = " << queries << "\n"
<< "KLEE: done: valid queries = " << queriesValid << "\n"
<< "KLEE: done: invalid queries = " << queriesInvalid << "\n"
<< "KLEE: done: query cex = " << queryCounterexamples << "\n";
std::stringstream stats;
stats << "\n";
stats << "KLEE: done: total instructions = "
<< instructions << "\n";
stats << "KLEE: done: completed paths = "
<< handler->getNumPathsExplored() << "\n";
stats << "KLEE: done: generated tests = "
<< handler->getNumTestCases() << "\n";
bool useColors = llvm::errs().is_displayed();
if (useColors)
llvm::errs().changeColor(llvm::raw_ostream::GREEN,
/*bold=*/true,
/*bg=*/false);
llvm::errs() << stats.str();
if (useColors)
llvm::errs().resetColor();
handler->getInfoStream() << stats.str();
#if LLVM_VERSION_CODE < LLVM_VERSION(3, 5)
// FIXME: This really doesn't look right
// This is preventing the module from being
// deleted automatically
BufferPtr.take();
#endif
delete handler;
return 0;
}
//===----------------------------------------------------------------------===//
// main Driver function
//
int main(int argc, char **argv, char * const *envp) {
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
LLVMContext &Context = getGlobalContext();
atexit(do_shutdown); // Call llvm_shutdown() on exit.
// If we have a native target, initialize it to ensure it is linked in and
// usable by the JIT.
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
InitializeNativeTargetAsmParser();
cl::ParseCommandLineOptions(argc, argv,
"llvm interpreter & dynamic compiler\n");
// If the user doesn't want core files, disable them.
if (DisableCoreFiles)
sys::Process::PreventCoreFiles();
// Load the bitcode...
SMDiagnostic Err;
Module *Mod = ParseIRFile(InputFile, Err, Context);
if (!Mod) {
Err.print(argv[0], errs());
return 1;
}
// If not jitting lazily, load the whole bitcode file eagerly too.
std::string ErrorMsg;
if (NoLazyCompilation) {
if (Mod->MaterializeAllPermanently(&ErrorMsg)) {
errs() << argv[0] << ": bitcode didn't read correctly.\n";
errs() << "Reason: " << ErrorMsg << "\n";
exit(1);
}
}
EngineBuilder builder(Mod);
builder.setMArch(MArch);
builder.setMCPU(MCPU);
builder.setMAttrs(MAttrs);
builder.setRelocationModel(RelocModel);
builder.setCodeModel(CMModel);
builder.setErrorStr(&ErrorMsg);
builder.setEngineKind(ForceInterpreter
? EngineKind::Interpreter
: EngineKind::JIT);
// If we are supposed to override the target triple, do so now.
if (!TargetTriple.empty())
Mod->setTargetTriple(Triple::normalize(TargetTriple));
// Enable MCJIT if desired.
JITMemoryManager *JMM = 0;
if (UseMCJIT && !ForceInterpreter) {
builder.setUseMCJIT(true);
if (RemoteMCJIT)
JMM = new RecordingMemoryManager();
else
JMM = new SectionMemoryManager();
builder.setJITMemoryManager(JMM);
} else {
if (RemoteMCJIT) {
errs() << "error: Remote process execution requires -use-mcjit\n";
exit(1);
}
builder.setJITMemoryManager(ForceInterpreter ? 0 :
JITMemoryManager::CreateDefaultMemManager());
}
CodeGenOpt::Level OLvl = CodeGenOpt::Default;
switch (OptLevel) {
default:
errs() << argv[0] << ": invalid optimization level.\n";
return 1;
case ' ': break;
case '0': OLvl = CodeGenOpt::None; break;
case '1': OLvl = CodeGenOpt::Less; break;
case '2': OLvl = CodeGenOpt::Default; break;
case '3': OLvl = CodeGenOpt::Aggressive; break;
}
builder.setOptLevel(OLvl);
TargetOptions Options;
Options.UseSoftFloat = GenerateSoftFloatCalls;
if (FloatABIForCalls != FloatABI::Default)
Options.FloatABIType = FloatABIForCalls;
if (GenerateSoftFloatCalls)
FloatABIForCalls = FloatABI::Soft;
// Remote target execution doesn't handle EH or debug registration.
if (!RemoteMCJIT) {
Options.JITExceptionHandling = EnableJITExceptionHandling;
Options.JITEmitDebugInfo = EmitJitDebugInfo;
Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk;
}
builder.setTargetOptions(Options);
EE = builder.create();
if (!EE) {
if (!ErrorMsg.empty())
errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n";
else
errs() << argv[0] << ": unknown error creating EE!\n";
exit(1);
}
// The following functions have no effect if their respective profiling
// support wasn't enabled in the build configuration.
EE->RegisterJITEventListener(
JITEventListener::createOProfileJITEventListener());
EE->RegisterJITEventListener(
JITEventListener::createIntelJITEventListener());
if (!NoLazyCompilation && RemoteMCJIT) {
errs() << "warning: remote mcjit does not support lazy compilation\n";
NoLazyCompilation = true;
}
EE->DisableLazyCompilation(NoLazyCompilation);
// If the user specifically requested an argv[0] to pass into the program,
// do it now.
if (!FakeArgv0.empty()) {
InputFile = FakeArgv0;
} else {
// Otherwise, if there is a .bc suffix on the executable strip it off, it
// might confuse the program.
if (StringRef(InputFile).endswith(".bc"))
InputFile.erase(InputFile.length() - 3);
}
// Add the module's name to the start of the vector of arguments to main().
InputArgv.insert(InputArgv.begin(), InputFile);
// Call the main function from M as if its signature were:
// int main (int argc, char **argv, const char **envp)
// using the contents of Args to determine argc & argv, and the contents of
// EnvVars to determine envp.
//
Function *EntryFn = Mod->getFunction(EntryFunc);
if (!EntryFn) {
errs() << '\'' << EntryFunc << "\' function not found in module.\n";
return -1;
}
// If the program doesn't explicitly call exit, we will need the Exit
// function later on to make an explicit call, so get the function now.
Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context),
Type::getInt32Ty(Context),
NULL);
// Reset errno to zero on entry to main.
errno = 0;
// Remote target MCJIT doesn't (yet) support static constructors. No reason
// it couldn't. This is a limitation of the LLI implemantation, not the
// MCJIT itself. FIXME.
//
// Run static constructors.
if (!RemoteMCJIT) {
if (UseMCJIT && !ForceInterpreter) {
// Give MCJIT a chance to apply relocations and set page permissions.
EE->finalizeObject();
}
EE->runStaticConstructorsDestructors(false);
}
if (NoLazyCompilation) {
for (Module::iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
Function *Fn = &*I;
if (Fn != EntryFn && !Fn->isDeclaration())
EE->getPointerToFunction(Fn);
}
}
int Result;
if (RemoteMCJIT) {
RecordingMemoryManager *MM = static_cast<RecordingMemoryManager*>(JMM);
// Everything is prepared now, so lay out our program for the target
// address space, assign the section addresses to resolve any relocations,
// and send it to the target.
RemoteTarget Target;
Target.create();
// Ask for a pointer to the entry function. This triggers the actual
// compilation.
(void)EE->getPointerToFunction(EntryFn);
// Enough has been compiled to execute the entry function now, so
// layout the target memory.
layoutRemoteTargetMemory(&Target, MM);
// Since we're executing in a (at least simulated) remote address space,
// we can't use the ExecutionEngine::runFunctionAsMain(). We have to
// grab the function address directly here and tell the remote target
// to execute the function.
// FIXME: argv and envp handling.
uint64_t Entry = (uint64_t)EE->getPointerToFunction(EntryFn);
DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at "
<< format("%p", Entry) << "\n");
if (Target.executeCode(Entry, Result))
errs() << "ERROR: " << Target.getErrorMsg() << "\n";
Target.stop();
} else {
// Trigger compilation separately so code regions that need to be
// invalidated will be known.
(void)EE->getPointerToFunction(EntryFn);
// Clear instruction cache before code will be executed.
if (JMM)
static_cast<SectionMemoryManager*>(JMM)->invalidateInstructionCache();
// Run main.
Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp);
}
// Like static constructors, the remote target MCJIT support doesn't handle
// this yet. It could. FIXME.
if (!RemoteMCJIT) {
// Run static destructors.
EE->runStaticConstructorsDestructors(true);
// If the program didn't call exit explicitly, we should call it now.
// This ensures that any atexit handlers get called correctly.
if (Function *ExitF = dyn_cast<Function>(Exit)) {
std::vector<GenericValue> Args;
GenericValue ResultGV;
ResultGV.IntVal = APInt(32, Result);
Args.push_back(ResultGV);
EE->runFunction(ExitF, Args);
errs() << "ERROR: exit(" << Result << ") returned!\n";
abort();
} else {
errs() << "ERROR: exit defined with wrong prototype!\n";
abort();
}
}
return Result;
}
//===----------------------------------------------------------------------===//
// main Driver function
//
int main(int argc, char **argv, char * const *envp) {
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
LLVMContext &Context = getGlobalContext();
atexit(do_shutdown); // Call llvm_shutdown() on exit.
// If we have a native target, initialize it to ensure it is linked in and
// usable by the JIT.
InitializeNativeTarget();
InitializeNativeTargetAsmPrinter();
InitializeNativeTargetAsmParser();
cl::ParseCommandLineOptions(argc, argv,
"llvm interpreter & dynamic compiler\n");
// If the user doesn't want core files, disable them.
if (DisableCoreFiles)
sys::Process::PreventCoreFiles();
// Load the bitcode...
SMDiagnostic Err;
Module *Mod = ParseIRFile(InputFile, Err, Context);
if (!Mod) {
Err.print(argv[0], errs());
return 1;
}
if (EnableCacheManager) {
if (UseMCJIT) {
std::string CacheName("file:");
CacheName.append(InputFile);
Mod->setModuleIdentifier(CacheName);
} else
errs() << "warning: -enable-cache-manager can only be used with MCJIT.";
}
// If not jitting lazily, load the whole bitcode file eagerly too.
std::string ErrorMsg;
if (NoLazyCompilation) {
if (Mod->MaterializeAllPermanently(&ErrorMsg)) {
errs() << argv[0] << ": bitcode didn't read correctly.\n";
errs() << "Reason: " << ErrorMsg << "\n";
exit(1);
}
}
if (DebugIR) {
if (!UseMCJIT) {
errs() << "warning: -debug-ir used without -use-mcjit. Only partial debug"
<< " information will be emitted by the non-MC JIT engine. To see full"
<< " source debug information, enable the flag '-use-mcjit'.\n";
}
ModulePass *DebugIRPass = createDebugIRPass();
DebugIRPass->runOnModule(*Mod);
}
EngineBuilder builder(Mod);
builder.setMArch(MArch);
builder.setMCPU(MCPU);
builder.setMAttrs(MAttrs);
builder.setRelocationModel(RelocModel);
builder.setCodeModel(CMModel);
builder.setErrorStr(&ErrorMsg);
builder.setEngineKind(ForceInterpreter
? EngineKind::Interpreter
: EngineKind::JIT);
// If we are supposed to override the target triple, do so now.
if (!TargetTriple.empty())
Mod->setTargetTriple(Triple::normalize(TargetTriple));
// Enable MCJIT if desired.
RTDyldMemoryManager *RTDyldMM = 0;
if (UseMCJIT && !ForceInterpreter) {
builder.setUseMCJIT(true);
if (RemoteMCJIT)
RTDyldMM = new RemoteMemoryManager();
else
RTDyldMM = new SectionMemoryManager();
builder.setMCJITMemoryManager(RTDyldMM);
} else {
if (RemoteMCJIT) {
errs() << "error: Remote process execution requires -use-mcjit\n";
exit(1);
}
builder.setJITMemoryManager(ForceInterpreter ? 0 :
JITMemoryManager::CreateDefaultMemManager());
}
CodeGenOpt::Level OLvl = CodeGenOpt::Default;
switch (OptLevel) {
default:
errs() << argv[0] << ": invalid optimization level.\n";
return 1;
case ' ': break;
case '0': OLvl = CodeGenOpt::None; break;
case '1': OLvl = CodeGenOpt::Less; break;
case '2': OLvl = CodeGenOpt::Default; break;
case '3': OLvl = CodeGenOpt::Aggressive; break;
}
builder.setOptLevel(OLvl);
TargetOptions Options;
Options.UseSoftFloat = GenerateSoftFloatCalls;
if (FloatABIForCalls != FloatABI::Default)
Options.FloatABIType = FloatABIForCalls;
if (GenerateSoftFloatCalls)
FloatABIForCalls = FloatABI::Soft;
// Remote target execution doesn't handle EH or debug registration.
if (!RemoteMCJIT) {
Options.JITEmitDebugInfo = EmitJitDebugInfo;
Options.JITEmitDebugInfoToDisk = EmitJitDebugInfoToDisk;
}
builder.setTargetOptions(Options);
EE = builder.create();
if (!EE) {
if (!ErrorMsg.empty())
errs() << argv[0] << ": error creating EE: " << ErrorMsg << "\n";
else
errs() << argv[0] << ": unknown error creating EE!\n";
exit(1);
}
if (EnableCacheManager) {
CacheManager = new LLIObjectCache;
EE->setObjectCache(CacheManager);
}
// Load any additional modules specified on the command line.
for (unsigned i = 0, e = ExtraModules.size(); i != e; ++i) {
Module *XMod = ParseIRFile(ExtraModules[i], Err, Context);
if (!XMod) {
Err.print(argv[0], errs());
return 1;
}
if (EnableCacheManager) {
if (UseMCJIT) {
std::string CacheName("file:");
CacheName.append(ExtraModules[i]);
XMod->setModuleIdentifier(CacheName);
}
// else, we already printed a warning above.
}
EE->addModule(XMod);
}
for (unsigned i = 0, e = ExtraObjects.size(); i != e; ++i) {
object::ObjectFile *Obj = object::ObjectFile::createObjectFile(
ExtraObjects[i]);
if (!Obj) {
Err.print(argv[0], errs());
return 1;
}
EE->addObjectFile(Obj);
}
for (unsigned i = 0, e = ExtraArchives.size(); i != e; ++i) {
OwningPtr<MemoryBuffer> ArBuf;
error_code ec;
ec = MemoryBuffer::getFileOrSTDIN(ExtraArchives[i], ArBuf);
if (ec) {
Err.print(argv[0], errs());
return 1;
}
object::Archive *Ar = new object::Archive(ArBuf.take(), ec);
if (ec || !Ar) {
Err.print(argv[0], errs());
return 1;
}
EE->addArchive(Ar);
}
// If the target is Cygwin/MingW and we are generating remote code, we
// need an extra module to help out with linking.
if (RemoteMCJIT && Triple(Mod->getTargetTriple()).isOSCygMing()) {
addCygMingExtraModule(EE, Context, Mod->getTargetTriple());
}
// The following functions have no effect if their respective profiling
// support wasn't enabled in the build configuration.
EE->RegisterJITEventListener(
JITEventListener::createOProfileJITEventListener());
EE->RegisterJITEventListener(
JITEventListener::createIntelJITEventListener());
if (!NoLazyCompilation && RemoteMCJIT) {
errs() << "warning: remote mcjit does not support lazy compilation\n";
NoLazyCompilation = true;
}
EE->DisableLazyCompilation(NoLazyCompilation);
// If the user specifically requested an argv[0] to pass into the program,
// do it now.
if (!FakeArgv0.empty()) {
InputFile = FakeArgv0;
} else {
// Otherwise, if there is a .bc suffix on the executable strip it off, it
// might confuse the program.
if (StringRef(InputFile).endswith(".bc"))
InputFile.erase(InputFile.length() - 3);
}
// Add the module's name to the start of the vector of arguments to main().
InputArgv.insert(InputArgv.begin(), InputFile);
// Call the main function from M as if its signature were:
// int main (int argc, char **argv, const char **envp)
// using the contents of Args to determine argc & argv, and the contents of
// EnvVars to determine envp.
//
Function *EntryFn = Mod->getFunction(EntryFunc);
if (!EntryFn) {
errs() << '\'' << EntryFunc << "\' function not found in module.\n";
return -1;
}
// Reset errno to zero on entry to main.
errno = 0;
int Result;
if (!RemoteMCJIT) {
// If the program doesn't explicitly call exit, we will need the Exit
// function later on to make an explicit call, so get the function now.
Constant *Exit = Mod->getOrInsertFunction("exit", Type::getVoidTy(Context),
Type::getInt32Ty(Context),
NULL);
// Run static constructors.
if (UseMCJIT && !ForceInterpreter) {
// Give MCJIT a chance to apply relocations and set page permissions.
EE->finalizeObject();
}
EE->runStaticConstructorsDestructors(false);
if (!UseMCJIT && NoLazyCompilation) {
for (Module::iterator I = Mod->begin(), E = Mod->end(); I != E; ++I) {
Function *Fn = &*I;
if (Fn != EntryFn && !Fn->isDeclaration())
EE->getPointerToFunction(Fn);
}
}
// Trigger compilation separately so code regions that need to be
// invalidated will be known.
(void)EE->getPointerToFunction(EntryFn);
// Clear instruction cache before code will be executed.
if (RTDyldMM)
static_cast<SectionMemoryManager*>(RTDyldMM)->invalidateInstructionCache();
// Run main.
Result = EE->runFunctionAsMain(EntryFn, InputArgv, envp);
// Run static destructors.
EE->runStaticConstructorsDestructors(true);
// If the program didn't call exit explicitly, we should call it now.
// This ensures that any atexit handlers get called correctly.
if (Function *ExitF = dyn_cast<Function>(Exit)) {
std::vector<GenericValue> Args;
GenericValue ResultGV;
ResultGV.IntVal = APInt(32, Result);
Args.push_back(ResultGV);
EE->runFunction(ExitF, Args);
errs() << "ERROR: exit(" << Result << ") returned!\n";
abort();
} else {
errs() << "ERROR: exit defined with wrong prototype!\n";
abort();
}
} else {
// else == "if (RemoteMCJIT)"
// Remote target MCJIT doesn't (yet) support static constructors. No reason
// it couldn't. This is a limitation of the LLI implemantation, not the
// MCJIT itself. FIXME.
//
RemoteMemoryManager *MM = static_cast<RemoteMemoryManager*>(RTDyldMM);
// Everything is prepared now, so lay out our program for the target
// address space, assign the section addresses to resolve any relocations,
// and send it to the target.
OwningPtr<RemoteTarget> Target;
if (!MCJITRemoteProcess.empty()) { // Remote execution on a child process
if (!RemoteTarget::hostSupportsExternalRemoteTarget()) {
errs() << "Warning: host does not support external remote targets.\n"
<< " Defaulting to simulated remote execution\n";
Target.reset(RemoteTarget::createRemoteTarget());
} else {
std::string ChildEXE = sys::FindProgramByName(MCJITRemoteProcess);
if (ChildEXE == "") {
errs() << "Unable to find child target: '\''" << MCJITRemoteProcess << "\'\n";
return -1;
}
Target.reset(RemoteTarget::createExternalRemoteTarget(ChildEXE));
}
} else {
// No child process name provided, use simulated remote execution.
Target.reset(RemoteTarget::createRemoteTarget());
}
// Give the memory manager a pointer to our remote target interface object.
MM->setRemoteTarget(Target.get());
// Create the remote target.
Target->create();
// Since we're executing in a (at least simulated) remote address space,
// we can't use the ExecutionEngine::runFunctionAsMain(). We have to
// grab the function address directly here and tell the remote target
// to execute the function.
//
// Our memory manager will map generated code into the remote address
// space as it is loaded and copy the bits over during the finalizeMemory
// operation.
//
// FIXME: argv and envp handling.
uint64_t Entry = EE->getFunctionAddress(EntryFn->getName().str());
DEBUG(dbgs() << "Executing '" << EntryFn->getName() << "' at 0x"
<< format("%llx", Entry) << "\n");
if (Target->executeCode(Entry, Result))
errs() << "ERROR: " << Target->getErrorMsg() << "\n";
// Like static constructors, the remote target MCJIT support doesn't handle
// this yet. It could. FIXME.
// Stop the remote target
Target->stop();
}
return Result;
}
