static void addOptimizationPasses(T *PM) { #ifdef JL_DEBUG_BUILD PM->add(createVerifierPass()); #endif #ifdef __has_feature # if __has_feature(address_sanitizer) # if defined(LLVM37) && !defined(LLVM38) // LLVM 3.7 BUG: ASAN pass doesn't properly initialize its dependencies initializeTargetLibraryInfoWrapperPassPass(*PassRegistry::getPassRegistry()); # endif PM->add(createAddressSanitizerFunctionPass()); # endif # if __has_feature(memory_sanitizer) PM->add(llvm::createMemorySanitizerPass(true)); # endif #endif if (jl_options.opt_level <= 1) { return; } #ifdef LLVM37 PM->add(createTargetTransformInfoWrapperPass(jl_TargetMachine->getTargetIRAnalysis())); #else jl_TargetMachine->addAnalysisPasses(*PM); #endif #ifdef LLVM38 PM->add(createTypeBasedAAWrapperPass()); #else PM->add(createTypeBasedAliasAnalysisPass()); #endif if (jl_options.opt_level >= 3) { #ifdef LLVM38 PM->add(createBasicAAWrapperPass()); #else PM->add(createBasicAliasAnalysisPass()); #endif } // list of passes from vmkit PM->add(createCFGSimplificationPass()); // Clean up disgusting code PM->add(createPromoteMemoryToRegisterPass());// Kill useless allocas #ifndef INSTCOMBINE_BUG PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl. #endif PM->add(createSROAPass()); // Break up aggregate allocas #ifndef INSTCOMBINE_BUG PM->add(createInstructionCombiningPass()); // Cleanup for scalarrepl. #endif PM->add(createJumpThreadingPass()); // Thread jumps. // NOTE: CFG simp passes after this point seem to hurt native codegen. // See issue #6112. Should be re-evaluated when we switch to MCJIT. //PM->add(createCFGSimplificationPass()); // Merge & remove BBs #ifndef INSTCOMBINE_BUG PM->add(createInstructionCombiningPass()); // Combine silly seq's #endif //PM->add(createCFGSimplificationPass()); // Merge & remove BBs PM->add(createReassociatePass()); // Reassociate expressions // this has the potential to make some things a bit slower //PM->add(createBBVectorizePass()); PM->add(createEarlyCSEPass()); //// **** PM->add(createLoopIdiomPass()); //// **** PM->add(createLoopRotatePass()); // Rotate loops. // LoopRotate strips metadata from terminator, so run LowerSIMD afterwards PM->add(createLowerSimdLoopPass()); // Annotate loop marked with "simdloop" as LLVM parallel loop PM->add(createLICMPass()); // Hoist loop invariants PM->add(createLoopUnswitchPass()); // Unswitch loops. // Subsequent passes not stripping metadata from terminator #ifndef INSTCOMBINE_BUG PM->add(createInstructionCombiningPass()); #endif PM->add(createIndVarSimplifyPass()); // Canonicalize indvars PM->add(createLoopDeletionPass()); // Delete dead loops #if defined(LLVM35) PM->add(createSimpleLoopUnrollPass()); // Unroll small loops #else PM->add(createLoopUnrollPass()); // Unroll small loops #endif #if !defined(LLVM35) && !defined(INSTCOMBINE_BUG) PM->add(createLoopVectorizePass()); // Vectorize loops #endif //PM->add(createLoopStrengthReducePass()); // (jwb added) #ifndef INSTCOMBINE_BUG PM->add(createInstructionCombiningPass()); // Clean up after the unroller #endif PM->add(createGVNPass()); // Remove redundancies //PM->add(createMemCpyOptPass()); // Remove memcpy / form memset PM->add(createSCCPPass()); // Constant prop with SCCP // Run instcombine after redundancy elimination to exploit opportunities // opened up by them. PM->add(createSinkingPass()); ////////////// **** PM->add(createInstructionSimplifierPass());///////// **** #ifndef INSTCOMBINE_BUG PM->add(createInstructionCombiningPass()); #endif PM->add(createJumpThreadingPass()); // Thread jumps PM->add(createDeadStoreEliminationPass()); // Delete dead stores #if !defined(INSTCOMBINE_BUG) if (jl_options.opt_level >= 3) { #ifdef LLVM39 initializeDemandedBitsPass(*PassRegistry::getPassRegistry()); #endif PM->add(createSLPVectorizerPass()); // Vectorize straight-line code } #endif PM->add(createAggressiveDCEPass()); // Delete dead instructions #if !defined(INSTCOMBINE_BUG) if (jl_options.opt_level >= 3) PM->add(createInstructionCombiningPass()); // Clean up after SLP loop vectorizer #endif #if defined(LLVM35) PM->add(createLoopVectorizePass()); // Vectorize loops PM->add(createInstructionCombiningPass()); // Clean up after loop vectorizer #endif //PM->add(createCFGSimplificationPass()); // Merge & remove BBs }
int main(int argc, char **argv) { llvm::llvm_shutdown_obj shutdown; // calls llvm_shutdown() on exit llvm::cl::ParseCommandLineOptions(argc, argv, "llvm2bpl - LLVM bitcode to Boogie transformation\n"); llvm::sys::PrintStackTraceOnErrorSignal(argv[0]); llvm::PrettyStackTraceProgram PSTP(argc, argv); llvm::EnableDebugBuffering = true; llvm::SMDiagnostic err; llvm::LLVMContext Context; InitializeAllTargets(); InitializeAllTargetMCs(); InitializeAllAsmPrinters(); InitializeAllAsmParsers(); std::unique_ptr<llvm::Module> module = llvm::parseIRFile(InputFilename, err, Context); if (!err.getMessage().empty()) check("Problem reading input bitcode/IR: " + err.getMessage().str()); auto &L = module.get()->getDataLayoutStr(); if (L.empty()) module.get()->setDataLayout(DefaultDataLayout); /////////////////////////////// // initialise and run passes // /////////////////////////////// llvm::PassRegistry &Registry = *llvm::PassRegistry::getPassRegistry(); llvm::initializeAnalysis(Registry); llvm::legacy::PassManager pass_manager; pass_manager.add(llvm::createLowerSwitchPass()); //pass_manager.add(llvm::createCFGSimplificationPass()); pass_manager.add(llvm::createInternalizePass()); pass_manager.add(llvm::createPromoteMemoryToRegisterPass()); if (StaticUnroll) { pass_manager.add(llvm::createLoopSimplifyPass()); pass_manager.add(llvm::createLoopRotatePass()); //pass_manager.add(llvm::createIndVarSimplifyPass()); pass_manager.add(llvm::createLoopUnrollPass(32767)); } pass_manager.add(new llvm::StructRet()); pass_manager.add(new llvm::SimplifyEV()); pass_manager.add(new llvm::SimplifyIV()); pass_manager.add(new smack::ExtractContracts()); pass_manager.add(new smack::VerifierCodeMetadata()); pass_manager.add(llvm::createDeadCodeEliminationPass()); pass_manager.add(new smack::CodifyStaticInits()); if (!Modular) { pass_manager.add(new smack::RemoveDeadDefs()); } pass_manager.add(new llvm::MergeArrayGEP()); // pass_manager.add(new smack::SimplifyLibCalls()); pass_manager.add(new llvm::Devirtualize()); if (SplitStructs) pass_manager.add(new smack::SplitAggregateLoadStore()); if (smack::SmackOptions::MemorySafety) { pass_manager.add(new smack::MemorySafetyChecker()); } if (SignedIntegerOverflow) pass_manager.add(new smack::SignedIntegerOverflowChecker()); if(smack::SmackOptions::AddTiming){ Triple ModuleTriple(module->getTargetTriple()); assert (ModuleTriple.getArch() && "Module has no defined architecture: unable to add timing annotations"); const TargetOptions Options; /* = InitTargetOptionsFromCodeGenFlags();*/ std::string CPUStr = ""; /*getCPUStr();*/ std::string FeaturesStr = ""; /*getFeaturesStr();*/ TargetMachine *Machine = GetTargetMachine(ModuleTriple, CPUStr, FeaturesStr, Options); assert(Machine && "Module did not have a Target Machine: Cannot set up timing pass"); // Add an appropriate TargetLibraryInfo pass for the module's triple. TargetLibraryInfoImpl TLII(ModuleTriple); pass_manager.add(new TargetLibraryInfoWrapperPass(TLII)); // Add internal analysis passes from the target machine. pass_manager.add(createTargetTransformInfoWrapperPass(Machine->getTargetIRAnalysis())); pass_manager.add(new smack::AddTiming()); } std::vector<tool_output_file*> files; if (!FinalIrFilename.empty()) { std::error_code EC; auto F = new tool_output_file(FinalIrFilename.c_str(), EC, sys::fs::F_None); if (EC) check(EC.message()); F->keep(); files.push_back(F); pass_manager.add(llvm::createPrintModulePass(F->os())); } if (!OutputFilename.empty()) { std::error_code EC; auto F = new tool_output_file(OutputFilename.c_str(), EC, sys::fs::F_None); if (EC) check(EC.message()); F->keep(); files.push_back(F); pass_manager.add(new smack::SmackModuleGenerator()); pass_manager.add(new smack::BplFilePrinter(F->os())); } pass_manager.run(*module.get()); for (auto F : files) delete F; return 0; }