1 //===- BugDriver.h - Top-Level BugPoint class -------------------*- C++ -*-===//
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
9 // This class contains all of the shared state and information that is used by
10 // the BugPoint tool to track down errors in optimizations. This class is the
11 // main driver class that invokes all sub-functionality.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_TOOLS_BUGPOINT_BUGDRIVER_H
16 #define LLVM_TOOLS_BUGPOINT_BUGDRIVER_H
18 #include "llvm/IR/ValueMap.h"
19 #include "llvm/Support/Error.h"
20 #include "llvm/Support/FileSystem.h"
21 #include "llvm/Transforms/Utils/ValueMapper.h"
34 class AbstractInterpreter
;
42 extern bool DisableSimplifyCFG
;
44 /// BugpointIsInterrupted - Set to true when the user presses ctrl-c.
46 extern bool BugpointIsInterrupted
;
50 const char *ToolName
; // argv[0] of bugpoint
51 std::string ReferenceOutputFile
; // Name of `good' output file
52 std::unique_ptr
<Module
> Program
; // The raw program, linked together
53 std::vector
<std::string
> PassesToRun
;
54 AbstractInterpreter
*Interpreter
; // How to run the program
55 AbstractInterpreter
*SafeInterpreter
; // To generate reference output, etc.
62 // FIXME: sort out public/private distinctions...
63 friend class ReducePassList
;
64 friend class ReduceMisCodegenFunctions
;
67 BugDriver(const char *toolname
, bool find_bugs
, unsigned timeout
,
68 unsigned memlimit
, bool use_valgrind
, LLVMContext
&ctxt
);
71 const char *getToolName() const { return ToolName
; }
73 LLVMContext
&getContext() const { return Context
; }
75 // Set up methods... these methods are used to copy information about the
76 // command line arguments into instance variables of BugDriver.
78 bool addSources(const std::vector
<std::string
> &FileNames
);
79 void addPass(std::string p
) { PassesToRun
.push_back(std::move(p
)); }
80 void setPassesToRun(const std::vector
<std::string
> &PTR
) {
83 const std::vector
<std::string
> &getPassesToRun() const { return PassesToRun
; }
85 /// run - The top level method that is invoked after all of the instance
86 /// variables are set up from command line arguments. The \p as_child argument
87 /// indicates whether the driver is to run in parent mode or child mode.
91 /// debugOptimizerCrash - This method is called when some optimizer pass
92 /// crashes on input. It attempts to prune down the testcase to something
93 /// reasonable, and figure out exactly which pass is crashing.
95 Error
debugOptimizerCrash(const std::string
&ID
= "passes");
97 /// debugCodeGeneratorCrash - This method is called when the code generator
98 /// crashes on an input. It attempts to reduce the input as much as possible
99 /// while still causing the code generator to crash.
100 Error
debugCodeGeneratorCrash();
102 /// debugMiscompilation - This method is used when the passes selected are not
103 /// crashing, but the generated output is semantically different from the
105 Error
debugMiscompilation();
107 /// debugPassMiscompilation - This method is called when the specified pass
108 /// miscompiles Program as input. It tries to reduce the testcase to
109 /// something that smaller that still miscompiles the program.
110 /// ReferenceOutput contains the filename of the file containing the output we
113 bool debugPassMiscompilation(const PassInfo
*ThePass
,
114 const std::string
&ReferenceOutput
);
116 /// compileSharedObject - This method creates a SharedObject from a given
117 /// BitcodeFile for debugging a code generator.
119 Expected
<std::string
> compileSharedObject(const std::string
&BitcodeFile
);
121 /// debugCodeGenerator - This method narrows down a module to a function or
122 /// set of functions, using the CBE as a ``safe'' code generator for other
123 /// functions that are not under consideration.
124 Error
debugCodeGenerator();
126 /// isExecutingJIT - Returns true if bugpoint is currently testing the JIT
128 bool isExecutingJIT();
130 Module
&getProgram() const { return *Program
; }
132 /// Set the current module to the specified module, returning the old one.
133 std::unique_ptr
<Module
> swapProgramIn(std::unique_ptr
<Module
> M
);
135 AbstractInterpreter
*switchToSafeInterpreter() {
136 AbstractInterpreter
*Old
= Interpreter
;
137 Interpreter
= (AbstractInterpreter
*)SafeInterpreter
;
141 void switchToInterpreter(AbstractInterpreter
*AI
) { Interpreter
= AI
; }
143 /// If we reduce or update the program somehow, call this method to update
144 /// bugdriver with it. This deletes the old module and sets the specified one
145 /// as the current program.
146 void setNewProgram(std::unique_ptr
<Module
> M
);
148 /// Try to compile the specified module. This is used for code generation
150 Error
compileProgram(Module
&M
) const;
152 /// This method runs "Program", capturing the output of the program to a file.
153 /// A recommended filename may be optionally specified.
154 Expected
<std::string
> executeProgram(const Module
&Program
,
155 std::string OutputFilename
,
157 const std::string
&SharedObjects
,
158 AbstractInterpreter
*AI
) const;
160 /// Used to create reference output with the "safe" backend, if reference
161 /// output is not provided. If there is a problem with the code generator
162 /// (e.g., llc crashes), this will return false and set Error.
163 Expected
<std::string
>
164 executeProgramSafely(const Module
&Program
,
165 const std::string
&OutputFile
) const;
167 /// Calls compileProgram and then records the output into ReferenceOutputFile.
168 /// Returns true if reference file created, false otherwise. Note:
169 /// initializeExecutionEnvironment should be called BEFORE this function.
170 Error
createReferenceFile(Module
&M
, const std::string
&Filename
=
171 "bugpoint.reference.out-%%%%%%%");
173 /// This method executes the specified module and diffs the output against the
174 /// file specified by ReferenceOutputFile. If the output is different, 1 is
175 /// returned. If there is a problem with the code generator (e.g., llc
176 /// crashes), this will return -1 and set Error.
177 Expected
<bool> diffProgram(const Module
&Program
,
178 const std::string
&BitcodeFile
= "",
179 const std::string
&SharedObj
= "",
180 bool RemoveBitcode
= false) const;
182 /// This function is used to output M to a file named "bugpoint-ID.bc".
183 void EmitProgressBitcode(const Module
&M
, const std::string
&ID
,
184 bool NoFlyer
= false) const;
186 /// This method clones the current Program and deletes the specified
187 /// instruction from the cloned module. It then runs a series of cleanup
188 /// passes (ADCE and SimplifyCFG) to eliminate any code which depends on the
189 /// value. The modified module is then returned.
191 std::unique_ptr
<Module
> deleteInstructionFromProgram(const Instruction
*I
,
194 /// This method clones the current Program and performs a series of cleanups
195 /// intended to get rid of extra cruft on the module. If the
196 /// MayModifySemantics argument is true, then the cleanups is allowed to
197 /// modify how the code behaves.
199 std::unique_ptr
<Module
> performFinalCleanups(std::unique_ptr
<Module
> M
,
200 bool MayModifySemantics
= false);
202 /// Given a module, extract up to one loop from it into a new function. This
203 /// returns null if there are no extractable loops in the program or if the
204 /// loop extractor crashes.
205 std::unique_ptr
<Module
> extractLoop(Module
*M
);
207 /// Extract all but the specified basic blocks into their own functions. The
208 /// only detail is that M is actually a module cloned from the one the BBs are
209 /// in, so some mapping needs to be performed. If this operation fails for
210 /// some reason (ie the implementation is buggy), this function should return
211 /// null, otherwise it returns a new Module.
212 std::unique_ptr
<Module
>
213 extractMappedBlocksFromModule(const std::vector
<BasicBlock
*> &BBs
,
216 /// Carefully run the specified set of pass on the specified/ module,
217 /// returning the transformed module on success, or a null pointer on failure.
218 std::unique_ptr
<Module
> runPassesOn(Module
*M
,
219 const std::vector
<std::string
> &Passes
,
220 unsigned NumExtraArgs
= 0,
221 const char *const *ExtraArgs
= nullptr);
223 /// runPasses - Run the specified passes on Program, outputting a bitcode
224 /// file and writting the filename into OutputFile if successful. If the
225 /// optimizations fail for some reason (optimizer crashes), return true,
226 /// otherwise return false. If DeleteOutput is set to true, the bitcode is
227 /// deleted on success, and the filename string is undefined. This prints to
228 /// outs() a single line message indicating whether compilation was successful
229 /// or failed, unless Quiet is set. ExtraArgs specifies additional arguments
230 /// to pass to the child bugpoint instance.
232 bool runPasses(Module
&Program
, const std::vector
<std::string
> &PassesToRun
,
233 std::string
&OutputFilename
, bool DeleteOutput
= false,
234 bool Quiet
= false, unsigned NumExtraArgs
= 0,
235 const char *const *ExtraArgs
= nullptr) const;
237 /// runPasses - Just like the method above, but this just returns true or
238 /// false indicating whether or not the optimizer crashed on the specified
239 /// input (true = crashed). Does not produce any output.
241 bool runPasses(Module
&M
, const std::vector
<std::string
> &PassesToRun
) const {
242 std::string Filename
;
243 return runPasses(M
, PassesToRun
, Filename
, true);
246 /// Take the specified pass list and create different combinations of passes
247 /// to compile the program with. Compile the program with each set and mark
248 /// test to see if it compiled correctly. If the passes compiled correctly
249 /// output nothing and rearrange the passes into a new order. If the passes
250 /// did not compile correctly, output the command required to recreate the
252 Error
runManyPasses(const std::vector
<std::string
> &AllPasses
);
254 /// This writes the current "Program" to the named bitcode file. If an error
255 /// occurs, true is returned.
256 bool writeProgramToFile(const std::string
&Filename
, const Module
&M
) const;
257 bool writeProgramToFile(const std::string
&Filename
, int FD
,
258 const Module
&M
) const;
259 bool writeProgramToFile(int FD
, const Module
&M
) const;
262 /// initializeExecutionEnvironment - This method is used to set up the
263 /// environment for executing LLVM programs.
265 Error
initializeExecutionEnvironment();
269 sys::fs::TempFile
&File
;
273 /// Given a bitcode or assembly input filename, parse and return it, or return
274 /// null if not possible.
276 std::unique_ptr
<Module
> parseInputFile(StringRef InputFilename
,
279 /// getPassesString - Turn a list of passes into a string which indicates the
280 /// command line options that must be passed to add the passes.
282 std::string
getPassesString(const std::vector
<std::string
> &Passes
);
284 /// PrintFunctionList - prints out list of problematic functions
286 void PrintFunctionList(const std::vector
<Function
*> &Funcs
);
288 /// PrintGlobalVariableList - prints out list of problematic global variables
290 void PrintGlobalVariableList(const std::vector
<GlobalVariable
*> &GVs
);
292 // DeleteGlobalInitializer - "Remove" the global variable by deleting its
293 // initializer, making it external.
295 void DeleteGlobalInitializer(GlobalVariable
*GV
);
297 // DeleteFunctionBody - "Remove" the function by deleting all of it's basic
298 // blocks, making it external.
300 void DeleteFunctionBody(Function
*F
);
302 /// Given a module and a list of functions in the module, split the functions
303 /// OUT of the specified module, and place them in the new module.
304 std::unique_ptr
<Module
>
305 SplitFunctionsOutOfModule(Module
*M
, const std::vector
<Function
*> &F
,
306 ValueToValueMapTy
&VMap
);
308 } // End llvm namespace