[Bugpoint] Use 'CC' instead of 'GCC' for variable naming.
We now use clang by default and fallback to gcc when requested. With this commit, names reflect reality. No functional change intended. Discussed with: Rafael Espindola. llvm-svn: 250321
This commit is contained in:
Davide Italiano
parent
92b9ec3c84
commit
ab25621997
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
|
|
@ -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 "";
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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;
|
||||
|
|
|
|||
Loading…
Reference in New Issue