X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fbugpoint%2Fbugpoint.cpp;h=48f30e6709f8089002fddcea620b8c7d34a1041d;hb=2507c58ca21ee01c359cd5ddf2fe84eea16366ee;hp=9bf3a004be47ba17f99d03a675099f3e365d87b9;hpb=4a1de8b25044a6bd8ca2d113d1a6eb907d222e4c;p=oota-llvm.git diff --git a/tools/bugpoint/bugpoint.cpp b/tools/bugpoint/bugpoint.cpp index 9bf3a004be4..48f30e6709f 100644 --- a/tools/bugpoint/bugpoint.cpp +++ b/tools/bugpoint/bugpoint.cpp @@ -1,10 +1,10 @@ //===- bugpoint.cpp - The LLVM Bugpoint utility ---------------------------===// -// +// // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. -// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// // // This program is an automated compiler debugger tool. It is used to narrow @@ -14,54 +14,190 @@ //===----------------------------------------------------------------------===// #include "BugDriver.h" -#include "llvm/Support/PassNameParser.h" -#include "llvm/Support/ToolRunner.h" -#include "Support/CommandLine.h" -#include "llvm/System/Signals.h" -#include "Support/PluginLoader.h" -#include "Config/unistd.h" -#include +#include "ToolRunner.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/IR/LegacyPassManager.h" +#include "llvm/IR/LegacyPassNameParser.h" +#include "llvm/LinkAllIR.h" +#include "llvm/LinkAllPasses.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/PluginLoader.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Process.h" +#include "llvm/Support/Signals.h" +#include "llvm/Support/Valgrind.h" +#include "llvm/Transforms/IPO/PassManagerBuilder.h" + +//Enable this macro to debug bugpoint itself. +//#define DEBUG_BUGPOINT 1 + using namespace llvm; +static cl::opt +FindBugs("find-bugs", cl::desc("Run many different optimization sequences " + "on program to find bugs"), cl::init(false)); + static cl::list InputFilenames(cl::Positional, cl::OneOrMore, cl::desc("")); +static cl::opt +TimeoutValue("timeout", cl::init(300), cl::value_desc("seconds"), + cl::desc("Number of seconds program is allowed to run before it " + "is killed (default is 300s), 0 disables timeout")); + +static cl::opt +MemoryLimit("mlimit", cl::init(-1), cl::value_desc("MBytes"), + cl::desc("Maximum amount of memory to use. 0 disables check." + " Defaults to 400MB (800MB under valgrind).")); + +static cl::opt +UseValgrind("enable-valgrind", + cl::desc("Run optimizations through valgrind")); + // The AnalysesList is automatically populated with registered Passes by the // PassNameParser. // static cl::list PassList(cl::desc("Passes available:"), cl::ZeroOrMore); +static cl::opt +StandardLinkOpts("std-link-opts", + cl::desc("Include the standard link time optimizations")); + +static cl::opt +OptLevelO1("O1", + cl::desc("Optimization level 1. Identical to 'opt -O1'")); + +static cl::opt +OptLevelO2("O2", + cl::desc("Optimization level 2. Identical to 'opt -O2'")); + +static cl::opt +OptLevelO3("O3", + cl::desc("Optimization level 3. Identical to 'opt -O3'")); + +static cl::opt +OverrideTriple("mtriple", cl::desc("Override target triple for module")); + +/// BugpointIsInterrupted - Set to true when the user presses ctrl-c. +bool llvm::BugpointIsInterrupted = false; + +#ifndef DEBUG_BUGPOINT +static void BugpointInterruptFunction() { + BugpointIsInterrupted = true; +} +#endif + +// Hack to capture a pass list. +namespace { + class AddToDriver : public legacy::FunctionPassManager { + BugDriver &D; + public: + AddToDriver(BugDriver &_D) : FunctionPassManager(nullptr), D(_D) {} + + void add(Pass *P) override { + const void *ID = P->getPassID(); + const PassInfo *PI = PassRegistry::getPassRegistry()->getPassInfo(ID); + D.addPass(PI->getPassArgument()); + } + }; +} + +#ifdef LINK_POLLY_INTO_TOOLS +namespace polly { +void initializePollyPasses(llvm::PassRegistry &Registry); +} +#endif + 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); + 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.cs.uiuc.edu/docs/CommandGuide/bugpoint.html" + "LLVM automatic testcase reducer. See\nhttp://" + "llvm.org/cmds/bugpoint.html" " for more information.\n"); - PrintStackTraceOnErrorSignal(); +#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]); + BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit, + UseValgrind, Context); if (D.addSources(InputFilenames)) return 1; - D.addPasses(PassList.begin(), PassList.end()); - // Bugpoint has the ability of generating a plethora of core files, so to - // avoid filling up the disk, set the max core file size to 0. - struct rlimit rlim; - rlim.rlim_cur = rlim.rlim_max = 0; - int res = setrlimit(RLIMIT_CORE, &rlim); - if (res < 0) { - // setrlimit() may have failed, but we're not going to let that stop us - perror("setrlimit: RLIMIT_CORE"); + AddToDriver PM(D); + + if (StandardLinkOpts) { + PassManagerBuilder Builder; + Builder.Inliner = createFunctionInliningPass(); + Builder.populateLTOPassManager(PM); } - try { - return D.run(); - } catch (ToolExecutionError &TEE) { - std::cerr << "Tool execution error: " << TEE.what() << "\n"; - return 1; - } catch (...) { - std::cerr << "Whoops, an exception leaked out of bugpoint. " - << "This is a bug in bugpoint!\n"; + if (OptLevelO1 || OptLevelO2 || OptLevelO3) { + PassManagerBuilder Builder; + if (OptLevelO1) + Builder.Inliner = createAlwaysInlinerPass(); + else if (OptLevelO2) + Builder.Inliner = createFunctionInliningPass(225); + 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 + + std::string Error; + bool Failure = D.run(Error); + if (!Error.empty()) { + errs() << Error; return 1; } + return Failure; }