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::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 true; 143 } 144 OutputFilename = std::string(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 true; 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 true; 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 true; 177 } 178 if (!sys::fs::exists(tool)) { 179 errs() << "Specified `opt' binary does not exist: " << tool << "\n"; 180 return true; 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 true; 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 // Pin to legacy PM since bugpoint has lots of infra and hacks revolving 209 // around the legacy PM. 210 Args.push_back("-enable-new-pm=0"); 211 Args.push_back("-disable-symbolication"); 212 Args.push_back("-o"); 213 Args.push_back(OutputFilename); 214 std::vector<std::string> pass_args; 215 for (unsigned i = 0, e = PluginLoader::getNumPlugins(); i != e; ++i) { 216 pass_args.push_back(std::string("-load")); 217 pass_args.push_back(PluginLoader::getPlugin(i)); 218 } 219 for (std::vector<std::string>::const_iterator I = Passes.begin(), 220 E = Passes.end(); 221 I != E; ++I) 222 pass_args.push_back(std::string("-") + (*I)); 223 for (std::vector<std::string>::const_iterator I = pass_args.begin(), 224 E = pass_args.end(); 225 I != E; ++I) 226 Args.push_back(*I); 227 Args.push_back(Temp->TmpName); 228 Args.append(ExtraArgs.begin(), ExtraArgs.end()); 229 230 LLVM_DEBUG(errs() << "\nAbout to run:\t"; 231 for (unsigned i = 0, e = Args.size() - 1; i != e; ++i) errs() 232 << " " << Args[i]; 233 errs() << "\n";); 234 235 std::optional<StringRef> Redirects[3] = {std::nullopt, std::nullopt, 236 std::nullopt}; 237 // Redirect stdout and stderr to nowhere if SilencePasses is given. 238 if (SilencePasses) { 239 Redirects[1] = ""; 240 Redirects[2] = ""; 241 } 242 243 std::string ErrMsg; 244 int result = sys::ExecuteAndWait(Prog, Args, std::nullopt, Redirects, Timeout, 245 MemoryLimit, &ErrMsg); 246 247 // If we are supposed to delete the bitcode file or if the passes crashed, 248 // remove it now. This may fail if the file was never created, but that's ok. 249 if (DeleteOutput || result != 0) 250 sys::fs::remove(OutputFilename); 251 252 if (!Quiet) { 253 if (result == 0) 254 outs() << "Success!\n"; 255 else if (result > 0) 256 outs() << "Exited with error code '" << result << "'\n"; 257 else if (result < 0) { 258 if (result == -1) 259 outs() << "Execute failed: " << ErrMsg << "\n"; 260 else 261 outs() << "Crashed: " << ErrMsg << "\n"; 262 } 263 if (result & 0x01000000) 264 outs() << "Dumped core\n"; 265 } 266 267 // Was the child successful? 268 return result != 0; 269 } 270 271 std::unique_ptr<Module> 272 BugDriver::runPassesOn(Module *M, const std::vector<std::string> &Passes, 273 ArrayRef<std::string> ExtraArgs) { 274 std::string BitcodeResult; 275 if (runPasses(*M, Passes, BitcodeResult, false /*delete*/, true /*quiet*/, 276 ExtraArgs)) { 277 return nullptr; 278 } 279 280 std::unique_ptr<Module> Ret = parseInputFile(BitcodeResult, Context); 281 if (!Ret) { 282 errs() << getToolName() << ": Error reading bitcode file '" << BitcodeResult 283 << "'!\n"; 284 exit(1); 285 } 286 sys::fs::remove(BitcodeResult); 287 return Ret; 288 } 289