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