Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 1 | //===- BugDriver.h - Top-Level BugPoint class -------------------*- C++ -*-===// |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 7c0e022 | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file was developed by the LLVM research group and is distributed under |
| 6 | // the University of Illinois Open Source License. See LICENSE.TXT for details. |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 7c0e022 | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 9 | // |
| 10 | // This class contains all of the shared state and information that is used by |
| 11 | // the BugPoint tool to track down errors in optimizations. This class is the |
| 12 | // main driver class that invokes all sub-functionality. |
| 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
| 16 | #ifndef BUGDRIVER_H |
| 17 | #define BUGDRIVER_H |
| 18 | |
| 19 | #include <vector> |
| 20 | #include <string> |
Misha Brukman | 5073336 | 2003-07-24 18:17:43 +0000 | [diff] [blame] | 21 | |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 22 | namespace llvm { |
| 23 | |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 24 | class PassInfo; |
| 25 | class Module; |
Bill Wendling | 4e3be89 | 2006-10-25 18:36:14 +0000 | [diff] [blame] | 26 | class GlobalVariable; |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 27 | class Function; |
Chris Lattner | 5e783ab | 2004-05-11 21:54:13 +0000 | [diff] [blame] | 28 | class BasicBlock; |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 29 | class AbstractInterpreter; |
Chris Lattner | 6520785 | 2003-01-23 02:48:33 +0000 | [diff] [blame] | 30 | class Instruction; |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 31 | |
Chris Lattner | aae33f9 | 2003-04-24 22:24:58 +0000 | [diff] [blame] | 32 | class DebugCrashes; |
Chris Lattner | 640f22e | 2003-04-24 17:02:17 +0000 | [diff] [blame] | 33 | |
Misha Brukman | a259c9b | 2003-07-24 21:59:10 +0000 | [diff] [blame] | 34 | class GCC; |
| 35 | |
Chris Lattner | 47ae4a1 | 2003-08-05 15:51:05 +0000 | [diff] [blame] | 36 | extern bool DisableSimplifyCFG; |
| 37 | |
Chris Lattner | f9aaae0 | 2005-08-02 02:16:17 +0000 | [diff] [blame] | 38 | /// BugpointIsInterrupted - Set to true when the user presses ctrl-c. |
| 39 | /// |
| 40 | extern bool BugpointIsInterrupted; |
| 41 | |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 42 | class BugDriver { |
| 43 | const std::string ToolName; // Name of bugpoint |
Misha Brukman | a259c9b | 2003-07-24 21:59:10 +0000 | [diff] [blame] | 44 | std::string ReferenceOutputFile; // Name of `good' output file |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 45 | Module *Program; // The raw program, linked together |
| 46 | std::vector<const PassInfo*> PassesToRun; |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 47 | AbstractInterpreter *Interpreter; // How to run the program |
Chris Lattner | c600f3c | 2006-09-15 21:29:15 +0000 | [diff] [blame] | 48 | AbstractInterpreter *cbe; |
Misha Brukman | a259c9b | 2003-07-24 21:59:10 +0000 | [diff] [blame] | 49 | GCC *gcc; |
Reid Spencer | c4bb052 | 2005-12-22 20:02:55 +0000 | [diff] [blame] | 50 | bool run_as_child; |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 51 | bool run_find_bugs; |
Chris Lattner | 9686ae7 | 2006-06-13 03:10:48 +0000 | [diff] [blame] | 52 | unsigned Timeout; |
Anton Korobeynikov | 9ba8a76 | 2007-02-16 19:11:07 +0000 | [diff] [blame] | 53 | unsigned MemoryLimit; |
Chris Lattner | 640f22e | 2003-04-24 17:02:17 +0000 | [diff] [blame] | 54 | |
Chris Lattner | aae33f9 | 2003-04-24 22:24:58 +0000 | [diff] [blame] | 55 | // FIXME: sort out public/private distinctions... |
Chris Lattner | 06905db | 2004-02-18 21:24:48 +0000 | [diff] [blame] | 56 | friend class ReducePassList; |
Misha Brukman | 5073336 | 2003-07-24 18:17:43 +0000 | [diff] [blame] | 57 | friend class ReduceMisCodegenFunctions; |
Misha Brukman | 5073336 | 2003-07-24 18:17:43 +0000 | [diff] [blame] | 58 | |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 59 | public: |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 60 | BugDriver(const char *toolname, bool as_child, bool find_bugs, |
Anton Korobeynikov | 9ba8a76 | 2007-02-16 19:11:07 +0000 | [diff] [blame] | 61 | unsigned timeout, unsigned memlimit); |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 62 | |
| 63 | const std::string &getToolName() const { return ToolName; } |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 64 | |
| 65 | // Set up methods... these methods are used to copy information about the |
| 66 | // command line arguments into instance variables of BugDriver. |
| 67 | // |
| 68 | bool addSources(const std::vector<std::string> &FileNames); |
| 69 | template<class It> |
| 70 | void addPasses(It I, It E) { PassesToRun.insert(PassesToRun.end(), I, E); } |
Chris Lattner | 9c6cfe1 | 2003-10-17 23:03:16 +0000 | [diff] [blame] | 71 | void setPassesToRun(const std::vector<const PassInfo*> &PTR) { |
| 72 | PassesToRun = PTR; |
| 73 | } |
Chris Lattner | efdc0b5 | 2004-03-14 20:50:42 +0000 | [diff] [blame] | 74 | const std::vector<const PassInfo*> &getPassesToRun() const { |
| 75 | return PassesToRun; |
| 76 | } |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 77 | |
| 78 | /// run - The top level method that is invoked after all of the instance |
Reid Spencer | c4bb052 | 2005-12-22 20:02:55 +0000 | [diff] [blame] | 79 | /// variables are set up from command line arguments. The \p as_child argument |
| 80 | /// indicates whether the driver is to run in parent mode or child mode. |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 81 | /// |
| 82 | bool run(); |
| 83 | |
Chris Lattner | 0252626 | 2004-02-18 21:02:04 +0000 | [diff] [blame] | 84 | /// debugOptimizerCrash - This method is called when some optimizer pass |
| 85 | /// crashes on input. It attempts to prune down the testcase to something |
| 86 | /// reasonable, and figure out exactly which pass is crashing. |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 87 | /// |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 88 | bool debugOptimizerCrash(const std::string &ID = "passes"); |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 89 | |
Chris Lattner | 0252626 | 2004-02-18 21:02:04 +0000 | [diff] [blame] | 90 | /// debugCodeGeneratorCrash - This method is called when the code generator |
| 91 | /// crashes on an input. It attempts to reduce the input as much as possible |
| 92 | /// while still causing the code generator to crash. |
| 93 | bool debugCodeGeneratorCrash(); |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 94 | |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 95 | /// debugMiscompilation - This method is used when the passes selected are not |
| 96 | /// crashing, but the generated output is semantically different from the |
| 97 | /// input. |
| 98 | bool debugMiscompilation(); |
| 99 | |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 100 | /// debugPassMiscompilation - This method is called when the specified pass |
| 101 | /// miscompiles Program as input. It tries to reduce the testcase to |
| 102 | /// something that smaller that still miscompiles the program. |
| 103 | /// ReferenceOutput contains the filename of the file containing the output we |
| 104 | /// are to match. |
| 105 | /// |
| 106 | bool debugPassMiscompilation(const PassInfo *ThePass, |
Jeff Cohen | ea3e5e5 | 2005-04-22 04:13:13 +0000 | [diff] [blame] | 107 | const std::string &ReferenceOutput); |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 108 | |
Misha Brukman | 5073336 | 2003-07-24 18:17:43 +0000 | [diff] [blame] | 109 | /// compileSharedObject - This method creates a SharedObject from a given |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 110 | /// BitcodeFile for debugging a code generator. |
Chris Lattner | a0f5b15 | 2003-10-14 21:09:11 +0000 | [diff] [blame] | 111 | /// |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 112 | std::string compileSharedObject(const std::string &BitcodeFile); |
Misha Brukman | 5073336 | 2003-07-24 18:17:43 +0000 | [diff] [blame] | 113 | |
| 114 | /// debugCodeGenerator - This method narrows down a module to a function or |
| 115 | /// set of functions, using the CBE as a ``safe'' code generator for other |
| 116 | /// functions that are not under consideration. |
| 117 | bool debugCodeGenerator(); |
| 118 | |
Misha Brukman | fe04db8 | 2003-07-28 20:59:16 +0000 | [diff] [blame] | 119 | /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT |
| 120 | /// |
Misha Brukman | 91eabc1 | 2003-07-28 19:16:14 +0000 | [diff] [blame] | 121 | bool isExecutingJIT(); |
| 122 | |
Chris Lattner | 06905db | 2004-02-18 21:24:48 +0000 | [diff] [blame] | 123 | /// runPasses - Run all of the passes in the "PassesToRun" list, discard the |
| 124 | /// output, and return true if any of the passes crashed. |
| 125 | bool runPasses(Module *M = 0) { |
| 126 | if (M == 0) M = Program; |
| 127 | std::swap(M, Program); |
| 128 | bool Result = runPasses(PassesToRun); |
| 129 | std::swap(M, Program); |
| 130 | return Result; |
| 131 | } |
| 132 | |
Chris Lattner | efdc0b5 | 2004-03-14 20:50:42 +0000 | [diff] [blame] | 133 | Module *getProgram() const { return Program; } |
| 134 | |
| 135 | /// swapProgramIn - Set the current module to the specified module, returning |
| 136 | /// the old one. |
| 137 | Module *swapProgramIn(Module *M) { |
| 138 | Module *OldProgram = Program; |
| 139 | Program = M; |
| 140 | return OldProgram; |
| 141 | } |
Chris Lattner | 06905db | 2004-02-18 21:24:48 +0000 | [diff] [blame] | 142 | |
Chris Lattner | a57d86b | 2004-04-05 22:58:16 +0000 | [diff] [blame] | 143 | AbstractInterpreter *switchToCBE() { |
| 144 | AbstractInterpreter *Old = Interpreter; |
| 145 | Interpreter = (AbstractInterpreter*)cbe; |
| 146 | return Old; |
| 147 | } |
| 148 | |
| 149 | void switchToInterpreter(AbstractInterpreter *AI) { |
| 150 | Interpreter = AI; |
| 151 | } |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 152 | |
Chris Lattner | 06905db | 2004-02-18 21:24:48 +0000 | [diff] [blame] | 153 | /// setNewProgram - If we reduce or update the program somehow, call this |
| 154 | /// method to update bugdriver with it. This deletes the old module and sets |
| 155 | /// the specified one as the current program. |
| 156 | void setNewProgram(Module *M); |
| 157 | |
Chris Lattner | ea9212c | 2004-02-18 23:25:22 +0000 | [diff] [blame] | 158 | /// compileProgram - Try to compile the specified module, throwing an |
| 159 | /// exception if an error occurs, or returning normally if not. This is used |
| 160 | /// for code generation crash testing. |
| 161 | /// |
| 162 | void compileProgram(Module *M); |
| 163 | |
Chris Lattner | a36ec88 | 2004-02-18 21:35:28 +0000 | [diff] [blame] | 164 | /// executeProgram - This method runs "Program", capturing the output of the |
| 165 | /// program to a file, returning the filename of the file. A recommended |
| 166 | /// filename may be optionally specified. If there is a problem with the code |
| 167 | /// generator (e.g., llc crashes), this will throw an exception. |
| 168 | /// |
| 169 | std::string executeProgram(std::string RequestedOutputFilename = "", |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 170 | std::string Bitcode = "", |
Chris Lattner | a36ec88 | 2004-02-18 21:35:28 +0000 | [diff] [blame] | 171 | const std::string &SharedObjects = "", |
| 172 | AbstractInterpreter *AI = 0, |
| 173 | bool *ProgramExitedNonzero = 0); |
| 174 | |
| 175 | /// executeProgramWithCBE - Used to create reference output with the C |
| 176 | /// backend, if reference output is not provided. If there is a problem with |
| 177 | /// the code generator (e.g., llc crashes), this will throw an exception. |
| 178 | /// |
| 179 | std::string executeProgramWithCBE(std::string OutputFile = ""); |
| 180 | |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 181 | /// createReferenceFile - calls compileProgram and then records the output |
| 182 | /// into ReferenceOutputFile. Returns true if reference file created, false |
| 183 | /// otherwise. Note: initializeExecutionEnvironment should be called BEFORE |
| 184 | /// this function. |
| 185 | /// |
Chris Lattner | c0431fe | 2006-08-17 18:51:28 +0000 | [diff] [blame] | 186 | bool createReferenceFile(Module *M, const std::string &Filename |
| 187 | = "bugpoint.reference.out"); |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 188 | |
Chris Lattner | a36ec88 | 2004-02-18 21:35:28 +0000 | [diff] [blame] | 189 | /// diffProgram - This method executes the specified module and diffs the |
| 190 | /// output against the file specified by ReferenceOutputFile. If the output |
| 191 | /// is different, true is returned. If there is a problem with the code |
| 192 | /// generator (e.g., llc crashes), this will throw an exception. |
| 193 | /// |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 194 | bool diffProgram(const std::string &BitcodeFile = "", |
Chris Lattner | a36ec88 | 2004-02-18 21:35:28 +0000 | [diff] [blame] | 195 | const std::string &SharedObj = "", |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 196 | bool RemoveBitcode = false); |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 197 | |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 198 | /// EmitProgressBitcode - This function is used to output the current Program |
Chris Lattner | 0cc8807 | 2004-02-18 21:50:26 +0000 | [diff] [blame] | 199 | /// to a file named "bugpoint-ID.bc". |
| 200 | /// |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 201 | void EmitProgressBitcode(const std::string &ID, bool NoFlyer = false); |
Chris Lattner | 0cc8807 | 2004-02-18 21:50:26 +0000 | [diff] [blame] | 202 | |
| 203 | /// deleteInstructionFromProgram - This method clones the current Program and |
| 204 | /// deletes the specified instruction from the cloned module. It then runs a |
| 205 | /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code |
| 206 | /// which depends on the value. The modified module is then returned. |
| 207 | /// |
| 208 | Module *deleteInstructionFromProgram(const Instruction *I, unsigned Simp) |
| 209 | const; |
| 210 | |
| 211 | /// performFinalCleanups - This method clones the current Program and performs |
| 212 | /// a series of cleanups intended to get rid of extra cruft on the module. If |
| 213 | /// the MayModifySemantics argument is true, then the cleanups is allowed to |
| 214 | /// modify how the code behaves. |
| 215 | /// |
| 216 | Module *performFinalCleanups(Module *M, bool MayModifySemantics = false); |
| 217 | |
Chris Lattner | 7546c38 | 2004-03-14 20:02:07 +0000 | [diff] [blame] | 218 | /// ExtractLoop - Given a module, extract up to one loop from it into a new |
| 219 | /// function. This returns null if there are no extractable loops in the |
| 220 | /// program or if the loop extractor crashes. |
| 221 | Module *ExtractLoop(Module *M); |
| 222 | |
Chris Lattner | 5e783ab | 2004-05-11 21:54:13 +0000 | [diff] [blame] | 223 | /// ExtractMappedBlocksFromModule - Extract all but the specified basic blocks |
| 224 | /// into their own functions. The only detail is that M is actually a module |
| 225 | /// cloned from the one the BBs are in, so some mapping needs to be performed. |
| 226 | /// If this operation fails for some reason (ie the implementation is buggy), |
| 227 | /// this function should return null, otherwise it returns a new Module. |
| 228 | Module *ExtractMappedBlocksFromModule(const std::vector<BasicBlock*> &BBs, |
| 229 | Module *M); |
| 230 | |
Chris Lattner | 3b6441e | 2004-03-14 21:17:03 +0000 | [diff] [blame] | 231 | /// runPassesOn - Carefully run the specified set of pass on the specified |
| 232 | /// module, returning the transformed module on success, or a null pointer on |
Chris Lattner | 0a00256 | 2004-03-14 21:21:57 +0000 | [diff] [blame] | 233 | /// failure. If AutoDebugCrashes is set to true, then bugpoint will |
| 234 | /// automatically attempt to track down a crashing pass if one exists, and |
| 235 | /// this method will never return null. |
| 236 | Module *runPassesOn(Module *M, const std::vector<const PassInfo*> &Passes, |
Nick Lewycky | 6fa98b1 | 2007-11-14 06:47:06 +0000 | [diff] [blame^] | 237 | bool AutoDebugCrashes = false, unsigned NumExtraArgs = 0, |
| 238 | const char * const *ExtraArgs = NULL); |
Chris Lattner | 3b6441e | 2004-03-14 21:17:03 +0000 | [diff] [blame] | 239 | |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 240 | /// runPasses - Run the specified passes on Program, outputting a bitcode |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 241 | /// file and writting the filename into OutputFile if successful. If the |
| 242 | /// optimizations fail for some reason (optimizer crashes), return true, |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 243 | /// otherwise return false. If DeleteOutput is set to true, the bitcode is |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 244 | /// deleted on success, and the filename string is undefined. This prints to |
| 245 | /// cout a single line message indicating whether compilation was successful |
Nick Lewycky | 6fa98b1 | 2007-11-14 06:47:06 +0000 | [diff] [blame^] | 246 | /// or failed, unless Quiet is set. ExtraArgs specifies additional arguments |
| 247 | /// to pass to the child bugpoint instance. |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 248 | /// |
| 249 | bool runPasses(const std::vector<const PassInfo*> &PassesToRun, |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 250 | std::string &OutputFilename, bool DeleteOutput = false, |
Nick Lewycky | 6fa98b1 | 2007-11-14 06:47:06 +0000 | [diff] [blame^] | 251 | bool Quiet = false, unsigned NumExtraArgs = 0, |
| 252 | const char * const *ExtraArgs = NULL) const; |
Patrick Jenkins | 6a3f31c | 2006-08-15 16:40:49 +0000 | [diff] [blame] | 253 | |
| 254 | /// runManyPasses - Take the specified pass list and create different |
| 255 | /// combinations of passes to compile the program with. Compile the program with |
| 256 | /// each set and mark test to see if it compiled correctly. If the passes |
| 257 | /// compiled correctly output nothing and rearrange the passes into a new order. |
| 258 | /// If the passes did not compile correctly, output the command required to |
| 259 | /// recreate the failure. This returns true if a compiler error is found. |
| 260 | /// |
| 261 | bool runManyPasses(const std::vector<const PassInfo*> &AllPasses); |
Chris Lattner | 11b8cd1 | 2004-04-05 22:01:48 +0000 | [diff] [blame] | 262 | |
Chris Lattner | efdc0b5 | 2004-03-14 20:50:42 +0000 | [diff] [blame] | 263 | /// writeProgramToFile - This writes the current "Program" to the named |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 264 | /// bitcode file. If an error occurs, true is returned. |
Chris Lattner | efdc0b5 | 2004-03-14 20:50:42 +0000 | [diff] [blame] | 265 | /// |
| 266 | bool writeProgramToFile(const std::string &Filename, Module *M = 0) const; |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 267 | |
Chris Lattner | 11b8cd1 | 2004-04-05 22:01:48 +0000 | [diff] [blame] | 268 | private: |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 269 | /// runPasses - Just like the method above, but this just returns true or |
| 270 | /// false indicating whether or not the optimizer crashed on the specified |
| 271 | /// input (true = crashed). |
| 272 | /// |
| 273 | bool runPasses(const std::vector<const PassInfo*> &PassesToRun, |
| 274 | bool DeleteOutput = true) const { |
| 275 | std::string Filename; |
| 276 | return runPasses(PassesToRun, Filename, DeleteOutput); |
| 277 | } |
| 278 | |
Reid Spencer | c4bb052 | 2005-12-22 20:02:55 +0000 | [diff] [blame] | 279 | /// runAsChild - The actual "runPasses" guts that runs in a child process. |
| 280 | int runPassesAsChild(const std::vector<const PassInfo*> &PassesToRun); |
| 281 | |
Chris Lattner | 218e26e | 2002-12-23 23:49:59 +0000 | [diff] [blame] | 282 | /// initializeExecutionEnvironment - This method is used to set up the |
| 283 | /// environment for executing LLVM programs. |
| 284 | /// |
| 285 | bool initializeExecutionEnvironment(); |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 286 | }; |
| 287 | |
Gabor Greif | 8ff70c2 | 2007-07-04 21:55:50 +0000 | [diff] [blame] | 288 | /// ParseInputFile - Given a bitcode or assembly input filename, parse and |
Chris Lattner | efdc0b5 | 2004-03-14 20:50:42 +0000 | [diff] [blame] | 289 | /// return it, or return null if not possible. |
| 290 | /// |
| 291 | Module *ParseInputFile(const std::string &InputFilename); |
| 292 | |
| 293 | |
Chris Lattner | 640f22e | 2003-04-24 17:02:17 +0000 | [diff] [blame] | 294 | /// getPassesString - Turn a list of passes into a string which indicates the |
| 295 | /// command line options that must be passed to add the passes. |
| 296 | /// |
| 297 | std::string getPassesString(const std::vector<const PassInfo*> &Passes); |
| 298 | |
Chris Lattner | efdc0b5 | 2004-03-14 20:50:42 +0000 | [diff] [blame] | 299 | /// PrintFunctionList - prints out list of problematic functions |
| 300 | /// |
| 301 | void PrintFunctionList(const std::vector<Function*> &Funcs); |
| 302 | |
Bill Wendling | 4e3be89 | 2006-10-25 18:36:14 +0000 | [diff] [blame] | 303 | /// PrintGlobalVariableList - prints out list of problematic global variables |
| 304 | /// |
| 305 | void PrintGlobalVariableList(const std::vector<GlobalVariable*> &GVs); |
| 306 | |
Chris Lattner | aae33f9 | 2003-04-24 22:24:58 +0000 | [diff] [blame] | 307 | // DeleteFunctionBody - "Remove" the function by deleting all of it's basic |
| 308 | // blocks, making it external. |
| 309 | // |
| 310 | void DeleteFunctionBody(Function *F); |
| 311 | |
Chris Lattner | be21ca5 | 2004-03-14 19:27:19 +0000 | [diff] [blame] | 312 | /// SplitFunctionsOutOfModule - Given a module and a list of functions in the |
| 313 | /// module, split the functions OUT of the specified module, and place them in |
| 314 | /// the new module. |
| 315 | Module *SplitFunctionsOutOfModule(Module *M, const std::vector<Function*> &F); |
| 316 | |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 317 | } // End llvm namespace |
| 318 | |
Chris Lattner | afade92 | 2002-11-20 22:28:10 +0000 | [diff] [blame] | 319 | #endif |