void
LLVMPassManagerBuilderPopulateFunctionPassManager(LLVMPassManagerBuilderRef PMB,
LLVMPassManagerRef PM) {
PassManagerBuilder *Builder = unwrap(PMB);
legacy::FunctionPassManager *FPM = unwrap<legacy::FunctionPassManager>(PM);
Builder->populateFunctionPassManager(*FPM);
}
/// This routine adds optimization passes based on selected optimization level,
/// OptLevel.
///
/// OptLevel - Optimization Level
static void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM,
unsigned OptLevel, unsigned SizeLevel) {
FPM.add(createVerifierPass()); // Verify that input is correct
MPM.add(createDebugInfoVerifierPass()); // Verify that debug info is correct
PassManagerBuilder Builder;
Builder.OptLevel = OptLevel;
Builder.SizeLevel = SizeLevel;
if (DisableInline) {
// No inlining pass
} else if (OptLevel > 1) {
Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel);
} else {
Builder.Inliner = createAlwaysInlinerPass();
}
Builder.DisableUnitAtATime = !UnitAtATime;
Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ?
DisableLoopUnrolling : OptLevel == 0;
// This is final, unless there is a #pragma vectorize enable
if (DisableLoopVectorization)
Builder.LoopVectorize = false;
// If option wasn't forced via cmd line (-vectorize-loops, -loop-vectorize)
else if (!Builder.LoopVectorize)
Builder.LoopVectorize = OptLevel > 1 && SizeLevel < 2;
// When #pragma vectorize is on for SLP, do the same as above
Builder.SLPVectorize =
DisableSLPVectorization ? false : OptLevel > 1 && SizeLevel < 2;
Builder.populateFunctionPassManager(FPM);
Builder.populateModulePassManager(MPM);
}
/// AddOptimizationPasses - This routine adds optimization passes
/// based on selected optimization level, OptLevel. This routine
/// duplicates llvm-gcc behaviour.
///
/// OptLevel - Optimization Level
static void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM,
unsigned OptLevel, unsigned SizeLevel) {
FPM.add(createVerifierPass()); // Verify that input is correct
PassManagerBuilder Builder;
Builder.OptLevel = OptLevel;
Builder.SizeLevel = SizeLevel;
if (DisableInline) {
// No inlining pass
} else if (OptLevel > 1) {
unsigned Threshold = 225;
if (SizeLevel == 1) // -Os
Threshold = 75;
else if (SizeLevel == 2) // -Oz
Threshold = 25;
if (OptLevel > 2)
Threshold = 275;
Builder.Inliner = createFunctionInliningPass(Threshold);
} else {
Builder.Inliner = createAlwaysInlinerPass();
}
Builder.DisableUnitAtATime = !UnitAtATime;
Builder.DisableUnrollLoops = OptLevel == 0;
Builder.DisableSimplifyLibCalls = DisableSimplifyLibCalls;
Builder.populateFunctionPassManager(FPM);
Builder.populateModulePassManager(MPM);
}
void LLVMZigOptimizeModule(LLVMTargetMachineRef targ_machine_ref, LLVMModuleRef module_ref) {
TargetMachine* target_machine = reinterpret_cast<TargetMachine*>(targ_machine_ref);
Module* module = unwrap(module_ref);
TargetLibraryInfoImpl tlii(Triple(module->getTargetTriple()));
PassManagerBuilder *PMBuilder = new PassManagerBuilder();
PMBuilder->OptLevel = target_machine->getOptLevel();
PMBuilder->SizeLevel = 0;
PMBuilder->BBVectorize = true;
PMBuilder->SLPVectorize = true;
PMBuilder->LoopVectorize = true;
PMBuilder->DisableUnitAtATime = false;
PMBuilder->DisableUnrollLoops = false;
PMBuilder->MergeFunctions = true;
PMBuilder->PrepareForLTO = true;
PMBuilder->RerollLoops = true;
PMBuilder->addExtension(PassManagerBuilder::EP_EarlyAsPossible, addAddDiscriminatorsPass);
PMBuilder->LibraryInfo = &tlii;
PMBuilder->Inliner = createFunctionInliningPass(PMBuilder->OptLevel, PMBuilder->SizeLevel);
// Set up the per-function pass manager.
legacy::FunctionPassManager *FPM = new legacy::FunctionPassManager(module);
FPM->add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis()));
#ifndef NDEBUG
bool verify_module = true;
#else
bool verify_module = false;
#endif
if (verify_module) {
FPM->add(createVerifierPass());
}
PMBuilder->populateFunctionPassManager(*FPM);
// Set up the per-module pass manager.
legacy::PassManager *MPM = new legacy::PassManager();
MPM->add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis()));
PMBuilder->populateModulePassManager(*MPM);
// run per function optimization passes
FPM->doInitialization();
for (Function &F : *module)
if (!F.isDeclaration())
FPM->run(F);
FPM->doFinalization();
// run per module optimization passes
MPM->run(*module);
}
LLVMFormula::LLVMFormula ()
{
// We need to initialize the native target info, once.
static bool initializeNative = false;
if (!initializeNative)
{
InitializeNativeTarget ();
initializeNative = true;
}
// Build a module and a JIT engine
module = new Module ("AFormula JIT", getGlobalContext ());
// The Engine is going to take control of this module,
// don't delete them later.
std::string errorString;
engine = EngineBuilder (module).setErrorStr (&errorString).create ();
if (!engine)
{
// We won't let you call buildFunction if you catch this error
errorMessage.reset (new std::string ("LLVM Error: " + errorString));
return;
}
// Create an IRBuilder
builder = new IRBuilder<> (getGlobalContext ());
// Get a data layout for this module
const std::string &moduleDataLayout = module->getDataLayout ();
if (!moduleDataLayout.empty ())
TD = new DataLayout (moduleDataLayout);
else
TD = NULL;
// Build an optimizer. We're going to get default optimization settings
// in the same way that LLVM does.
FPM = new FunctionPassManager (module);
if (TD)
FPM->add (TD);
FPM->add (createVerifierPass());
PassManagerBuilder builder;
builder.OptLevel = 3;
builder.populateFunctionPassManager (*FPM);
FPM->doInitialization ();
}
/**
* Adds a set of optimization passes to the given module/function pass
* managers based on the given optimization and size reduction levels.
*
* The selection mirrors Clang behavior and is based on LLVM's
* PassManagerBuilder.
*/
static void addOptimizationPasses(PassManagerBase &mpm, FunctionPassManager &fpm,
unsigned optLevel, unsigned sizeLevel) {
fpm.add(createVerifierPass()); // Verify that input is correct
PassManagerBuilder builder;
builder.OptLevel = optLevel;
builder.SizeLevel = sizeLevel;
if (willInline()) {
unsigned threshold = 225;
if (sizeLevel == 1) // -Os
threshold = 75;
else if (sizeLevel == 2) // -Oz
threshold = 25;
if (optLevel > 2)
threshold = 275;
builder.Inliner = createFunctionInliningPass(threshold);
} else {
builder.Inliner = createAlwaysInlinerPass();
}
builder.DisableSimplifyLibCalls = disableSimplifyLibCalls;
builder.DisableUnitAtATime = !unitAtATime;
builder.DisableUnrollLoops = optLevel == 0;
/* builder.Vectorize is set in ctor from command line switch */
if (!disableLangSpecificPasses) {
if (!disableSimplifyDruntimeCalls)
builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd, addSimplifyDRuntimeCallsPass);
#if USE_METADATA
if (!disableGCToStack)
builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd, addGarbageCollect2StackPass);
#endif // USE_METADATA
}
#if LDC_LLVM_VER >= 301
// EP_OptimizerLast does not exist in LLVM 3.0, add it manually below.
builder.addExtension(PassManagerBuilder::EP_OptimizerLast, addStripExternalsPass);
#endif
builder.populateFunctionPassManager(fpm);
builder.populateModulePassManager(mpm);
#if LDC_LLVM_VER < 301
addStripExternalsPass(builder, mpm);
#endif
}
/// This routine adds optimization passes based on selected optimization level,
/// OptLevel.
///
/// OptLevel - Optimization Level
static void AddOptimizationPasses(legacy::PassManagerBase &MPM,
legacy::FunctionPassManager &FPM,
TargetMachine *TM, unsigned OptLevel,
unsigned SizeLevel) {
if (!NoVerify || VerifyEach)
FPM.add(createVerifierPass()); // Verify that input is correct
PassManagerBuilder Builder;
Builder.OptLevel = OptLevel;
Builder.SizeLevel = SizeLevel;
if (DisableInline) {
// No inlining pass
} else if (OptLevel > 1) {
Builder.Inliner = createFunctionInliningPass(OptLevel, SizeLevel);
} else {
Builder.Inliner = createAlwaysInlinerLegacyPass();
}
Builder.DisableUnitAtATime = !UnitAtATime;
Builder.DisableUnrollLoops = (DisableLoopUnrolling.getNumOccurrences() > 0) ?
DisableLoopUnrolling : OptLevel == 0;
// This is final, unless there is a #pragma vectorize enable
if (DisableLoopVectorization)
Builder.LoopVectorize = false;
// If option wasn't forced via cmd line (-vectorize-loops, -loop-vectorize)
else if (!Builder.LoopVectorize)
Builder.LoopVectorize = OptLevel > 1 && SizeLevel < 2;
// When #pragma vectorize is on for SLP, do the same as above
Builder.SLPVectorize =
DisableSLPVectorization ? false : OptLevel > 1 && SizeLevel < 2;
// Add target-specific passes that need to run as early as possible.
if (TM)
Builder.addExtension(
PassManagerBuilder::EP_EarlyAsPossible,
[&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
TM->addEarlyAsPossiblePasses(PM);
});
if (Coroutines)
addCoroutinePassesToExtensionPoints(Builder);
Builder.populateFunctionPassManager(FPM);
Builder.populateModulePassManager(MPM);
}
/// AddOptimizationPasses - This routine adds optimization passes
/// based on selected optimization level, OptLevel. This routine
/// duplicates llvm-gcc behaviour.
///
/// OptLevel - Optimization Level
static void AddOptimizationPasses(PassManagerBase &MPM,FunctionPassManager &FPM,
unsigned OptLevel) {
PassManagerBuilder Builder;
Builder.OptLevel = OptLevel;
if (DisableInline) {
// No inlining pass
} else if (OptLevel > 1) {
unsigned Threshold = 225;
if (OptLevel > 2)
Threshold = 275;
Builder.Inliner = createFunctionInliningPass(Threshold);
} else {
Builder.Inliner = createAlwaysInlinerPass();
}
Builder.DisableUnitAtATime = !UnitAtATime;
Builder.DisableUnrollLoops = OptLevel == 0;
Builder.DisableSimplifyLibCalls = DisableSimplifyLibCalls;
Builder.populateFunctionPassManager(FPM);
Builder.populateModulePassManager(MPM);
}
Function &OptimizeForRuntime(Function &F) {
#ifdef DEBUG
static PassManagerBuilder Builder = getDebugBuilder();
#else
static PassManagerBuilder Builder = getBuilder();
#endif
Module *M = F.getParent();
opt::GenerateOutput = true;
polly::opt::PollyParallel = true;
FunctionPassManager PM = FunctionPassManager(M);
Builder.populateFunctionPassManager(PM);
PM.doInitialization();
PM.run(F);
PM.doFinalization();
if (opt::havePapi()) {
PassManager MPM;
Builder.populateModulePassManager(MPM);
MPM.add(polli::createTraceMarkerPass());
MPM.run(*M);
}
if (opt::haveLikwid()) {
PassManager MPM;
Builder.populateModulePassManager(MPM);
MPM.add(polli::createLikwidMarkerPass());
MPM.run(*M);
}
DEBUG(
StoreModule(*M, M->getModuleIdentifier() + ".after.polly.ll")
);
opt::GenerateOutput = false;
return F;
}
void EmitAssemblyHelper::CreatePasses() {
unsigned OptLevel = CodeGenOpts.OptimizationLevel;
CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
// Handle disabling of LLVM optimization, where we want to preserve the
// internal module before any optimization.
if (CodeGenOpts.DisableLLVMOpts) {
OptLevel = 0;
Inlining = CodeGenOpts.NoInlining;
}
PassManagerBuilder PMBuilder;
PMBuilder.OptLevel = OptLevel;
PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
// In ObjC ARC mode, add the main ARC optimization passes.
if (LangOpts.ObjCAutoRefCount) {
PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
addObjCARCExpandPass);
PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
addObjCARCAPElimPass);
PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
addObjCARCOptPass);
}
if (CodeGenOpts.BoundsChecking > 0) {
BoundsChecking = CodeGenOpts.BoundsChecking;
PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
addBoundsCheckingPass);
PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addBoundsCheckingPass);
}
if (LangOpts.AddressSanitizer) {
PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
addAddressSanitizerPass);
PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addAddressSanitizerPass);
}
if (LangOpts.ThreadSanitizer) {
PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addThreadSanitizerPass);
PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addThreadSanitizerPass);
}
// Figure out TargetLibraryInfo.
Triple TargetTriple(TheModule->getTargetTriple());
PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
if (!CodeGenOpts.SimplifyLibCalls)
PMBuilder.LibraryInfo->disableAllFunctions();
switch (Inlining) {
case CodeGenOptions::NoInlining: break;
case CodeGenOptions::NormalInlining: {
// FIXME: Derive these constants in a principled fashion.
unsigned Threshold = 225;
if (CodeGenOpts.OptimizeSize == 1) // -Os
Threshold = 75;
else if (CodeGenOpts.OptimizeSize == 2) // -Oz
Threshold = 25;
else if (OptLevel > 2)
Threshold = 275;
PMBuilder.Inliner = createFunctionInliningPass(Threshold);
break;
}
case CodeGenOptions::OnlyAlwaysInlining:
// Respect always_inline.
if (OptLevel == 0)
// Do not insert lifetime intrinsics at -O0.
PMBuilder.Inliner = createAlwaysInlinerPass(false);
else
PMBuilder.Inliner = createAlwaysInlinerPass();
break;
}
// Set up the per-function pass manager.
FunctionPassManager *FPM = getPerFunctionPasses();
if (CodeGenOpts.VerifyModule)
FPM->add(createVerifierPass());
PMBuilder.populateFunctionPassManager(*FPM);
// Set up the per-module pass manager.
PassManager *MPM = getPerModulePasses();
if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
CodeGenOpts.EmitGcovArcs,
TargetTriple.isMacOSX()));
if (CodeGenOpts.DebugInfo == CodeGenOptions::NoDebugInfo)
MPM->add(createStripSymbolsPass(true));
}
// Add the memory safety passes for control-flow integrity
if (CodeGenOpts.MemSafety) {
// Make sure everything that can be in an LLVM register is.
MPM->add (createPromoteMemoryToRegisterPass());
MPM->add (createUnifyFunctionExitNodesPass());
MPM->add (new CFIChecks());
}
PMBuilder.populateModulePassManager(*MPM);
if (CodeGenOpts.SoftBound) {
// Make sure SoftBound+CETS is run after optimization with atleast mem2reg run
MPM->add(new DominatorTree());
MPM->add(new DominanceFrontier());
MPM->add(new LoopInfo());
MPM->add(new InitializeSoftBound());
MPM->add(new SoftBoundCETSPass());
}
// Add the memory safety passes
if (CodeGenOpts.MemSafety) {
MPM->add (createCommonMSCInfoPass());
MPM->add (createSAFECodeMSCInfoPass());
// C standard library / format string function transforms
if (!CodeGenOpts.BaggyBounds) {
MPM->add (new StringTransform());
MPM->add (new FormatStringTransform());
MPM->add (new RegisterVarargCallSites());
MPM->add (new LoggingFunctions());
}
MPM->add (new InitAllocas());
MPM->add (createRegisterGlobalsPass(/*RegUncertain=*/true,
/*MakeInternal=*/false));
MPM->add (createRemoveUnsuitableGlobalRegistrationsPass());
MPM->add (new RegisterMainArgs());
MPM->add (createInstrumentFreeCallsPass());
MPM->add (new RegisterCustomizedAllocation());
MPM->add (new LoopInfo ());
MPM->add (new DominatorTree ());
MPM->add (createRegisterStackPoolsPass(/*RegByval=*/true));
MPM->add (createUnregisterStackPoolsPass());
MPM->add (createSpecializeCMSCallsPass());
MPM->add (new RegisterRuntimeInitializer(CodeGenOpts.MemSafetyLogFile.c_str()));
MPM->add (new DebugInstrument());
MPM->add (createInstrumentMemoryAccessesPass());
MPM->add (createInstrumentGEPsPass());
MPM->add (createSpecializeCMSCallsPass());
MPM->add (new ScalarEvolution());
MPM->add (new ArrayBoundsCheckLocal());
MPM->add (createOptimizeGEPChecksPass());
MPM->add (createExactCheckOptPass());
MPM->add (new ScalarEvolution());
MPM->add (createLocalArrayBoundsAnalysisPass());
MPM->add (createOptimizeFastMemoryChecksPass());
MPM->add (createOptimizeIdenticalLSChecksPass());
MPM->add (new DominatorTree());
MPM->add (new ScalarEvolution());
MPM->add (createOptimizeImpliedFastLSChecksPass());
MPM->add (new OptimizeChecks());
MPM->add (createOptimizeMemoryRegistrationsPass(/*AllowFastChecks=*/true));
if (CodeGenOpts.MemSafeTerminate) {
MPM->add (llvm::createSCTerminatePass ());
}
}
if (CodeGenOpts.BaggyBounds) {
MPM->add (new InsertBaggyBoundsChecks());
}
//
// Rerun the LLVM optimizations again.
//
PMBuilder.populateModulePassManager(*MPM);
// For SAFECode, do the debug instrumentation and OOB rewriting after
// all optimization is done.
if (CodeGenOpts.MemSafety) {
MPM->add (new DebugInstrument());
MPM->add (new RewriteOOB());
}
}
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;
}
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
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 swift::performLLVMOptimizations(IRGenOptions &Opts, llvm::Module *Module,
llvm::TargetMachine *TargetMachine) {
SharedTimer timer("LLVM optimization");
// Set up a pipeline.
PassManagerBuilder PMBuilder;
if (Opts.Optimize && !Opts.DisableLLVMOptzns) {
PMBuilder.OptLevel = 3;
PMBuilder.Inliner = llvm::createFunctionInliningPass(200);
PMBuilder.SLPVectorize = true;
PMBuilder.LoopVectorize = true;
PMBuilder.MergeFunctions = true;
} else {
PMBuilder.OptLevel = 0;
if (!Opts.DisableLLVMOptzns)
PMBuilder.Inliner =
llvm::createAlwaysInlinerPass(/*insertlifetime*/false);
}
PMBuilder.addExtension(PassManagerBuilder::EP_ModuleOptimizerEarly,
addSwiftStackPromotionPass);
// If the optimizer is enabled, we run the ARCOpt pass in the scalar optimizer
// and the Contract pass as late as possible.
if (!Opts.DisableLLVMARCOpts) {
PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
addSwiftARCOptPass);
PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addSwiftContractPass);
}
if (Opts.Sanitize == SanitizerKind::Address) {
PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addAddressSanitizerPasses);
PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addAddressSanitizerPasses);
}
if (Opts.Sanitize == SanitizerKind::Thread) {
PMBuilder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addThreadSanitizerPass);
PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addThreadSanitizerPass);
}
// Configure the function passes.
legacy::FunctionPassManager FunctionPasses(Module);
FunctionPasses.add(createTargetTransformInfoWrapperPass(
TargetMachine->getTargetIRAnalysis()));
if (Opts.Verify)
FunctionPasses.add(createVerifierPass());
PMBuilder.populateFunctionPassManager(FunctionPasses);
// The PMBuilder only knows about LLVM AA passes. We should explicitly add
// the swift AA pass after the other ones.
if (!Opts.DisableLLVMARCOpts) {
FunctionPasses.add(createSwiftAAWrapperPass());
FunctionPasses.add(createExternalAAWrapperPass([](Pass &P, Function &,
AAResults &AAR) {
if (auto *WrapperPass = P.getAnalysisIfAvailable<SwiftAAWrapperPass>())
AAR.addAAResult(WrapperPass->getResult());
}));
}
// Run the function passes.
FunctionPasses.doInitialization();
for (auto I = Module->begin(), E = Module->end(); I != E; ++I)
if (!I->isDeclaration())
FunctionPasses.run(*I);
FunctionPasses.doFinalization();
// Configure the module passes.
legacy::PassManager ModulePasses;
ModulePasses.add(createTargetTransformInfoWrapperPass(
TargetMachine->getTargetIRAnalysis()));
PMBuilder.populateModulePassManager(ModulePasses);
// The PMBuilder only knows about LLVM AA passes. We should explicitly add
// the swift AA pass after the other ones.
if (!Opts.DisableLLVMARCOpts) {
ModulePasses.add(createSwiftAAWrapperPass());
ModulePasses.add(createExternalAAWrapperPass([](Pass &P, Function &,
AAResults &AAR) {
if (auto *WrapperPass = P.getAnalysisIfAvailable<SwiftAAWrapperPass>())
AAR.addAAResult(WrapperPass->getResult());
}));
}
// If we're generating a profile, add the lowering pass now.
if (Opts.GenerateProfile)
ModulePasses.add(createInstrProfilingPass());
if (Opts.Verify)
ModulePasses.add(createVerifierPass());
if (Opts.PrintInlineTree)
ModulePasses.add(createInlineTreePrinterPass());
// Do it.
ModulePasses.run(*Module);
}
void EmitAssemblyHelper::CreatePasses() {
unsigned OptLevel = CodeGenOpts.OptimizationLevel;
CodeGenOptions::InliningMethod Inlining = CodeGenOpts.Inlining;
// Handle disabling of LLVM optimization, where we want to preserve the
// internal module before any optimization.
if (CodeGenOpts.DisableLLVMOpts) {
OptLevel = 0;
Inlining = CodeGenOpts.NoInlining;
}
PassManagerBuilder PMBuilder;
PMBuilder.OptLevel = OptLevel;
PMBuilder.SizeLevel = CodeGenOpts.OptimizeSize;
PMBuilder.DisableSimplifyLibCalls = !CodeGenOpts.SimplifyLibCalls;
PMBuilder.DisableUnitAtATime = !CodeGenOpts.UnitAtATime;
PMBuilder.DisableUnrollLoops = !CodeGenOpts.UnrollLoops;
// In ObjC ARC mode, add the main ARC optimization passes.
if (LangOpts.ObjCAutoRefCount) {
PMBuilder.addExtension(PassManagerBuilder::EP_EarlyAsPossible,
addObjCARCExpandPass);
PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
addObjCARCOptPass);
}
if (LangOpts.AddressSanitizer) {
PMBuilder.addExtension(PassManagerBuilder::EP_ScalarOptimizerLate,
addAddressSanitizerPass);
PMBuilder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addAddressSanitizerPass);
}
// Figure out TargetLibraryInfo.
Triple TargetTriple(TheModule->getTargetTriple());
PMBuilder.LibraryInfo = new TargetLibraryInfo(TargetTriple);
if (!CodeGenOpts.SimplifyLibCalls)
PMBuilder.LibraryInfo->disableAllFunctions();
switch (Inlining) {
case CodeGenOptions::NoInlining: break;
case CodeGenOptions::NormalInlining: {
// FIXME: Derive these constants in a principled fashion.
unsigned Threshold = 225;
if (CodeGenOpts.OptimizeSize == 1) // -Os
Threshold = 75;
else if (CodeGenOpts.OptimizeSize == 2) // -Oz
Threshold = 25;
else if (OptLevel > 2)
Threshold = 275;
PMBuilder.Inliner = createFunctionInliningPass(Threshold);
break;
}
case CodeGenOptions::OnlyAlwaysInlining:
// Respect always_inline.
PMBuilder.Inliner = createAlwaysInlinerPass();
break;
}
// Set up the per-function pass manager.
FunctionPassManager *FPM = getPerFunctionPasses();
if (CodeGenOpts.VerifyModule)
FPM->add(createVerifierPass());
PMBuilder.populateFunctionPassManager(*FPM);
// Set up the per-module pass manager.
PassManager *MPM = getPerModulePasses();
if (CodeGenOpts.EmitGcovArcs || CodeGenOpts.EmitGcovNotes) {
MPM->add(createGCOVProfilerPass(CodeGenOpts.EmitGcovNotes,
CodeGenOpts.EmitGcovArcs,
TargetTriple.isMacOSX()));
if (!CodeGenOpts.DebugInfo)
MPM->add(createStripSymbolsPass(true));
}
PMBuilder.populateModulePassManager(*MPM);
}
static void addOptimizationPasses(PassManagerBase &mpm, FunctionPassManager &fpm,
#endif
unsigned optLevel, unsigned sizeLevel) {
fpm.add(createVerifierPass()); // Verify that input is correct
PassManagerBuilder builder;
builder.OptLevel = optLevel;
builder.SizeLevel = sizeLevel;
if (willInline()) {
unsigned threshold = 225;
if (sizeLevel == 1) // -Os
threshold = 75;
else if (sizeLevel == 2) // -Oz
threshold = 25;
if (optLevel > 2)
threshold = 275;
builder.Inliner = createFunctionInliningPass(threshold);
} else {
builder.Inliner = createAlwaysInlinerPass();
}
#if LDC_LLVM_VER < 304
builder.DisableSimplifyLibCalls = disableSimplifyLibCalls;
#endif
builder.DisableUnitAtATime = !unitAtATime;
builder.DisableUnrollLoops = optLevel == 0;
#if LDC_LLVM_VER >= 304
builder.DisableUnrollLoops = (disableLoopUnrolling.getNumOccurrences() > 0) ?
disableLoopUnrolling : optLevel == 0;
// This is final, unless there is a #pragma vectorize enable
if (disableLoopVectorization)
builder.LoopVectorize = false;
// If option wasn't forced via cmd line (-vectorize-loops, -loop-vectorize)
else if (!builder.LoopVectorize)
builder.LoopVectorize = optLevel > 1 && sizeLevel < 2;
// When #pragma vectorize is on for SLP, do the same as above
builder.SLPVectorize =
disableSLPVectorization ? false : optLevel > 1 && sizeLevel < 2;
#else
/* builder.Vectorize is set in ctor from command line switch */
#endif
#if LDC_LLVM_VER >= 303
if (opts::sanitize == opts::AddressSanitizer) {
builder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addAddressSanitizerPasses);
builder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addAddressSanitizerPasses);
}
if (opts::sanitize == opts::MemorySanitizer) {
builder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addMemorySanitizerPass);
builder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addMemorySanitizerPass);
}
if (opts::sanitize == opts::ThreadSanitizer) {
builder.addExtension(PassManagerBuilder::EP_OptimizerLast,
addThreadSanitizerPass);
builder.addExtension(PassManagerBuilder::EP_EnabledOnOptLevel0,
addThreadSanitizerPass);
}
#endif
if (!disableLangSpecificPasses) {
if (!disableSimplifyDruntimeCalls)
builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd, addSimplifyDRuntimeCallsPass);
if (!disableGCToStack)
builder.addExtension(PassManagerBuilder::EP_LoopOptimizerEnd, addGarbageCollect2StackPass);
}
// EP_OptimizerLast does not exist in LLVM 3.0, add it manually below.
builder.addExtension(PassManagerBuilder::EP_OptimizerLast, addStripExternalsPass);
builder.populateFunctionPassManager(fpm);
builder.populateModulePassManager(mpm);
}
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;
}
vector<char> CodeGen_PTX_Dev::compile_to_src() {
#ifdef WITH_PTX
debug(2) << "In CodeGen_PTX_Dev::compile_to_src";
// DISABLED - hooked in here to force PrintBeforeAll option - seems to be the only way?
/*char* argv[] = { "llc", "-print-before-all" };*/
/*int argc = sizeof(argv)/sizeof(char*);*/
/*cl::ParseCommandLineOptions(argc, argv, "Halide PTX internal compiler\n");*/
llvm::Triple triple(module->getTargetTriple());
// Allocate target machine
std::string err_str;
const llvm::Target *target = TargetRegistry::lookupTarget(triple.str(), err_str);
internal_assert(target) << err_str << "\n";
TargetOptions options;
#if LLVM_VERSION < 50
options.LessPreciseFPMADOption = true;
#endif
options.PrintMachineCode = false;
options.AllowFPOpFusion = FPOpFusion::Fast;
options.UnsafeFPMath = true;
options.NoInfsFPMath = true;
options.NoNaNsFPMath = true;
options.HonorSignDependentRoundingFPMathOption = false;
options.NoZerosInBSS = false;
options.GuaranteedTailCallOpt = false;
options.StackAlignmentOverride = 0;
std::unique_ptr<TargetMachine>
target_machine(target->createTargetMachine(triple.str(),
mcpu(), mattrs(), options,
llvm::Reloc::PIC_,
#if LLVM_VERSION < 60
llvm::CodeModel::Default,
#else
llvm::CodeModel::Small,
#endif
CodeGenOpt::Aggressive));
internal_assert(target_machine.get()) << "Could not allocate target machine!";
#if LLVM_VERSION >= 60
module->setDataLayout(target_machine->createDataLayout());
#endif
// Set up passes
llvm::SmallString<8> outstr;
raw_svector_ostream ostream(outstr);
ostream.SetUnbuffered();
legacy::FunctionPassManager function_pass_manager(module.get());
legacy::PassManager module_pass_manager;
module_pass_manager.add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis()));
function_pass_manager.add(createTargetTransformInfoWrapperPass(target_machine->getTargetIRAnalysis()));
// NVidia's libdevice library uses a __nvvm_reflect to choose
// how to handle denormalized numbers. (The pass replaces calls
// to __nvvm_reflect with a constant via a map lookup. The inliner
// pass then resolves these situations to fast code, often a single
// instruction per decision point.)
//
// The default is (more) IEEE like handling. FTZ mode flushes them
// to zero. (This may only apply to single-precision.)
//
// The libdevice documentation covers other options for math accuracy
// such as replacing division with multiply by the reciprocal and
// use of fused-multiply-add, but they do not seem to be controlled
// by this __nvvvm_reflect mechanism and may be flags to earlier compiler
// passes.
#define kDefaultDenorms 0
#define kFTZDenorms 1
#if LLVM_VERSION <= 40
StringMap<int> reflect_mapping;
reflect_mapping[StringRef("__CUDA_FTZ")] = kFTZDenorms;
module_pass_manager.add(createNVVMReflectPass(reflect_mapping));
#else
// Insert a module flag for the FTZ handling.
module->addModuleFlag(llvm::Module::Override, "nvvm-reflect-ftz",
kFTZDenorms);
if (kFTZDenorms) {
for (llvm::Function &fn : *module) {
fn.addFnAttr("nvptx-f32ftz", "true");
}
}
#endif
PassManagerBuilder b;
b.OptLevel = 3;
#if LLVM_VERSION >= 50
b.Inliner = createFunctionInliningPass(b.OptLevel, 0, false);
#else
b.Inliner = createFunctionInliningPass(b.OptLevel, 0);
#endif
b.LoopVectorize = true;
b.SLPVectorize = true;
#if LLVM_VERSION > 40
target_machine->adjustPassManager(b);
#endif
b.populateFunctionPassManager(function_pass_manager);
b.populateModulePassManager(module_pass_manager);
// Override default to generate verbose assembly.
target_machine->Options.MCOptions.AsmVerbose = true;
// Output string stream
// Ask the target to add backend passes as necessary.
bool fail = target_machine->addPassesToEmitFile(module_pass_manager, ostream,
TargetMachine::CGFT_AssemblyFile,
true);
if (fail) {
internal_error << "Failed to set up passes to emit PTX source\n";
}
// Run optimization passes
function_pass_manager.doInitialization();
for (llvm::Module::iterator i = module->begin(); i != module->end(); i++) {
function_pass_manager.run(*i);
}
function_pass_manager.doFinalization();
module_pass_manager.run(*module);
if (debug::debug_level() >= 2) {
dump();
}
debug(2) << "Done with CodeGen_PTX_Dev::compile_to_src";
debug(1) << "PTX kernel:\n" << outstr.c_str() << "\n";
vector<char> buffer(outstr.begin(), outstr.end());
buffer.push_back(0);
return buffer;
#else // WITH_PTX
return vector<char>();
#endif
}
int main(int argc, char* argv[])
{
if(argc < 2)
{
cerr << "Usage: " << argv[0] << " bf_file" << endl;
return -1;
}
ifstream sourceFile(argv[1]);
string line, source;
while(getline(sourceFile, line)) source += line;
// Setup a module and engine for JIT-ing
std::string error;
InitializeNativeTarget();
Module* module = new Module("bfcode", getGlobalContext());
InitializeNativeTarget();
LLVMLinkInJIT();
ExecutionEngine *engine = EngineBuilder(module)
.setErrorStr(&error)
.setOptLevel(CodeGenOpt::Aggressive)
.create();
if(!engine)
{
cout << "No engine created: " << error << endl;
return -1;
}
module->setDataLayout(engine->getTargetData()->getStringRepresentation());
// Compile the BF to IR
cout << "Parsing… " << flush;
Function* func = makeFunc(module, source.c_str());
cout << "done" << endl;
{
ofstream dst("out.ll");
raw_os_ostream rawdst(dst);
rawdst << *module;
}
// Run optimization passes
cout << "Optimizing… " << flush;
PassManagerBuilder PMBuilder;
FunctionPassManager pm(module);
PMBuilder.populateFunctionPassManager(pm);
pm.add(new TargetData(*(engine->getTargetData())));
pm.add(createVerifierPass());
// Eliminate simple loops such as [>>++<<-]
pm.add(createInstructionCombiningPass()); // Cleanup for scalarrepl.
pm.add(createLICMPass()); // Hoist loop invariants
pm.add(createPromoteMemoryToRegisterPass());
pm.add(createIndVarSimplifyPass()); // Canonicalize indvars
pm.add(createLoopDeletionPass()); // Delete dead loops
pm.add(createConstantPropagationPass()); // Propagate constants
pm.add(new CondProp); // Propagate conditionals
// Simplify code
for(int repeat=0; repeat < 3; repeat++)
{
pm.add(createPromoteMemoryToRegisterPass());
pm.add(createGVNPass()); // Remove redundancies
pm.add(createSCCPPass()); // Constant prop with SCCP
pm.add(createLoopDeletionPass());
pm.add(createLoopUnrollPass());
pm.add(createCFGSimplificationPass()); // Merge & remove BBs
pm.add(createInstructionCombiningPass());
pm.add(createConstantPropagationPass()); // Propagate constants
pm.add(createAggressiveDCEPass()); // Delete dead instructions
pm.add(createCFGSimplificationPass()); // Merge & remove BBs
pm.add(createDeadStoreEliminationPass()); // Delete dead stores
pm.add(createMemCpyOptPass()); // Combine multiple stores into memset's
//pm.add(new PutCharAggregatePass);
}
pm.add(createPromoteMemoryToRegisterPass());
// Process
foreach (Function& f, *module)
if (!f.isDeclaration)
pm.run(f);
PassManager pmm;
PMBuilder.populateModulePassManager(pmm);
pmm.add(createConstantMergePass());
pmm.add(createGlobalOptimizerPass());
pmm.add(createGlobalDCEPass());
pmm.add(createIPConstantPropagationPass());
pmm.run(*module);
foreach (Function& f, *module)
if (!f.isDeclaration)
pm.run(f);
pmm.run(*module);
cout << "done" << endl;
{
ofstream dst("optout.ll");
raw_os_ostream rawdst(dst);
rawdst << *module;
}
// Compile …
cout << "Compiling…" << flush;
int (*bf)() = (int (*)())engine->getPointerToFunction(func);
cout << " done" << endl;
// … and run!
return bf();
}