diff options
| -rw-r--r-- | llvm/tools/bugpoint/BugDriver.cpp | 4 | ||||
| -rw-r--r-- | llvm/tools/bugpoint/BugDriver.h | 4 | ||||
| -rw-r--r-- | llvm/tools/bugpoint/ExecutionDriver.cpp | 38 | ||||
| -rw-r--r-- | llvm/tools/bugpoint/Miscompilation.cpp | 4 | ||||
| -rw-r--r-- | llvm/tools/bugpoint/ToolRunner.cpp | 198 | ||||
| -rw-r--r-- | llvm/tools/bugpoint/ToolRunner.h | 50 |
6 files changed, 149 insertions, 149 deletions
diff --git a/llvm/tools/bugpoint/BugDriver.cpp b/llvm/tools/bugpoint/BugDriver.cpp index 43f4c2963fc..d0731f5f6d3 100644 --- a/llvm/tools/bugpoint/BugDriver.cpp +++ b/llvm/tools/bugpoint/BugDriver.cpp @@ -72,7 +72,7 @@ BugDriver::BugDriver(const char *toolname, bool find_bugs, LLVMContext& ctxt) : Context(ctxt), ToolName(toolname), ReferenceOutputFile(OutputFile), Program(nullptr), Interpreter(nullptr), SafeInterpreter(nullptr), - gcc(nullptr), run_find_bugs(find_bugs), Timeout(timeout), + cc(nullptr), run_find_bugs(find_bugs), Timeout(timeout), MemoryLimit(memlimit), UseValgrind(use_valgrind) {} BugDriver::~BugDriver() { @@ -80,7 +80,7 @@ BugDriver::~BugDriver() { if (Interpreter != SafeInterpreter) delete Interpreter; delete SafeInterpreter; - delete gcc; + delete cc; } std::unique_ptr<Module> llvm::parseInputFile(StringRef Filename, diff --git a/llvm/tools/bugpoint/BugDriver.h b/llvm/tools/bugpoint/BugDriver.h index 579781246c5..1bd2e80a630 100644 --- a/llvm/tools/bugpoint/BugDriver.h +++ b/llvm/tools/bugpoint/BugDriver.h @@ -36,7 +36,7 @@ class LLVMContext; class DebugCrashes; -class GCC; +class CC; extern bool DisableSimplifyCFG; @@ -52,7 +52,7 @@ class BugDriver { std::vector<std::string> PassesToRun; AbstractInterpreter *Interpreter; // How to run the program AbstractInterpreter *SafeInterpreter; // To generate reference output, etc. - GCC *gcc; + CC *cc; bool run_find_bugs; unsigned Timeout; unsigned MemoryLimit; diff --git a/llvm/tools/bugpoint/ExecutionDriver.cpp b/llvm/tools/bugpoint/ExecutionDriver.cpp index d7964f357bc..41b8ccc18e8 100644 --- a/llvm/tools/bugpoint/ExecutionDriver.cpp +++ b/llvm/tools/bugpoint/ExecutionDriver.cpp @@ -125,10 +125,10 @@ namespace { cl::ZeroOrMore, cl::PositionalEatsArgs); cl::opt<std::string> - GCCBinary("gcc", cl::init(""), cl::desc("The gcc binary to use.")); + CCBinary("gcc", cl::init(""), cl::desc("The gcc binary to use.")); cl::list<std::string> - GCCToolArgv("gcc-tool-args", cl::Positional, + CCToolArgv("gcc-tool-args", cl::Positional, cl::desc("<gcc-tool arguments>..."), cl::ZeroOrMore, cl::PositionalEatsArgs); } @@ -148,11 +148,11 @@ bool BugDriver::initializeExecutionEnvironment() { SafeInterpreter = nullptr; std::string Message; - if (GCCBinary.empty()) { + if (CCBinary.empty()) { if (sys::findProgramByName("clang")) - GCCBinary = "clang"; + CCBinary = "clang"; else - GCCBinary = "gcc"; + CCBinary = "gcc"; } switch (InterpreterSel) { @@ -165,8 +165,8 @@ bool BugDriver::initializeExecutionEnvironment() { if (!Interpreter) { InterpreterSel = RunLLC; Interpreter = AbstractInterpreter::createLLC(getToolName(), Message, - GCCBinary, &ToolArgv, - &GCCToolArgv); + CCBinary, &ToolArgv, + &CCToolArgv); } if (!Interpreter) { InterpreterSel = RunLLI; @@ -186,8 +186,8 @@ bool BugDriver::initializeExecutionEnvironment() { case RunLLCIA: case LLC_Safe: Interpreter = AbstractInterpreter::createLLC(getToolName(), Message, - GCCBinary, &ToolArgv, - &GCCToolArgv, + CCBinary, &ToolArgv, + &CCToolArgv, InterpreterSel == RunLLCIA); break; case RunJIT: @@ -220,9 +220,9 @@ bool BugDriver::initializeExecutionEnvironment() { SafeInterpreterSel = RunLLC; SafeToolArgs.push_back("--relocation-model=pic"); SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message, - GCCBinary, + CCBinary, &SafeToolArgs, - &GCCToolArgv); + &CCToolArgv); } if (!SafeInterpreter && @@ -231,9 +231,9 @@ bool BugDriver::initializeExecutionEnvironment() { SafeInterpreterSel = RunLLC; SafeToolArgs.push_back("--relocation-model=pic"); SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message, - GCCBinary, + CCBinary, &SafeToolArgs, - &GCCToolArgv); + &CCToolArgv); } if (!SafeInterpreter) { SafeInterpreterSel = AutoPick; @@ -244,8 +244,8 @@ bool BugDriver::initializeExecutionEnvironment() { case RunLLCIA: SafeToolArgs.push_back("--relocation-model=pic"); SafeInterpreter = AbstractInterpreter::createLLC(Path.c_str(), Message, - GCCBinary, &SafeToolArgs, - &GCCToolArgv, + CCBinary, &SafeToolArgs, + &CCToolArgv, SafeInterpreterSel == RunLLCIA); break; case Custom: @@ -259,8 +259,8 @@ bool BugDriver::initializeExecutionEnvironment() { } if (!SafeInterpreter) { outs() << Message << "\nExiting.\n"; exit(1); } - gcc = GCC::create(Message, GCCBinary, &GCCToolArgv); - if (!gcc) { outs() << Message << "\nExiting.\n"; exit(1); } + cc = CC::create(Message, CCBinary, &CCToolArgv); + if (!cc) { outs() << Message << "\nExiting.\n"; exit(1); } // If there was an error creating the selected interpreter, quit with error. return Interpreter == nullptr; @@ -395,13 +395,13 @@ std::string BugDriver::compileSharedObject(const std::string &BitcodeFile, std::string OutputFile; // Using the known-good backend. - GCC::FileType FT = SafeInterpreter->OutputCode(BitcodeFile, OutputFile, + CC::FileType FT = SafeInterpreter->OutputCode(BitcodeFile, OutputFile, Error); if (!Error.empty()) return ""; std::string SharedObjectFile; - bool Failure = gcc->MakeSharedObject(OutputFile, FT, SharedObjectFile, + bool Failure = cc->MakeSharedObject(OutputFile, FT, SharedObjectFile, AdditionalLinkerArgs, Error); if (!Error.empty()) return ""; diff --git a/llvm/tools/bugpoint/Miscompilation.cpp b/llvm/tools/bugpoint/Miscompilation.cpp index fad16368698..2be9bba07d9 100644 --- a/llvm/tools/bugpoint/Miscompilation.cpp +++ b/llvm/tools/bugpoint/Miscompilation.cpp @@ -1080,7 +1080,7 @@ bool BugDriver::debugCodeGenerator(std::string *Error) { } else { outs() << " llc " << TestModuleBC << " -o " << TestModuleBC << ".s\n"; - outs() << " gcc " << SharedObject << " " << TestModuleBC.str() + outs() << " cc " << SharedObject << " " << TestModuleBC.str() << ".s -o " << TestModuleBC << ".exe"; #if defined (HAVE_LINK_R) outs() << " -Wl,-R."; @@ -1093,7 +1093,7 @@ bool BugDriver::debugCodeGenerator(std::string *Error) { outs() << '\n'; outs() << "The shared object was created with:\n llc -march=c " << SafeModuleBC.str() << " -o temporary.c\n" - << " gcc -xc temporary.c -O2 -o " << SharedObject; + << " cc -xc temporary.c -O2 -o " << SharedObject; if (TargetTriple.getArch() == Triple::sparc) outs() << " -G"; // Compile a shared library, `-G' for Sparc else diff --git a/llvm/tools/bugpoint/ToolRunner.cpp b/llvm/tools/bugpoint/ToolRunner.cpp index bf444488f71..2ccd6490512 100644 --- a/llvm/tools/bugpoint/ToolRunner.cpp +++ b/llvm/tools/bugpoint/ToolRunner.cpp @@ -133,7 +133,7 @@ static std::string ProcessFailure(StringRef ProgPath, const char** Args, ErrorFilename.str(), Timeout, MemoryLimit); // FIXME: check return code ? - // Print out the error messages generated by GCC if possible... + // Print out the error messages generated by CC if possible... std::ifstream ErrorFile(ErrorFilename.c_str()); if (ErrorFile) { std::copy(std::istreambuf_iterator<char>(ErrorFile), @@ -165,7 +165,7 @@ namespace { const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs, + const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs = std::vector<std::string>(), unsigned Timeout = 0, @@ -178,7 +178,7 @@ int LLI::ExecuteProgram(const std::string &Bitcode, const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs, + const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs, unsigned Timeout, unsigned MemoryLimit) { @@ -286,7 +286,7 @@ namespace { const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs = + const std::vector<std::string> &CCArgs = std::vector<std::string>(), const std::vector<std::string> &SharedLibs = std::vector<std::string>(), @@ -342,7 +342,7 @@ namespace { const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs, + const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs = std::vector<std::string>(), unsigned Timeout = 0, @@ -355,7 +355,7 @@ int CustomExecutor::ExecuteProgram(const std::string &Bitcode, const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs, + const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs, unsigned Timeout, unsigned MemoryLimit) { @@ -454,7 +454,7 @@ AbstractInterpreter *AbstractInterpreter::createCustomExecutor( //===----------------------------------------------------------------------===// // LLC Implementation of AbstractIntepreter interface // -GCC::FileType LLC::OutputCode(const std::string &Bitcode, +CC::FileType LLC::OutputCode(const std::string &Bitcode, std::string &OutputAsmFile, std::string &Error, unsigned Timeout, unsigned MemoryLimit) { const char *Suffix = (UseIntegratedAssembler ? ".llc.o" : ".llc.s"); @@ -495,7 +495,7 @@ GCC::FileType LLC::OutputCode(const std::string &Bitcode, Timeout, MemoryLimit)) Error = ProcessFailure(LLCPath, &LLCArgs[0], Timeout, MemoryLimit); - return UseIntegratedAssembler ? GCC::ObjectFile : GCC::AsmFile; + return UseIntegratedAssembler ? CC::ObjectFile : CC::AsmFile; } void LLC::compileProgram(const std::string &Bitcode, std::string *Error, @@ -510,22 +510,22 @@ int LLC::ExecuteProgram(const std::string &Bitcode, const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &ArgsForGCC, + const std::vector<std::string> &ArgsForCC, const std::vector<std::string> &SharedLibs, unsigned Timeout, unsigned MemoryLimit) { std::string OutputAsmFile; - GCC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile, *Error, Timeout, + CC::FileType FileKind = OutputCode(Bitcode, OutputAsmFile, *Error, Timeout, MemoryLimit); FileRemover OutFileRemover(OutputAsmFile, !SaveTemps); - std::vector<std::string> GCCArgs(ArgsForGCC); - GCCArgs.insert(GCCArgs.end(), SharedLibs.begin(), SharedLibs.end()); + std::vector<std::string> CCArgs(ArgsForCC); + CCArgs.insert(CCArgs.end(), SharedLibs.begin(), SharedLibs.end()); - // Assuming LLC worked, compile the result with GCC and run it. - return gcc->ExecuteProgram(OutputAsmFile, Args, FileKind, - InputFile, OutputFile, Error, GCCArgs, + // Assuming LLC worked, compile the result with CC and run it. + return cc->ExecuteProgram(OutputAsmFile, Args, FileKind, + InputFile, OutputFile, Error, CCArgs, Timeout, MemoryLimit); } @@ -533,9 +533,9 @@ int LLC::ExecuteProgram(const std::string &Bitcode, /// LLC *AbstractInterpreter::createLLC(const char *Argv0, std::string &Message, - const std::string &GCCBinary, + const std::string &CCBinary, const std::vector<std::string> *Args, - const std::vector<std::string> *GCCArgs, + const std::vector<std::string> *CCArgs, bool UseIntegratedAssembler) { std::string LLCPath = PrependMainExecutablePath("llc", Argv0, (void *)(intptr_t) & createLLC); @@ -544,13 +544,13 @@ LLC *AbstractInterpreter::createLLC(const char *Argv0, return nullptr; } - GCC *gcc = GCC::create(Message, GCCBinary, GCCArgs); - if (!gcc) { + CC *cc = CC::create(Message, CCBinary, CCArgs); + if (!cc) { errs() << Message << "\n"; exit(1); } Message = "Found llc: " + LLCPath + "\n"; - return new LLC(LLCPath, gcc, Args, UseIntegratedAssembler); + return new LLC(LLCPath, cc, Args, UseIntegratedAssembler); } //===---------------------------------------------------------------------===// @@ -572,7 +572,7 @@ namespace { const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs = + const std::vector<std::string> &CCArgs = std::vector<std::string>(), const std::vector<std::string> &SharedLibs = std::vector<std::string>(), @@ -586,7 +586,7 @@ int JIT::ExecuteProgram(const std::string &Bitcode, const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs, + const std::vector<std::string> &CCArgs, const std::vector<std::string> &SharedLibs, unsigned Timeout, unsigned MemoryLimit) { @@ -637,7 +637,7 @@ AbstractInterpreter *AbstractInterpreter::createJIT(const char *Argv0, } //===---------------------------------------------------------------------===// -// GCC abstraction +// CC abstraction // static bool IsARMArchitecture(std::vector<const char*> Args) { @@ -653,82 +653,82 @@ static bool IsARMArchitecture(std::vector<const char*> Args) { return false; } -int GCC::ExecuteProgram(const std::string &ProgramFile, +int CC::ExecuteProgram(const std::string &ProgramFile, const std::vector<std::string> &Args, FileType fileType, const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &ArgsForGCC, + const std::vector<std::string> &ArgsForCC, unsigned Timeout, unsigned MemoryLimit) { - std::vector<const char*> GCCArgs; + std::vector<const char*> CCArgs; - GCCArgs.push_back(GCCPath.c_str()); + CCArgs.push_back(CCPath.c_str()); if (TargetTriple.getArch() == Triple::x86) - GCCArgs.push_back("-m32"); + CCArgs.push_back("-m32"); for (std::vector<std::string>::const_iterator - I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I) - GCCArgs.push_back(I->c_str()); + I = ccArgs.begin(), E = ccArgs.end(); I != E; ++I) + CCArgs.push_back(I->c_str()); // Specify -x explicitly in case the extension is wonky if (fileType != ObjectFile) { - GCCArgs.push_back("-x"); + CCArgs.push_back("-x"); if (fileType == CFile) { - GCCArgs.push_back("c"); - GCCArgs.push_back("-fno-strict-aliasing"); + CCArgs.push_back("c"); + CCArgs.push_back("-fno-strict-aliasing"); } else { - GCCArgs.push_back("assembler"); + CCArgs.push_back("assembler"); // For ARM architectures we don't want this flag. bugpoint isn't // explicitly told what architecture it is working on, so we get - // it from gcc flags - if (TargetTriple.isOSDarwin() && !IsARMArchitecture(GCCArgs)) - GCCArgs.push_back("-force_cpusubtype_ALL"); + // it from cc flags + if (TargetTriple.isOSDarwin() && !IsARMArchitecture(CCArgs)) + CCArgs.push_back("-force_cpusubtype_ALL"); } } - GCCArgs.push_back(ProgramFile.c_str()); // Specify the input filename. + CCArgs.push_back(ProgramFile.c_str()); // Specify the input filename. - GCCArgs.push_back("-x"); - GCCArgs.push_back("none"); - GCCArgs.push_back("-o"); + CCArgs.push_back("-x"); + CCArgs.push_back("none"); + CCArgs.push_back("-o"); SmallString<128> OutputBinary; std::error_code EC = - sys::fs::createUniqueFile(ProgramFile + "-%%%%%%%.gcc.exe", OutputBinary); + sys::fs::createUniqueFile(ProgramFile + "-%%%%%%%.cc.exe", OutputBinary); if (EC) { errs() << "Error making unique filename: " << EC.message() << "\n"; exit(1); } - GCCArgs.push_back(OutputBinary.c_str()); // Output to the right file... + CCArgs.push_back(OutputBinary.c_str()); // Output to the right file... - // Add any arguments intended for GCC. We locate them here because this is + // Add any arguments intended for CC. We locate them here because this is // most likely -L and -l options that need to come before other libraries but // after the source. Other options won't be sensitive to placement on the // command line, so this should be safe. - for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i) - GCCArgs.push_back(ArgsForGCC[i].c_str()); + for (unsigned i = 0, e = ArgsForCC.size(); i != e; ++i) + CCArgs.push_back(ArgsForCC[i].c_str()); - GCCArgs.push_back("-lm"); // Hard-code the math library... - GCCArgs.push_back("-O2"); // Optimize the program a bit... + CCArgs.push_back("-lm"); // Hard-code the math library... + CCArgs.push_back("-O2"); // Optimize the program a bit... #if defined (HAVE_LINK_R) - GCCArgs.push_back("-Wl,-R."); // Search this dir for .so files + CCArgs.push_back("-Wl,-R."); // Search this dir for .so files #endif if (TargetTriple.getArch() == Triple::sparc) - GCCArgs.push_back("-mcpu=v9"); - GCCArgs.push_back(nullptr); // NULL terminator + CCArgs.push_back("-mcpu=v9"); + CCArgs.push_back(nullptr); // NULL terminator - outs() << "<gcc>"; outs().flush(); + outs() << "<CC>"; outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i = 0, e = GCCArgs.size()-1; i != e; ++i) - errs() << " " << GCCArgs[i]; + for (unsigned i = 0, e = CCArgs.size()-1; i != e; ++i) + errs() << " " << CCArgs[i]; errs() << "\n"; ); - if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], "", "", "")) { - *Error = ProcessFailure(GCCPath, &GCCArgs[0]); + if (RunProgramWithTimeout(CCPath, &CCArgs[0], "", "", "")) { + *Error = ProcessFailure(CCPath, &CCArgs[0]); return -1; } @@ -802,9 +802,9 @@ int GCC::ExecuteProgram(const std::string &ProgramFile, } } -int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType, +int CC::MakeSharedObject(const std::string &InputFile, FileType fileType, std::string &OutputFile, - const std::vector<std::string> &ArgsForGCC, + const std::vector<std::string> &ArgsForCC, std::string &Error) { SmallString<128> UniqueFilename; std::error_code EC = sys::fs::createUniqueFile( @@ -815,84 +815,84 @@ int GCC::MakeSharedObject(const std::string &InputFile, FileType fileType, } OutputFile = UniqueFilename.str(); - std::vector<const char*> GCCArgs; + std::vector<const char*> CCArgs; - GCCArgs.push_back(GCCPath.c_str()); + CCArgs.push_back(CCPath.c_str()); if (TargetTriple.getArch() == Triple::x86) - GCCArgs.push_back("-m32"); + CCArgs.push_back("-m32"); for (std::vector<std::string>::const_iterator - I = gccArgs.begin(), E = gccArgs.end(); I != E; ++I) - GCCArgs.push_back(I->c_str()); + I = ccArgs.begin(), E = ccArgs.end(); I != E; ++I) + CCArgs.push_back(I->c_str()); // Compile the C/asm file into a shared object if (fileType != ObjectFile) { - GCCArgs.push_back("-x"); - GCCArgs.push_back(fileType == AsmFile ? "assembler" : "c"); + CCArgs.push_back("-x"); + CCArgs.push_back(fileType == AsmFile ? "assembler" : "c"); } - GCCArgs.push_back("-fno-strict-aliasing"); - GCCArgs.push_back(InputFile.c_str()); // Specify the input filename. - GCCArgs.push_back("-x"); - GCCArgs.push_back("none"); + CCArgs.push_back("-fno-strict-aliasing"); + CCArgs.push_back(InputFile.c_str()); // Specify the input filename. + CCArgs.push_back("-x"); + CCArgs.push_back("none"); if (TargetTriple.getArch() == Triple::sparc) - GCCArgs.push_back("-G"); // Compile a shared library, `-G' for Sparc + CCArgs.push_back("-G"); // Compile a shared library, `-G' for Sparc else if (TargetTriple.isOSDarwin()) { // link all source files into a single module in data segment, rather than // generating blocks. dynamic_lookup requires that you set // MACOSX_DEPLOYMENT_TARGET=10.3 in your env. FIXME: it would be better for - // bugpoint to just pass that in the environment of GCC. - GCCArgs.push_back("-single_module"); - GCCArgs.push_back("-dynamiclib"); // `-dynamiclib' for MacOS X/PowerPC - GCCArgs.push_back("-undefined"); - GCCArgs.push_back("dynamic_lookup"); + // bugpoint to just pass that in the environment of CC. + CCArgs.push_back("-single_module"); + CCArgs.push_back("-dynamiclib"); // `-dynamiclib' for MacOS X/PowerPC + CCArgs.push_back("-undefined"); + CCArgs.push_back("dynamic_lookup"); } else - GCCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others + CCArgs.push_back("-shared"); // `-shared' for Linux/X86, maybe others if (TargetTriple.getArch() == Triple::x86_64) - GCCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC + CCArgs.push_back("-fPIC"); // Requires shared objs to contain PIC if (TargetTriple.getArch() == Triple::sparc) - GCCArgs.push_back("-mcpu=v9"); + CCArgs.push_back("-mcpu=v9"); - GCCArgs.push_back("-o"); - GCCArgs.push_back(OutputFile.c_str()); // Output to the right filename. - GCCArgs.push_back("-O2"); // Optimize the program a bit. + CCArgs.push_back("-o"); + CCArgs.push_back(OutputFile.c_str()); // Output to the right filename. + CCArgs.push_back("-O2"); // Optimize the program a bit. - // Add any arguments intended for GCC. We locate them here because this is + // Add any arguments intended for CC. We locate them here because this is // most likely -L and -l options that need to come before other libraries but // after the source. Other options won't be sensitive to placement on the // command line, so this should be safe. - for (unsigned i = 0, e = ArgsForGCC.size(); i != e; ++i) - GCCArgs.push_back(ArgsForGCC[i].c_str()); - GCCArgs.push_back(nullptr); // NULL terminator + for (unsigned i = 0, e = ArgsForCC.size(); i != e; ++i) + CCArgs.push_back(ArgsForCC[i].c_str()); + CCArgs.push_back(nullptr); // NULL terminator - outs() << "<gcc>"; outs().flush(); + outs() << "<CC>"; outs().flush(); DEBUG(errs() << "\nAbout to run:\t"; - for (unsigned i = 0, e = GCCArgs.size()-1; i != e; ++i) - errs() << " " << GCCArgs[i]; + for (unsigned i = 0, e = CCArgs.size()-1; i != e; ++i) + errs() << " " << CCArgs[i]; errs() << "\n"; ); - if (RunProgramWithTimeout(GCCPath, &GCCArgs[0], "", "", "")) { - Error = ProcessFailure(GCCPath, &GCCArgs[0]); + if (RunProgramWithTimeout(CCPath, &CCArgs[0], "", "", "")) { + Error = ProcessFailure(CCPath, &CCArgs[0]); return 1; } return 0; } -/// create - Try to find the `gcc' executable +/// create - Try to find the CC executable /// -GCC *GCC::create(std::string &Message, - const std::string &GCCBinary, +CC *CC::create(std::string &Message, + const std::string &CCBinary, const std::vector<std::string> *Args) { - auto GCCPath = sys::findProgramByName(GCCBinary); - if (!GCCPath) { - Message = "Cannot find `" + GCCBinary + "' in PATH: " + - GCCPath.getError().message() + "\n"; + auto CCPath = sys::findProgramByName(CCBinary); + if (!CCPath) { + Message = "Cannot find `" + CCBinary + "' in PATH: " + + CCPath.getError().message() + "\n"; return nullptr; } @@ -907,6 +907,6 @@ GCC *GCC::create(std::string &Message, RemoteClientPath = *Path; } - Message = "Found gcc: " + *GCCPath + "\n"; - return new GCC(*GCCPath, RemoteClientPath, Args); + Message = "Found CC: " + *CCPath + "\n"; + return new CC(*CCPath, RemoteClientPath, Args); } diff --git a/llvm/tools/bugpoint/ToolRunner.h b/llvm/tools/bugpoint/ToolRunner.h index 5d67a942687..3accd70ed4c 100644 --- a/llvm/tools/bugpoint/ToolRunner.h +++ b/llvm/tools/bugpoint/ToolRunner.h @@ -33,22 +33,22 @@ extern Triple TargetTriple; class LLC; //===---------------------------------------------------------------------===// -// GCC abstraction +// CC abstraction // -class GCC { - std::string GCCPath; // The path to the gcc executable. +class CC { + std::string CCPath; // The path to the cc executable. std::string RemoteClientPath; // The path to the rsh / ssh executable. - std::vector<std::string> gccArgs; // GCC-specific arguments. - GCC(StringRef gccPath, StringRef RemotePath, - const std::vector<std::string> *GCCArgs) - : GCCPath(gccPath), RemoteClientPath(RemotePath) { - if (GCCArgs) gccArgs = *GCCArgs; + std::vector<std::string> ccArgs; // CC-specific arguments. + CC(StringRef ccPath, StringRef RemotePath, + const std::vector<std::string> *CCArgs) + : CCPath(ccPath), RemoteClientPath(RemotePath) { + if (CCArgs) ccArgs = *CCArgs; } public: enum FileType { AsmFile, ObjectFile, CFile }; - static GCC *create(std::string &Message, - const std::string &GCCBinary, + static CC *create(std::string &Message, + const std::string &CCBinary, const std::vector<std::string> *Args); /// ExecuteProgram - Execute the program specified by "ProgramFile" (which is @@ -64,7 +64,7 @@ public: const std::string &InputFile, const std::string &OutputFile, std::string *Error = nullptr, - const std::vector<std::string> &GCCArgs = + const std::vector<std::string> &CCArgs = std::vector<std::string>(), unsigned Timeout = 0, unsigned MemoryLimit = 0); @@ -74,7 +74,7 @@ public: /// int MakeSharedObject(const std::string &InputFile, FileType fileType, std::string &OutputFile, - const std::vector<std::string> &ArgsForGCC, + const std::vector<std::string> &ArgsForCC, std::string &Error); }; @@ -88,9 +88,9 @@ class AbstractInterpreter { virtual void anchor(); public: static LLC *createLLC(const char *Argv0, std::string &Message, - const std::string &GCCBinary, + const std::string &CCBinary, const std::vector<std::string> *Args = nullptr, - const std::vector<std::string> *GCCArgs = nullptr, + const std::vector<std::string> *CCArgs = nullptr, bool UseIntegratedAssembler = false); static AbstractInterpreter* @@ -119,15 +119,15 @@ public: unsigned Timeout = 0, unsigned MemoryLimit = 0) {} /// OutputCode - Compile the specified program from bitcode to code - /// understood by the GCC driver (either C or asm). If the code generator + /// understood by the CC driver (either C or asm). If the code generator /// fails, it sets Error, otherwise, this function returns the type of code /// emitted. - virtual GCC::FileType OutputCode(const std::string &Bitcode, + virtual CC::FileType OutputCode(const std::string &Bitcode, std::string &OutFile, std::string &Error, unsigned Timeout = 0, unsigned MemoryLimit = 0) { Error = "OutputCode not supported by this AbstractInterpreter!"; - return GCC::AsmFile; + return CC::AsmFile; } /// ExecuteProgram - Run the specified bitcode file, emitting output to the @@ -140,7 +140,7 @@ public: const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs = + const std::vector<std::string> &CCArgs = std::vector<std::string>(), const std::vector<std::string> &SharedLibs = std::vector<std::string>(), @@ -154,18 +154,18 @@ public: class LLC : public AbstractInterpreter { std::string LLCPath; // The path to the LLC executable. std::vector<std::string> ToolArgs; // Extra args to pass to LLC. - GCC *gcc; + CC *cc; bool UseIntegratedAssembler; public: - LLC(const std::string &llcPath, GCC *Gcc, + LLC(const std::string &llcPath, CC *cc, const std::vector<std::string> *Args, bool useIntegratedAssembler) - : LLCPath(llcPath), gcc(Gcc), + : LLCPath(llcPath), cc(cc), UseIntegratedAssembler(useIntegratedAssembler) { ToolArgs.clear(); if (Args) ToolArgs = *Args; } - ~LLC() override { delete gcc; } + ~LLC() override { delete cc; } /// compileProgram - Compile the specified program from bitcode to executable /// code. This does not produce any output, it is only used when debugging @@ -178,7 +178,7 @@ public: const std::string &InputFile, const std::string &OutputFile, std::string *Error, - const std::vector<std::string> &GCCArgs = + const std::vector<std::string> &CCArgs = std::vector<std::string>(), const std::vector<std::string> &SharedLibs = std::vector<std::string>(), @@ -186,10 +186,10 @@ public: unsigned MemoryLimit = 0) override; /// OutputCode - Compile the specified program from bitcode to code - /// understood by the GCC driver (either C or asm). If the code generator + /// understood by the CC driver (either C or asm). If the code generator /// fails, it sets Error, otherwise, this function returns the type of code /// emitted. - GCC::FileType OutputCode(const std::string &Bitcode, + CC::FileType OutputCode(const std::string &Bitcode, std::string &OutFile, std::string &Error, unsigned Timeout = 0, unsigned MemoryLimit = 0) override; |
