1 //===- OptimizerDriver.cpp - Allow BugPoint to run passes safely ----------===// 2 // 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 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines an interface that allows bugpoint to run various passes 10 // without the threat of a buggy pass corrupting bugpoint (of course, bugpoint 11 // may have its own bugs, but that's another story...). It achieves this by 12 // forking a copy of itself and having the child process do the optimizations. 13 // If this client dies, we can always fork a new one. :) 14 // 15 //===----------------------------------------------------------------------===// 16 17 #include "BugDriver.h" 18 #include "ToolRunner.h" 19 #include "llvm/Bitcode/BitcodeWriter.h" 20 #include "llvm/IR/DataLayout.h" 21 #include "llvm/IR/Module.h" 22 #include "llvm/Support/CommandLine.h" 23 #include "llvm/Support/Debug.h" 24 #include "llvm/Support/FileUtilities.h" 25 #include "llvm/Support/Path.h" 26 #include "llvm/Support/Program.h" 27 #include "llvm/Support/ToolOutputFile.h" 28 29 #define DONT_GET_PLUGIN_LOADER_OPTION 30 #include "llvm/Support/PluginLoader.h" 31 32 33 using namespace llvm; 34 35 #define DEBUG_TYPE "bugpoint" 36 37 namespace llvm { 38 extern cl::opt<std::string> OutputPrefix; 39 } 40 41 static cl::opt<bool> PreserveBitcodeUseListOrder( 42 "preserve-bc-uselistorder", 43 cl::desc("Preserve use-list order when writing LLVM bitcode."), 44 cl::init(true), cl::Hidden); 45 46 static cl::opt<std::string> 47 OptCmd("opt-command", cl::init(""), 48 cl::desc("Path to opt. (default: search path " 49 "for 'opt'.)")); 50 51 /// This writes the current "Program" to the named bitcode file. If an error 52 /// occurs, true is returned. 53 static bool writeProgramToFileAux(ToolOutputFile &Out, const Module &M) { 54 WriteBitcodeToFile(M, Out.os(), PreserveBitcodeUseListOrder); 55 Out.os().close(); 56 if (!Out.os().has_error()) { 57 Out.keep(); 58 return false; 59 } 60 return true; 61 } 62 63 bool BugDriver::writeProgramToFile(const std::string &Filename, int FD, 64 const Module &M) const { 65 ToolOutputFile Out(Filename, FD); 66 return writeProgramToFileAux(Out, M); 67 } 68 69 bool BugDriver::writeProgramToFile(int FD, const Module &M) const { 70 raw_fd_ostream OS(FD, /*shouldClose*/ false); 71 WriteBitcodeToFile(M, OS, PreserveBitcodeUseListOrder); 72 OS.flush(); 73 if (!OS.has_error()) 74 return false; 75 OS.clear_error(); 76 return true; 77 } 78 79 bool BugDriver::writeProgramToFile(const std::string &Filename, 80 const Module &M) const { 81 std::error_code EC; 82 ToolOutputFile Out(Filename, EC, sys::fs::OF_None); 83 if (!EC) 84 return writeProgramToFileAux(Out, M); 85 return true; 86 } 87 88 /// This function is used to output the current Program to a file named 89 /// "bugpoint-ID.bc". 90 void BugDriver::EmitProgressBitcode(const Module &M, const std::string &ID, 91 bool NoFlyer) const { 92 // Output the input to the current pass to a bitcode file, emit a message 93 // telling the user how to reproduce it: opt -foo blah.bc 94 // 95 std::string Filename = OutputPrefix + "-" + ID + ".bc"; 96 if (writeProgramToFile(Filename, M)) { 97 errs() << "Error opening file '" << Filename << "' for writing!\n"; 98 return; 99 } 100 101 outs() << "Emitted bitcode to '" << Filename << "'\n"; 102 if (NoFlyer || PassesToRun.empty()) 103 return; 104 outs() << "\n*** You can reproduce the problem with: "; 105 if (UseValgrind) 106 outs() << "valgrind "; 107 outs() << "opt " << Filename; 108 for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) { 109 outs() << " -load " << PluginLoader::getPlugin(i); 110 } 111 outs() << " " << getPassesString(PassesToRun) << "\n"; 112 } 113 114 cl::opt<bool> SilencePasses( 115 "silence-passes", 116 cl::desc("Suppress output of running passes (both stdout and stderr)")); 117 118 static cl::list<std::string> OptArgs("opt-args", cl::Positional, 119 cl::desc("<opt arguments>..."), 120 cl::ZeroOrMore, cl::PositionalEatsArgs); 121 122 /// runPasses - Run the specified passes on Program, outputting a bitcode file 123 /// and writing the filename into OutputFile if successful. If the 124 /// optimizations fail for some reason (optimizer crashes), return true, 125 /// otherwise return false. If DeleteOutput is set to true, the bitcode is 126 /// deleted on success, and the filename string is undefined. This prints to 127 /// outs() a single line message indicating whether compilation was successful 128 /// or failed. 129 /// 130 bool BugDriver::runPasses(Module &Program, 131 const std::vector<std::string> &Passes, 132 std::string &OutputFilename, bool DeleteOutput, 133 bool Quiet, ArrayRef<std::string> ExtraArgs) const { 134 // setup the output file name 135 outs().flush(); 136 SmallString<128> UniqueFilename; 137 std::error_code EC = sys::fs::createUniqueFile( 138 OutputPrefix + "-output-%%%%%%%.bc", UniqueFilename); 139 if (EC) { 140 errs() << getToolName() 141 << ": Error making unique filename: " << EC.message() << "\n"; 142 return 1; 143 } 144 OutputFilename = UniqueFilename.str(); 145 146 // set up the input file name 147 Expected<sys::fs::TempFile> Temp = 148 sys::fs::TempFile::create(OutputPrefix + "-input-%%%%%%%.bc"); 149 if (!Temp) { 150 errs() << getToolName() 151 << ": Error making unique filename: " << toString(Temp.takeError()) 152 << "\n"; 153 return 1; 154 } 155 DiscardTemp Discard{*Temp}; 156 raw_fd_ostream OS(Temp->FD, /*shouldClose*/ false); 157 158 WriteBitcodeToFile(Program, OS, PreserveBitcodeUseListOrder); 159 OS.flush(); 160 if (OS.has_error()) { 161 errs() << "Error writing bitcode file: " << Temp->TmpName << "\n"; 162 OS.clear_error(); 163 return 1; 164 } 165 166 std::string tool = OptCmd; 167 if (OptCmd.empty()) { 168 if (ErrorOr<std::string> Path = 169 FindProgramByName("opt", getToolName(), &OutputPrefix)) 170 tool = *Path; 171 else 172 errs() << Path.getError().message() << "\n"; 173 } 174 if (tool.empty()) { 175 errs() << "Cannot find `opt' in PATH!\n"; 176 return 1; 177 } 178 if (!sys::fs::exists(tool)) { 179 errs() << "Specified `opt' binary does not exist: " << tool << "\n"; 180 return 1; 181 } 182 183 std::string Prog; 184 if (UseValgrind) { 185 if (ErrorOr<std::string> Path = sys::findProgramByName("valgrind")) 186 Prog = *Path; 187 else 188 errs() << Path.getError().message() << "\n"; 189 } else 190 Prog = tool; 191 if (Prog.empty()) { 192 errs() << "Cannot find `valgrind' in PATH!\n"; 193 return 1; 194 } 195 196 // setup the child process' arguments 197 SmallVector<StringRef, 8> Args; 198 if (UseValgrind) { 199 Args.push_back("valgrind"); 200 Args.push_back("--error-exitcode=1"); 201 Args.push_back("-q"); 202 Args.push_back(tool); 203 } else 204 Args.push_back(tool); 205 206 for (unsigned i = 0, e = OptArgs.size(); i != e; ++i) 207 Args.push_back(OptArgs[i]); 208 Args.push_back("-disable-symbolication"); 209 Args.push_back("-o"); 210 Args.push_back(OutputFilename); 211 std::vector<std::string> pass_args; 212 for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) { 213 pass_args.push_back(std::string("-load")); 214 pass_args.push_back(PluginLoader::getPlugin(i)); 215 } 216 for (std::vector<std::string>::const_iterator I = Passes.begin(), 217 E = Passes.end(); 218 I != E; ++I) 219 pass_args.push_back(std::string("-") + (*I)); 220 for (std::vector<std::string>::const_iterator I = pass_args.begin(), 221 E = pass_args.end(); 222 I != E; ++I) 223 Args.push_back(I->c_str()); 224 Args.push_back(Temp->TmpName.c_str()); 225 Args.append(ExtraArgs.begin(), ExtraArgs.end()); 226 227 LLVM_DEBUG(errs() << "\nAbout to run:\t"; 228 for (unsigned i = 0, e = Args.size() - 1; i != e; ++i) errs() 229 << " " << Args[i]; 230 errs() << "\n";); 231 232 Optional<StringRef> Redirects[3] = {None, None, None}; 233 // Redirect stdout and stderr to nowhere if SilencePasses is given. 234 if (SilencePasses) { 235 Redirects[1] = ""; 236 Redirects[2] = ""; 237 } 238 239 std::string ErrMsg; 240 int result = sys::ExecuteAndWait(Prog, Args, None, Redirects, Timeout, 241 MemoryLimit, &ErrMsg); 242 243 // If we are supposed to delete the bitcode file or if the passes crashed, 244 // remove it now. This may fail if the file was never created, but that's ok. 245 if (DeleteOutput || result != 0) 246 sys::fs::remove(OutputFilename); 247 248 if (!Quiet) { 249 if (result == 0) 250 outs() << "Success!\n"; 251 else if (result > 0) 252 outs() << "Exited with error code '" << result << "'\n"; 253 else if (result < 0) { 254 if (result == -1) 255 outs() << "Execute failed: " << ErrMsg << "\n"; 256 else 257 outs() << "Crashed: " << ErrMsg << "\n"; 258 } 259 if (result & 0x01000000) 260 outs() << "Dumped core\n"; 261 } 262 263 // Was the child successful? 264 return result != 0; 265 } 266 267 std::unique_ptr<Module> 268 BugDriver::runPassesOn(Module *M, const std::vector<std::string> &Passes, 269 ArrayRef<std::string> ExtraArgs) { 270 std::string BitcodeResult; 271 if (runPasses(*M, Passes, BitcodeResult, false /*delete*/, true /*quiet*/, 272 ExtraArgs)) { 273 return nullptr; 274 } 275 276 std::unique_ptr<Module> Ret = parseInputFile(BitcodeResult, Context); 277 if (!Ret) { 278 errs() << getToolName() << ": Error reading bitcode file '" << BitcodeResult 279 << "'!\n"; 280 exit(1); 281 } 282 sys::fs::remove(BitcodeResult); 283 return Ret; 284 } 285