X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fbugpoint%2FBugDriver.h;h=eff11ec0de476974c25296f97d04cfd0c39b4bd3;hb=bebd86d58eea8839691785a08917040751334083;hp=f88d29ffb7730139da2882262dde4c34de628433;hpb=ba386d943f4a83095d9c625cb0d46c1afe45ed1f;p=oota-llvm.git diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h index f88d29ffb77..eff11ec0de4 100644 --- a/tools/bugpoint/BugDriver.h +++ b/tools/bugpoint/BugDriver.h @@ -11,20 +11,43 @@ #include #include + class PassInfo; class Module; class Function; class AbstractInterpreter; class Instruction; +class DebugCrashes; +class ReduceMiscompilingPasses; +class ReduceMiscompilingFunctions; +class ReduceCrashingFunctions; +class ReduceCrashingBlocks; + +class CBE; +class GCC; + +extern bool DisableSimplifyCFG; + class BugDriver { const std::string ToolName; // Name of bugpoint + std::string ReferenceOutputFile; // Name of `good' output file Module *Program; // The raw program, linked together std::vector PassesToRun; AbstractInterpreter *Interpreter; // How to run the program + CBE *cbe; + GCC *gcc; + + // FIXME: sort out public/private distinctions... + friend class DebugCrashes; + friend class ReduceMiscompilingPasses; + friend class ReduceMiscompilingFunctions; + friend class ReduceMisCodegenFunctions; + friend class ReduceCrashingFunctions; + friend class ReduceCrashingBlocks; + public: - BugDriver(const char *toolname) - : ToolName(toolname), Program(0), Interpreter(0) {} + BugDriver(const char *toolname); const std::string &getToolName() const { return ToolName; } @@ -46,12 +69,6 @@ public: /// bool debugCrash(); - /// debugPassCrash - This method is called when the specified pass crashes on - /// Program as input. It tries to reduce the testcase to something that still - /// crashes, but it smaller. - /// - bool debugPassCrash(const PassInfo *PI); - /// debugMiscompilation - This method is used when the passes selected are not /// crashing, but the generated output is semantically different from the /// input. @@ -66,6 +83,20 @@ public: bool debugPassMiscompilation(const PassInfo *ThePass, const std::string &ReferenceOutput); + /// compileSharedObject - This method creates a SharedObject from a given + /// BytecodeFile for debugging a code generator. + int compileSharedObject(const std::string &BytecodeFile, + std::string &SharedObject); + + /// debugCodeGenerator - This method narrows down a module to a function or + /// set of functions, using the CBE as a ``safe'' code generator for other + /// functions that are not under consideration. + bool debugCodeGenerator(); + + /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT + /// + bool isExecutingJIT(); + private: /// ParseInputFile - Given a bytecode or assembly input filename, parse and /// return it, or return null if not possible. @@ -81,7 +112,7 @@ private: /// EmitProgressBytecode - This function is used to output the current Program /// to a file named "bugpoing-ID.bc". /// - void EmitProgressBytecode(const PassInfo *Pass, const std::string &ID); + void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false); /// runPasses - Run the specified passes on Program, outputting a bytecode /// file and writting the filename into OutputFile if successful. If the @@ -105,18 +136,9 @@ private: return runPasses(PassesToRun, Filename, DeleteOutput); } - /// runPass - Run only the specified pass on the program. - /// - bool runPass(const PassInfo *P, bool DeleteOutput = true) const { - return runPasses(std::vector(1, P), DeleteOutput); - } - - /// extractFunctionFromModule - This method is used to extract the specified - /// (non-external) function from the current program, slim down the module, - /// and then return it. This does not modify Program at all, it modifies a - /// copy, which it returns. + /// PrintFunctionList - prints out list of problematic functions /// - Module *extractFunctionFromModule(Function *F) const; + static void PrintFunctionList(const std::vector &Funcs); /// deleteInstructionFromProgram - This method clones the current Program and /// deletes the specified instruction from the cloned module. It then runs a @@ -127,9 +149,10 @@ private: /// performFinalCleanups - This method clones the current Program and performs /// a series of cleanups intended to get rid of extra cruft on the module - /// before handing it to the user... + /// before handing it to the user... if the module parameter is specified, it + /// operates directly on the specified Module, modifying it in place. /// - Module *performFinalCleanups() const; + Module *performFinalCleanups(Module *M = 0) const; /// initializeExecutionEnvironment - This method is used to set up the /// environment for executing LLVM programs. @@ -141,14 +164,33 @@ private: /// filename may be optionally specified. /// std::string executeProgram(std::string RequestedOutputFilename = "", - std::string Bytecode = ""); + std::string Bytecode = "", + std::string SharedObject = "", + AbstractInterpreter *AI = 0); + + /// executeProgramWithCBE - Used to create reference output with the C + /// backend, if reference output is not provided. + std::string executeProgramWithCBE(std::string RequestedOutputFilename = "", + std::string Bytecode = "", + std::string SharedObject = ""); /// diffProgram - This method executes the specified module and diffs the /// output against the file specified by ReferenceOutputFile. If the output /// is different, true is returned. /// - bool diffProgram(const std::string &ReferenceOutputFile, - const std::string &BytecodeFile = ""); + bool diffProgram(const std::string &BytecodeFile = "", + const std::string &SharedObject = "", + bool RemoveBytecode = false); }; +/// getPassesString - Turn a list of passes into a string which indicates the +/// command line options that must be passed to add the passes. +/// +std::string getPassesString(const std::vector &Passes); + +// DeleteFunctionBody - "Remove" the function by deleting all of it's basic +// blocks, making it external. +// +void DeleteFunctionBody(Function *F); + #endif