1 //===- OptimizerDriver.cpp - Allow BugPoint to run passes safely ----------===//
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 file defines an interface that allows bugpoint to run various passes
11 // without the threat of a buggy pass corrupting bugpoint (of course, bugpoint
12 // may have its own bugs, but that's another story...).  It achieves this by
13 // forking a copy of itself and having the child process do the optimizations.
14 // If this client dies, we can always fork a new one.  :)
15 //
16 //===----------------------------------------------------------------------===//
17 
18 // Note: as a short term hack, the old Unix-specific code and platform-
19 // independent code co-exist via conditional compilation until it is verified
20 // that the new code works correctly on Unix.
21 
22 #include "BugDriver.h"
23 #include "llvm/Module.h"
24 #include "llvm/PassManager.h"
25 #include "llvm/Analysis/Verifier.h"
26 #include "llvm/Bitcode/ReaderWriter.h"
27 #include "llvm/Target/TargetData.h"
28 #include "llvm/Support/FileUtilities.h"
29 #include "llvm/Support/CommandLine.h"
30 #include "llvm/Support/raw_ostream.h"
31 #include "llvm/System/Path.h"
32 #include "llvm/System/Program.h"
33 
34 #define DONT_GET_PLUGIN_LOADER_OPTION
35 #include "llvm/Support/PluginLoader.h"
36 
37 #include <fstream>
38 using namespace llvm;
39 
40 namespace llvm {
41   extern cl::opt<std::string> OutputPrefix;
42 }
43 
44 namespace {
45   // ChildOutput - This option captures the name of the child output file that
46   // is set up by the parent bugpoint process
47   cl::opt<std::string> ChildOutput("child-output", cl::ReallyHidden);
48   cl::opt<bool> UseValgrind("enable-valgrind",
49                             cl::desc("Run optimizations through valgrind"));
50 }
51 
52 /// writeProgramToFile - This writes the current "Program" to the named bitcode
53 /// file.  If an error occurs, true is returned.
54 ///
55 bool BugDriver::writeProgramToFile(const std::string &Filename,
56                                    Module *M) const {
57   std::string ErrInfo;
58   raw_fd_ostream Out(Filename.c_str(), ErrInfo,
59                      raw_fd_ostream::F_Binary);
60   if (!ErrInfo.empty()) return true;
61 
62   WriteBitcodeToFile(M ? M : Program, Out);
63   return false;
64 }
65 
66 
67 /// EmitProgressBitcode - This function is used to output the current Program
68 /// to a file named "bugpoint-ID.bc".
69 ///
70 void BugDriver::EmitProgressBitcode(const std::string &ID, bool NoFlyer) {
71   // Output the input to the current pass to a bitcode file, emit a message
72   // telling the user how to reproduce it: opt -foo blah.bc
73   //
74   std::string Filename = OutputPrefix + "-" + ID + ".bc";
75   if (writeProgramToFile(Filename)) {
76     errs() <<  "Error opening file '" << Filename << "' for writing!\n";
77     return;
78   }
79 
80   outs() << "Emitted bitcode to '" << Filename << "'\n";
81   if (NoFlyer || PassesToRun.empty()) return;
82   outs() << "\n*** You can reproduce the problem with: ";
83   if (UseValgrind) outs() << "valgrind ";
84   outs() << "opt " << Filename << " ";
85   outs() << getPassesString(PassesToRun) << "\n";
86 }
87 
88 int BugDriver::runPassesAsChild(const std::vector<const PassInfo*> &Passes) {
89   std::string ErrInfo;
90   raw_fd_ostream OutFile(ChildOutput.c_str(), ErrInfo,
91                          raw_fd_ostream::F_Binary);
92   if (!ErrInfo.empty()) {
93     errs() << "Error opening bitcode file: " << ChildOutput << "\n";
94     return 1;
95   }
96 
97   PassManager PM;
98   // Make sure that the appropriate target data is always used...
99   PM.add(new TargetData(Program));
100 
101   for (unsigned i = 0, e = Passes.size(); i != e; ++i) {
102     if (Passes[i]->getNormalCtor())
103       PM.add(Passes[i]->getNormalCtor()());
104     else
105       errs() << "Cannot create pass yet: " << Passes[i]->getPassName() << "\n";
106   }
107   // Check that the module is well formed on completion of optimization
108   PM.add(createVerifierPass());
109 
110   // Write bitcode out to disk as the last step...
111   PM.add(createBitcodeWriterPass(OutFile));
112 
113   // Run all queued passes.
114   PM.run(*Program);
115 
116   return 0;
117 }
118 
119 cl::opt<bool> SilencePasses("silence-passes", cl::desc("Suppress output of running passes (both stdout and stderr)"));
120 
121 /// runPasses - Run the specified passes on Program, outputting a bitcode file
122 /// and writing the filename into OutputFile if successful.  If the
123 /// optimizations fail for some reason (optimizer crashes), return true,
124 /// otherwise return false.  If DeleteOutput is set to true, the bitcode is
125 /// deleted on success, and the filename string is undefined.  This prints to
126 /// outs() a single line message indicating whether compilation was successful
127 /// or failed.
128 ///
129 bool BugDriver::runPasses(const std::vector<const PassInfo*> &Passes,
130                           std::string &OutputFilename, bool DeleteOutput,
131                           bool Quiet, unsigned NumExtraArgs,
132                           const char * const *ExtraArgs) const {
133   // setup the output file name
134   outs().flush();
135   sys::Path uniqueFilename(OutputPrefix + "-output.bc");
136   std::string ErrMsg;
137   if (uniqueFilename.makeUnique(true, &ErrMsg)) {
138     errs() << getToolName() << ": Error making unique filename: "
139            << ErrMsg << "\n";
140     return(1);
141   }
142   OutputFilename = uniqueFilename.str();
143 
144   // set up the input file name
145   sys::Path inputFilename(OutputPrefix + "-input.bc");
146   if (inputFilename.makeUnique(true, &ErrMsg)) {
147     errs() << getToolName() << ": Error making unique filename: "
148            << ErrMsg << "\n";
149     return(1);
150   }
151 
152   std::string ErrInfo;
153   raw_fd_ostream InFile(inputFilename.c_str(), ErrInfo,
154                         raw_fd_ostream::F_Binary);
155 
156 
157   if (!ErrInfo.empty()) {
158     errs() << "Error opening bitcode file: " << inputFilename.str() << "\n";
159     return 1;
160   }
161   WriteBitcodeToFile(Program, InFile);
162   InFile.close();
163 
164   // setup the child process' arguments
165   SmallVector<const char*, 8> Args;
166   sys::Path tool = sys::Program::FindProgramByName(ToolName);
167   if (UseValgrind) {
168     Args.push_back("valgrind");
169     Args.push_back("--error-exitcode=1");
170     Args.push_back("-q");
171     Args.push_back(tool.c_str());
172   } else
173     Args.push_back(ToolName);
174 
175   Args.push_back("-as-child");
176   Args.push_back("-child-output");
177   Args.push_back(OutputFilename.c_str());
178   std::vector<std::string> pass_args;
179   for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) {
180     pass_args.push_back( std::string("-load"));
181     pass_args.push_back( PluginLoader::getPlugin(i));
182   }
183   for (std::vector<const PassInfo*>::const_iterator I = Passes.begin(),
184        E = Passes.end(); I != E; ++I )
185     pass_args.push_back( std::string("-") + (*I)->getPassArgument() );
186   for (std::vector<std::string>::const_iterator I = pass_args.begin(),
187        E = pass_args.end(); I != E; ++I )
188     Args.push_back(I->c_str());
189   Args.push_back(inputFilename.c_str());
190   for (unsigned i = 0; i < NumExtraArgs; ++i)
191     Args.push_back(*ExtraArgs);
192   Args.push_back(0);
193 
194   sys::Path prog;
195   if (UseValgrind)
196     prog = sys::Program::FindProgramByName("valgrind");
197   else
198     prog = tool;
199 
200   // Redirect stdout and stderr to nowhere if SilencePasses is given
201   sys::Path Nowhere;
202   const sys::Path *Redirects[3] = {0, &Nowhere, &Nowhere};
203 
204   int result = sys::Program::ExecuteAndWait(prog, Args.data(), 0,
205                                             (SilencePasses ? Redirects : 0),
206                                             Timeout, MemoryLimit, &ErrMsg);
207 
208   // If we are supposed to delete the bitcode file or if the passes crashed,
209   // remove it now.  This may fail if the file was never created, but that's ok.
210   if (DeleteOutput || result != 0)
211     sys::Path(OutputFilename).eraseFromDisk();
212 
213   // Remove the temporary input file as well
214   inputFilename.eraseFromDisk();
215 
216   if (!Quiet) {
217     if (result == 0)
218       outs() << "Success!\n";
219     else if (result > 0)
220       outs() << "Exited with error code '" << result << "'\n";
221     else if (result < 0) {
222       if (result == -1)
223         outs() << "Execute failed: " << ErrMsg << "\n";
224       else
225         outs() << "Crashed with signal #" << abs(result) << "\n";
226     }
227     if (result & 0x01000000)
228       outs() << "Dumped core\n";
229   }
230 
231   // Was the child successful?
232   return result != 0;
233 }
234 
235 
236 /// runPassesOn - Carefully run the specified set of pass on the specified
237 /// module, returning the transformed module on success, or a null pointer on
238 /// failure.
239 Module *BugDriver::runPassesOn(Module *M,
240                                const std::vector<const PassInfo*> &Passes,
241                                bool AutoDebugCrashes, unsigned NumExtraArgs,
242                                const char * const *ExtraArgs) {
243   Module *OldProgram = swapProgramIn(M);
244   std::string BitcodeResult;
245   if (runPasses(Passes, BitcodeResult, false/*delete*/, true/*quiet*/,
246                 NumExtraArgs, ExtraArgs)) {
247     if (AutoDebugCrashes) {
248       errs() << " Error running this sequence of passes"
249              << " on the input program!\n";
250       delete OldProgram;
251       EmitProgressBitcode("pass-error",  false);
252       exit(debugOptimizerCrash());
253     }
254     swapProgramIn(OldProgram);
255     return 0;
256   }
257 
258   // Restore the current program.
259   swapProgramIn(OldProgram);
260 
261   Module *Ret = ParseInputFile(BitcodeResult, Context);
262   if (Ret == 0) {
263     errs() << getToolName() << ": Error reading bitcode file '"
264            << BitcodeResult << "'!\n";
265     exit(1);
266   }
267   sys::Path(BitcodeResult).eraseFromDisk();  // No longer need the file on disk
268   return Ret;
269 }
270