/// Optimize merged modules using various IPO passes
bool LTOCodeGenerator::generateObjectFile(raw_ostream &out,
bool DisableOpt,
bool DisableInline,
bool DisableGVNLoadPRE,
bool DisableVectorization,
std::string &errMsg) {
if (!this->determineTarget(errMsg))
return false;
Module *mergedModule = IRLinker.getModule();
// Mark which symbols can not be internalized
this->applyScopeRestrictions();
// Instantiate the pass manager to organize the passes.
PassManager passes;
// Add an appropriate DataLayout instance for this module...
mergedModule->setDataLayout(TargetMach->getSubtargetImpl()->getDataLayout());
Triple TargetTriple(TargetMach->getTargetTriple());
PassManagerBuilder PMB;
PMB.DisableGVNLoadPRE = DisableGVNLoadPRE;
PMB.LoopVectorize = !DisableVectorization;
PMB.SLPVectorize = !DisableVectorization;
if (!DisableInline)
PMB.Inliner = createFunctionInliningPass();
PMB.LibraryInfo = new TargetLibraryInfo(TargetTriple);
if (DisableOpt)
PMB.OptLevel = 0;
PMB.VerifyInput = true;
PMB.VerifyOutput = true;
PMB.populateLTOPassManager(passes, TargetMach);
PassManager codeGenPasses;
codeGenPasses.add(new DataLayoutPass());
formatted_raw_ostream Out(out);
// If the bitcode files contain ARC code and were compiled with optimization,
// the ObjCARCContractPass must be run, so do it unconditionally here.
codeGenPasses.add(createObjCARCContractPass());
if (TargetMach->addPassesToEmitFile(codeGenPasses, Out,
TargetMachine::CGFT_ObjectFile)) {
errMsg = "target file type not supported";
return false;
}
// Run our queue of passes all at once now, efficiently.
passes.run(*mergedModule);
// Run the code generator, and write assembly file
codeGenPasses.run(*mergedModule);
return true;
}
void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,
LLVMPassManagerRef PM,
LLVMBool Internalize,
LLVMBool RunInliner) {
PassManagerBuilder *Builder = unwrap(PMB);
PassManagerBase *LPM = unwrap(PM);
Builder->populateLTOPassManager(*LPM, Internalize != 0, RunInliner != 0);
}
static void runLTOPasses(Module &M, TargetMachine &TM) {
PassManager passes;
PassManagerBuilder PMB;
PMB.LibraryInfo = new TargetLibraryInfo(Triple(TM.getTargetTriple()));
PMB.Inliner = createFunctionInliningPass();
PMB.VerifyInput = true;
PMB.VerifyOutput = true;
PMB.populateLTOPassManager(passes, &TM);
passes.run(M);
}
static void AddStandardLinkPasses(legacy::PassManagerBase &PM) {
PassManagerBuilder Builder;
Builder.VerifyInput = true;
if (DisableOptimizations)
Builder.OptLevel = 0;
if (!DisableInline)
Builder.Inliner = createFunctionInliningPass();
Builder.populateLTOPassManager(PM);
}
static void AddStandardLinkPasses(PassManagerBase &PM) {
PM.add(createVerifierPass()); // Verify that input is correct
// If the -strip-debug command line option was specified, do it.
if (StripDebug)
addPass(PM, createStripSymbolsPass(true));
if (DisableOptimizations) return;
PassManagerBuilder Builder;
Builder.populateLTOPassManager(PM, /*Internalize=*/ !DisableInternalize,
/*RunInliner=*/ !DisableInline);
}
/// Optimize merged modules using various IPO passes
bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
bool DisableGVNLoadPRE,
bool DisableVectorization) {
if (!this->determineTarget())
return false;
auto DiagFileOrErr = lto::setupOptimizationRemarks(
Context, LTORemarksFilename, LTOPassRemarksWithHotness);
if (!DiagFileOrErr) {
errs() << "Error: " << toString(DiagFileOrErr.takeError()) << "\n";
report_fatal_error("Can't get an output file for the remarks");
}
DiagnosticOutputFile = std::move(*DiagFileOrErr);
// We always run the verifier once on the merged module, the `DisableVerify`
// parameter only applies to subsequent verify.
verifyMergedModuleOnce();
// Mark which symbols can not be internalized
this->applyScopeRestrictions();
// Instantiate the pass manager to organize the passes.
legacy::PassManager passes;
// Add an appropriate DataLayout instance for this module...
MergedModule->setDataLayout(TargetMach->createDataLayout());
passes.add(
createTargetTransformInfoWrapperPass(TargetMach->getTargetIRAnalysis()));
Triple TargetTriple(TargetMach->getTargetTriple());
PassManagerBuilder PMB;
PMB.DisableGVNLoadPRE = DisableGVNLoadPRE;
PMB.LoopVectorize = !DisableVectorization;
PMB.SLPVectorize = !DisableVectorization;
if (!DisableInline)
PMB.Inliner = createFunctionInliningPass();
PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple);
if (Freestanding)
PMB.LibraryInfo->disableAllFunctions();
PMB.OptLevel = OptLevel;
PMB.VerifyInput = !DisableVerify;
PMB.VerifyOutput = !DisableVerify;
PMB.populateLTOPassManager(passes);
// Run our queue of passes all at once now, efficiently.
passes.run(*MergedModule);
return true;
}
void LLVMPassManagerBuilderPopulateLTOPassManager(LLVMPassManagerBuilderRef PMB,
LLVMPassManagerRef PM,
LLVMBool Internalize,
LLVMBool RunInliner) {
PassManagerBuilder *Builder = unwrap(PMB);
legacy::PassManagerBase *LPM = unwrap(PM);
// A small backwards compatibility hack. populateLTOPassManager used to take
// an RunInliner option.
if (RunInliner && !Builder->Inliner)
Builder->Inliner = createFunctionInliningPass();
Builder->populateLTOPassManager(*LPM);
}
static void runOldLtoPasses(Module &M, TargetMachine &TM) {
// Note that the gold plugin has a similar piece of code, so
// it is probably better to move this code to a common place.
legacy::PassManager LtoPasses;
LtoPasses.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
PassManagerBuilder PMB;
PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
PMB.Inliner = createFunctionInliningPass();
PMB.VerifyInput = PMB.VerifyOutput = !Config->DisableVerify;
PMB.LoopVectorize = true;
PMB.SLPVectorize = true;
PMB.OptLevel = Config->LtoO;
PMB.populateLTOPassManager(LtoPasses);
LtoPasses.run(M);
}
// Run LTO passes.
// Note that the gold plugin has a similar piece of code, so
// it is probably better to move this code to a common place.
static void runLTOPasses(Module &M, TargetMachine &TM) {
legacy::PassManager LtoPasses;
LtoPasses.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
PassManagerBuilder PMB;
PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
PMB.Inliner = createFunctionInliningPass();
PMB.VerifyInput = PMB.VerifyOutput = !Config->DisableVerify;
PMB.LoopVectorize = true;
PMB.SLPVectorize = true;
PMB.OptLevel = Config->LtoO;
PMB.populateLTOPassManager(LtoPasses);
LtoPasses.run(M);
if (Config->SaveTemps)
saveBCFile(M, ".lto.opt.bc");
}
static void runLTOPasses(Module &M, TargetMachine &TM) {
if (const DataLayout *DL = TM.getDataLayout())
M.setDataLayout(*DL);
legacy::PassManager passes;
passes.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
PassManagerBuilder PMB;
PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
PMB.Inliner = createFunctionInliningPass();
PMB.VerifyInput = true;
PMB.VerifyOutput = true;
PMB.LoopVectorize = true;
PMB.SLPVectorize = true;
PMB.OptLevel = options::OptLevel;
PMB.populateLTOPassManager(passes);
passes.run(M);
}
// Generate current module to std::string
std::string* AndroidBitcodeLinker::GenerateBitcode() {
std::string *BCString = new std::string;
Module *M = linker->getModule();
legacy::PassManager PM;
raw_string_ostream Bitcode(*BCString);
PM.add(createVerifierPass());
if (!Config.isDisableOpt()) {
PassManagerBuilder PMBuilder;
PMBuilder.Inliner = createFunctionInliningPass();
PMBuilder.populateLTOPassManager(PM);
}
// Doing clean up passes
if (!Config.isDisableOpt())
{
PM.add(createInstructionCombiningPass());
PM.add(createCFGSimplificationPass());
PM.add(createAggressiveDCEPass());
PM.add(createGlobalDCEPass());
}
// Make sure everything is still good
PM.add(createVerifierPass());
// Strip debug info and symbols.
if (Config.isStripAll() || Config.isStripDebug())
PM.add(createStripSymbolsPass(Config.isStripDebug() && !Config.isStripAll()));
PM.add(createBitcodeWriterPass(Bitcode));
PM.run(*M);
Bitcode.flush();
// Re-compute defined and undefined symbols
UpdateSymbolList(M);
delete M;
delete linker;
linker = 0;
return BCString;
}
static void runLTOPasses(Module &M, TargetMachine &TM) {
M.setDataLayout(TM.createDataLayout());
legacy::PassManager passes;
passes.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis()));
PassManagerBuilder PMB;
PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple()));
PMB.Inliner = createFunctionInliningPass();
// Unconditionally verify input since it is not verified before this
// point and has unknown origin.
PMB.VerifyInput = true;
PMB.VerifyOutput = !options::DisableVerify;
PMB.LoopVectorize = true;
PMB.SLPVectorize = true;
PMB.OptLevel = options::OptLevel;
PMB.populateLTOPassManager(passes);
passes.run(M);
}
/// Optimize merged modules using various IPO passes
bool LTOCodeGenerator::optimize(bool DisableOpt,
bool DisableInline,
bool DisableGVNLoadPRE,
bool DisableVectorization,
std::string &errMsg) {
if (!this->determineTarget(errMsg))
return false;
Module *mergedModule = IRLinker.getModule();
// Mark which symbols can not be internalized
this->applyScopeRestrictions();
// Instantiate the pass manager to organize the passes.
legacy::PassManager passes;
// Add an appropriate DataLayout instance for this module...
mergedModule->setDataLayout(*TargetMach->getDataLayout());
passes.add(
createTargetTransformInfoWrapperPass(TargetMach->getTargetIRAnalysis()));
Triple TargetTriple(TargetMach->getTargetTriple());
PassManagerBuilder PMB;
PMB.DisableGVNLoadPRE = DisableGVNLoadPRE;
PMB.LoopVectorize = !DisableVectorization;
PMB.SLPVectorize = !DisableVectorization;
if (!DisableInline)
PMB.Inliner = createFunctionInliningPass();
PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple);
if (DisableOpt)
PMB.OptLevel = 0;
PMB.VerifyInput = true;
PMB.VerifyOutput = true;
PMB.populateLTOPassManager(passes);
// Run our queue of passes all at once now, efficiently.
passes.run(*mergedModule);
return true;
}
/// Optimize merged modules using various IPO passes
bool LTOCodeGenerator::optimize(bool DisableVerify, bool DisableInline,
bool DisableGVNLoadPRE,
bool DisableVectorization) {
if (!this->determineTarget())
return false;
// We always run the verifier once on the merged module, the `DisableVerify`
// parameter only applies to subsequent verify.
verifyMergedModuleOnce();
// Mark which symbols can not be internalized
this->applyScopeRestrictions();
// Instantiate the pass manager to organize the passes.
legacy::PassManager passes;
// Add an appropriate DataLayout instance for this module...
MergedModule->setDataLayout(TargetMach->createDataLayout());
passes.add(
createTargetTransformInfoWrapperPass(TargetMach->getTargetIRAnalysis()));
Triple TargetTriple(TargetMach->getTargetTriple());
PassManagerBuilder PMB;
PMB.DisableGVNLoadPRE = DisableGVNLoadPRE;
PMB.LoopVectorize = !DisableVectorization;
PMB.SLPVectorize = !DisableVectorization;
if (!DisableInline)
PMB.Inliner = createFunctionInliningPass();
PMB.LibraryInfo = new TargetLibraryInfoImpl(TargetTriple);
PMB.OptLevel = OptLevel;
PMB.VerifyInput = !DisableVerify;
PMB.VerifyOutput = !DisableVerify;
PMB.populateLTOPassManager(passes);
// Run our queue of passes all at once now, efficiently.
passes.run(*MergedModule);
return true;
}
// main - Entry point for the sync compiler.
//
int main(int argc, char **argv) {
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
// Enable debug stream buffering.
EnableDebugBuffering = true;
LLVMContext &Context = getGlobalContext();
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
// Initialize target first, so that --version shows registered targets.
LLVMInitializeVerilogBackendTarget();
LLVMInitializeVerilogBackendTargetInfo();
LLVMInitializeVerilogBackendTargetMC();
cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
SMDiagnostic Err;
LuaScript *S = &scriptEngin();
S->init();
// Run the lua script.
if (!S->runScriptFile(InputFilename, Err)){
Err.print(argv[0], errs());
return 1;
}
S->updateStatus();
// Load the module to be compiled...
std::auto_ptr<Module> M;
M.reset(ParseIRFile(S->getValue<std::string>("InputFile"),
Err, Context));
if (M.get() == 0) {
Err.print(argv[0], errs());
return 1;
}
Module &mod = *M.get();
// TODO: Build the right triple.
Triple TheTriple(mod.getTargetTriple());
TargetOptions TO;
std::auto_ptr<TargetMachine>
target(TheVBackendTarget.createTargetMachine(TheTriple.getTriple(), "",
S->getDataLayout(), TO));
// Build up all of the passes that we want to do to the module.
PassManagerBuilder Builder;
Builder.DisableUnrollLoops = true;
Builder.LibraryInfo = new TargetLibraryInfo();
Builder.LibraryInfo->disableAllFunctions();
Builder.OptLevel = 3;
Builder.SizeLevel = 2;
Builder.DisableSimplifyLibCalls = true;
Builder.Inliner = createHLSInlinerPass();
Builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd,
LoopOptimizerEndExtensionFn);
PassManager Passes;
Passes.add(new TargetData(*target->getTargetData()));
// Add the immutable target-specific alias analysis ahead of all others AAs.
Passes.add(createVAliasAnalysisPass(target->getIntrinsicInfo()));
Passes.add(createVerifierPass());
// This is the final bitcode, internalize it to expose more optimization
// opportunities. Note that we should internalize it before SW/HW partition,
// otherwise we may lost some information that help the later internalize.
Passes.add(createInternalizePass(true));
// Perform Software/Hardware partition.
Passes.add(createFunctionFilterPass(S->getOutputStream("SoftwareIROutput")));
Passes.add(createGlobalDCEPass());
// Optimize the hardware part.
//Builder.populateFunctionPassManager(*FPasses);
Builder.populateModulePassManager(Passes);
Builder.populateLTOPassManager(Passes,
/*Internalize*/true,
/*RunInliner*/true);
//PM.add(createPrintModulePass(&dbgs()));
// We do not use the stream that passing into addPassesToEmitFile.
formatted_raw_ostream formatted_nulls(nulls());
// Ask the target to add backend passes as necessary.
target->addPassesToEmitFile(Passes, formatted_nulls,
TargetMachine::CGFT_Null,
false/*NoVerify*/);
// Analyse the slack between registers.
Passes.add(createCombPathDelayAnalysisPass());
Passes.add(createVerilogASTWriterPass(S->getOutputStream("RTLOutput")));
// Run some scripting passes.
for (LuaScript::scriptpass_it I = S->passes_begin(), E = S->passes_end();
I != E; ++I) {
const luabind::object &o = *I;
Pass *P = createScriptingPass(
luabind::object_cast<std::string>(I.key()).c_str(),
luabind::object_cast<std::string>(o["FunctionScript"]).c_str(),
luabind::object_cast<std::string>(o["GlobalScript"]).c_str());
Passes.add(P);
}
// Run the passes.
Passes.run(mod);
// If no error occur, keep the files.
S->keepAllFiles();
return 0;
}
int main(int argc, char **argv) {
#ifndef DEBUG_BUGPOINT
llvm::sys::PrintStackTraceOnErrorSignal();
llvm::PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
#endif
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeObjCARCOpts(Registry);
initializeVectorization(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeIPA(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeInstrumentation(Registry);
initializeTarget(Registry);
#ifdef LINK_POLLY_INTO_TOOLS
polly::initializePollyPasses(Registry);
#endif
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
#ifndef DEBUG_BUGPOINT
sys::SetInterruptFunction(BugpointInterruptFunction);
#endif
LLVMContext& Context = getGlobalContext();
// If we have an override, set it and then track the triple we want Modules
// to use.
if (!OverrideTriple.empty()) {
TargetTriple.setTriple(Triple::normalize(OverrideTriple));
outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
}
if (MemoryLimit < 0) {
// Set the default MemoryLimit. Be sure to update the flag's description if
// you change this.
if (sys::RunningOnValgrind() || UseValgrind)
MemoryLimit = 800;
else
MemoryLimit = 400;
}
BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
UseValgrind, Context);
if (D.addSources(InputFilenames)) return 1;
AddToDriver PM(D);
if (StandardLinkOpts) {
PassManagerBuilder Builder;
Builder.Inliner = createFunctionInliningPass();
Builder.populateLTOPassManager(PM);
}
if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
PassManagerBuilder Builder;
if (OptLevelO1)
Builder.Inliner = createAlwaysInlinerPass();
else if (OptLevelO2)
Builder.Inliner = createFunctionInliningPass(225);
else
Builder.Inliner = createFunctionInliningPass(275);
// Note that although clang/llvm-gcc use two separate passmanagers
// here, it shouldn't normally make a difference.
Builder.populateFunctionPassManager(PM);
Builder.populateModulePassManager(PM);
}
for (std::vector<const PassInfo*>::iterator I = PassList.begin(),
E = PassList.end();
I != E; ++I) {
const PassInfo* PI = *I;
D.addPass(PI->getPassArgument());
}
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
#ifndef DEBUG_BUGPOINT
sys::Process::PreventCoreFiles();
#endif
std::string Error;
bool Failure = D.run(Error);
if (!Error.empty()) {
errs() << Error;
return 1;
}
return Failure;
}
void CompileContext::CreateEE()
{
string errMsg;
if (verifyModule(*module, &raw_string_ostream(errMsg))) {
Alert((char*)errMsg.c_str());
}
EE.reset(EngineBuilder(module)
.setEngineKind(EngineKind::JIT)
.setUseMCJIT(true)
.setOptLevel(CodeGenOpt::Aggressive)
.create());
EE->InstallLazyFunctionCreator(HspLazyFunctionCreator);
#define REGISTER_RT_(t, name, func) \
do {\
Function *KnownFunction = Function::Create(\
TypeBuilder<t, false>::get(context),\
GlobalValue::ExternalLinkage, name,\
module);\
EE->addGlobalMapping(KnownFunction, (void*)(intptr_t)func);\
} while (false);
#define REGISTER_RT(t, func) REGISTER_RT_(t, #func, func)
REGISTER_RT(void(int, int), Prgcmd);
REGISTER_RT(void(int, int), Modcmd);
REGISTER_RT(void(void*, int, int), VarSet);
REGISTER_RT(void(void*, int), VarSetIndex1);
REGISTER_RT(void(void*, int, int), VarSetIndex2);
REGISTER_RT(void(void*, int, int), VarSetIndex1i);
REGISTER_RT(void(void*, int, int, int), VarSetIndex2i);
REGISTER_RT(void(void*, double, int), VarSetIndex1d);
REGISTER_RT(void(void*, double, int, int), VarSetIndex2d);
REGISTER_RT(void(int), StackPushi);
REGISTER_RT_(void(int), "PushInt", StackPushi);
REGISTER_RT(void(int), StackPushd);
REGISTER_RT_(void(double), "PushDouble", StackPushd);
REGISTER_RT(void(int), StackPushl);
REGISTER_RT_(void(int), "PushLabel", StackPushl);
REGISTER_RT(void(char*), PushStr);
REGISTER_RT(void(void*, int), PushVar);
REGISTER_RT(void(void*, int), PushVAP);
REGISTER_RT(void(), PushDefault);
REGISTER_RT(void(), PushFuncEnd);
REGISTER_RT(void(int), PushFuncPrm1);
REGISTER_RT(void(int), PushFuncPrmI);
REGISTER_RT(void(int), PushFuncPrmD);
REGISTER_RT(void(int, int), PushFuncPrm);
REGISTER_RT(void(int, int), PushFuncPAP);
REGISTER_RT(void*(int), FuncPrm);
REGISTER_RT(void*(int), LocalPrm);
REGISTER_RT(int(int), FuncPrmI);
REGISTER_RT(double(int), FuncPrmD);
REGISTER_RT(void(), CalcAddI);
REGISTER_RT(void(), CalcSubI);
REGISTER_RT(void(), CalcMulI);
REGISTER_RT(void(), CalcDivI);
REGISTER_RT(void(), CalcModI);
REGISTER_RT(void(), CalcAndI);
REGISTER_RT(void(), CalcOrI);
REGISTER_RT(void(), CalcXorI);
REGISTER_RT(void(), CalcEqI);
REGISTER_RT(void(), CalcNeI);
REGISTER_RT(void(), CalcGtI);
REGISTER_RT(void(), CalcLtI);
REGISTER_RT(void(), CalcGtEqI);
REGISTER_RT(void(), CalcLtEqI);
REGISTER_RT(void(), CalcRrI);
REGISTER_RT(void(), CalcLrI);
REGISTER_RT(void(int, int), PushIntfunc);
REGISTER_RT(void(void*, int, int), VarCalc);
REGISTER_RT(void(void*, int), VarInc);
REGISTER_RT(void(int), TaskSwitch);
REGISTER_RT(char(), HspIf);
REGISTER_RT(void(int, int), PushSysvar);
REGISTER_RT(void(int, int), PushExtvar);
REGISTER_RT(void(int, int), PushModcmd);
REGISTER_RT(void(int, int), Extcmd);
REGISTER_RT(void(int, int), Intcmd);
REGISTER_RT(void(int, int), PushDllfunc);
REGISTER_RT(void(int, int), PushDllctrl);
REGISTER_RT(int(), GetTaskID);
//REGISTER_RT(int(Hsp3r*, int, int), Hsp3rReset);
REGISTER_RT(void(void*, int), HspVarCoreArray2);
REGISTER_RT(double(int, int), CallDoubleIntfunc);
REGISTER_RT(int(int, int), CallIntIntfunc);
REGISTER_RT(double(int, int), CallDoubleSysvar);
REGISTER_RT(int(int, int), CallIntSysvar);
REGISTER_RT(int(), PopInt);
REGISTER_RT(double(), PopDouble);
//REGISTER_RT(char(), HspIf);
//REGISTER_RT(void(int, int), PushSysvar);
#undef REGISTER_RT
Passes.reset(new PassManager());
FPM.reset(new FunctionPassManager(module));
Passes->add(new DataLayoutPass(module));
Passes->add(createVerifierPass());
PassManagerBuilder Builder;
Builder.OptLevel = 3;
Builder.SizeLevel = 0;
Builder.Inliner = createFunctionInliningPass(Builder.OptLevel, Builder.SizeLevel);
Builder.populateModulePassManager(*Passes);
Builder.populateLTOPassManager(*Passes, false, true);
Builder.populateFunctionPassManager(*FPM);
Builder.populateModulePassManager(*Passes);
FPM->doInitialization();
for (auto& f : *module) {
// Run the FPM on this function
FPM->run(f);
}
return;
}
int main(int argc, char **argv) {
#ifndef DEBUG_BUGPOINT
llvm::sys::PrintStackTraceOnErrorSignal();
llvm::PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
#endif
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeObjCARCOpts(Registry);
initializeVectorization(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeIPA(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeInstrumentation(Registry);
initializeTarget(Registry);
#ifdef LINK_POLLY_INTO_TOOLS
polly::initializePollyPasses(Registry);
#endif
// @LOCALMOD-BEGIN
initializeAddPNaClExternalDeclsPass(Registry);
initializeAllocateDataSegmentPass(Registry);
initializeBackendCanonicalizePass(Registry);
initializeCanonicalizeMemIntrinsicsPass(Registry);
initializeCleanupUsedGlobalsMetadataPass(Registry);
initializeConstantInsertExtractElementIndexPass(Registry);
initializeExpandAllocasPass(Registry);
initializeExpandArithWithOverflowPass(Registry);
initializeExpandByValPass(Registry);
initializeExpandConstantExprPass(Registry);
initializeExpandCtorsPass(Registry);
initializeExpandGetElementPtrPass(Registry);
initializeExpandIndirectBrPass(Registry);
initializeExpandLargeIntegersPass(Registry);
initializeExpandShuffleVectorPass(Registry);
initializeExpandSmallArgumentsPass(Registry);
initializeExpandStructRegsPass(Registry);
initializeExpandTlsConstantExprPass(Registry);
initializeExpandTlsPass(Registry);
initializeExpandVarArgsPass(Registry);
initializeFixVectorLoadStoreAlignmentPass(Registry);
initializeFlattenGlobalsPass(Registry);
initializeGlobalCleanupPass(Registry);
initializeGlobalizeConstantVectorsPass(Registry);
initializeInsertDivideCheckPass(Registry);
initializeInternalizeUsedGlobalsPass(Registry);
initializeNormalizeAlignmentPass(Registry);
initializePNaClABIVerifyFunctionsPass(Registry);
initializePNaClABIVerifyModulePass(Registry);
initializePNaClSjLjEHPass(Registry);
initializePromoteI1OpsPass(Registry);
initializePromoteIntegersPass(Registry);
initializeRemoveAsmMemoryPass(Registry);
initializeRenameEntryPointPass(Registry);
initializeReplacePtrsWithIntsPass(Registry);
initializeResolveAliasesPass(Registry);
initializeResolvePNaClIntrinsicsPass(Registry);
initializeRewriteAtomicsPass(Registry);
initializeRewriteLLVMIntrinsicsPass(Registry);
initializeRewritePNaClLibraryCallsPass(Registry);
initializeSandboxIndirectCallsPass(Registry);
initializeSandboxMemoryAccessesPass(Registry);
initializeSimplifyAllocasPass(Registry);
initializeSimplifyStructRegSignaturesPass(Registry);
initializeStripAttributesPass(Registry);
initializeStripMetadataPass(Registry);
initializeStripModuleFlagsPass(Registry);
initializeStripTlsPass(Registry);
initializeSubstituteUndefsPass(Registry);
// Emscripten passes:
initializeExpandI64Pass(Registry);
initializeExpandInsertExtractElementPass(Registry);
initializeLowerEmAsyncifyPass(Registry);
initializeLowerEmExceptionsPass(Registry);
initializeLowerEmSetjmpPass(Registry);
initializeNoExitRuntimePass(Registry);
// Emscripten passes end.
// @LOCALMOD-END
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
#ifndef DEBUG_BUGPOINT
sys::SetInterruptFunction(BugpointInterruptFunction);
#endif
LLVMContext& Context = getGlobalContext();
// If we have an override, set it and then track the triple we want Modules
// to use.
if (!OverrideTriple.empty()) {
TargetTriple.setTriple(Triple::normalize(OverrideTriple));
outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
}
if (MemoryLimit < 0) {
// Set the default MemoryLimit. Be sure to update the flag's description if
// you change this.
if (sys::RunningOnValgrind() || UseValgrind)
MemoryLimit = 800;
else
MemoryLimit = 300;
}
BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
UseValgrind, Context);
if (D.addSources(InputFilenames)) return 1;
AddToDriver PM(D);
if (StandardLinkOpts) {
PassManagerBuilder Builder;
Builder.Inliner = createFunctionInliningPass();
Builder.populateLTOPassManager(PM);
}
if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
PassManagerBuilder Builder;
if (OptLevelO1)
Builder.Inliner = createAlwaysInlinerPass();
else if (OptLevelO2)
Builder.Inliner = createFunctionInliningPass(225);
else
Builder.Inliner = createFunctionInliningPass(275);
// Note that although clang/llvm-gcc use two separate passmanagers
// here, it shouldn't normally make a difference.
Builder.populateFunctionPassManager(PM);
Builder.populateModulePassManager(PM);
}
for (std::vector<const PassInfo*>::iterator I = PassList.begin(),
E = PassList.end();
I != E; ++I) {
const PassInfo* PI = *I;
D.addPass(PI->getPassArgument());
}
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
#ifndef DEBUG_BUGPOINT
sys::Process::PreventCoreFiles();
#endif
std::string Error;
bool Failure = D.run(Error);
if (!Error.empty()) {
errs() << Error;
return 1;
}
return Failure;
}
int main(int argc, char **argv) {
#ifndef DEBUG_BUGPOINT
InitLLVM X(argc, argv);
#endif
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeObjCARCOpts(Registry);
initializeVectorization(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeAggressiveInstCombine(Registry);
initializeInstrumentation(Registry);
initializeTarget(Registry);
#ifdef LINK_POLLY_INTO_TOOLS
polly::initializePollyPasses(Registry);
#endif
if (std::getenv("bar") == (char*) -1) {
InitializeAllTargets();
InitializeAllTargetMCs();
InitializeAllAsmPrinters();
InitializeAllAsmParsers();
}
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
#ifndef DEBUG_BUGPOINT
sys::SetInterruptFunction(BugpointInterruptFunction);
#endif
LLVMContext Context;
// If we have an override, set it and then track the triple we want Modules
// to use.
if (!OverrideTriple.empty()) {
TargetTriple.setTriple(Triple::normalize(OverrideTriple));
outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
}
if (MemoryLimit < 0) {
// Set the default MemoryLimit. Be sure to update the flag's description if
// you change this.
if (sys::RunningOnValgrind() || UseValgrind)
MemoryLimit = 800;
else
MemoryLimit = 400;
#if (LLVM_ADDRESS_SANITIZER_BUILD || LLVM_MEMORY_SANITIZER_BUILD || \
LLVM_THREAD_SANITIZER_BUILD)
// Starting from kernel 4.9 memory allocated with mmap is counted against
// RLIMIT_DATA. Sanitizers need to allocate tens of terabytes for shadow.
MemoryLimit = 0;
#endif
}
BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit, UseValgrind,
Context);
if (D.addSources(InputFilenames))
return 1;
AddToDriver PM(D);
if (StandardLinkOpts) {
PassManagerBuilder Builder;
Builder.Inliner = createFunctionInliningPass();
Builder.populateLTOPassManager(PM);
}
if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
PassManagerBuilder Builder;
if (OptLevelO1)
Builder.Inliner = createAlwaysInlinerLegacyPass();
else if (OptLevelOs || OptLevelO2)
Builder.Inliner = createFunctionInliningPass(
2, OptLevelOs ? 1 : 0, false);
else
Builder.Inliner = createFunctionInliningPass(275);
Builder.populateFunctionPassManager(PM);
Builder.populateModulePassManager(PM);
}
for (const PassInfo *PI : PassList)
D.addPass(PI->getPassArgument());
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
#ifndef DEBUG_BUGPOINT
sys::Process::PreventCoreFiles();
#endif
if (Error E = D.run()) {
errs() << toString(std::move(E));
return 1;
}
return 0;
}
