// BuildLinkItems -- This function generates a LinkItemList for the LinkItems
// linker function by combining the Files and Libraries in the order they were
// declared on the command line.
static void BuildLinkItems(
Linker::ItemList& Items,
const cl::list<std::string>& Files,
const cl::list<std::string>& Libraries) {
// Build the list of linkage items for LinkItems.
cl::list<std::string>::const_iterator fileIt = Files.begin();
cl::list<std::string>::const_iterator libIt = Libraries.begin();
int libPos = -1, filePos = -1;
while ( libIt != Libraries.end() || fileIt != Files.end() ) {
if (libIt != Libraries.end())
libPos = Libraries.getPosition(libIt - Libraries.begin());
else
libPos = -1;
if (fileIt != Files.end())
filePos = Files.getPosition(fileIt - Files.begin());
else
filePos = -1;
if (filePos != -1 && (libPos == -1 || filePos < libPos)) {
// Add a source file
Items.push_back(std::make_pair(*fileIt++, false));
} else if (libPos != -1 && (filePos == -1 || libPos < filePos)) {
// Add a library
Items.push_back(std::make_pair(*libIt++, true));
}
}
}
int main(int argc, const char **argv) {
llvm::sys::PrintStackTraceOnErrorSignal(argv[0]);
CommonOptionsParser OptionsParser(argc, argv, ClangQueryCategory);
if (!Commands.empty() && !CommandFiles.empty()) {
llvm::errs() << argv[0] << ": cannot specify both -c and -f\n";
return 1;
}
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
std::vector<std::unique_ptr<ASTUnit>> ASTs;
if (Tool.buildASTs(ASTs) != 0)
return 1;
QuerySession QS(ASTs);
if (!Commands.empty()) {
for (cl::list<std::string>::iterator I = Commands.begin(),
E = Commands.end();
I != E; ++I) {
QueryRef Q = QueryParser::parse(*I, QS);
if (!Q->run(llvm::outs(), QS))
return 1;
}
} else if (!CommandFiles.empty()) {
for (cl::list<std::string>::iterator I = CommandFiles.begin(),
E = CommandFiles.end();
I != E; ++I) {
std::ifstream Input(I->c_str());
if (!Input.is_open()) {
llvm::errs() << argv[0] << ": cannot open " << *I << "\n";
return 1;
}
while (Input.good()) {
std::string Line;
std::getline(Input, Line);
QueryRef Q = QueryParser::parse(Line, QS);
if (!Q->run(llvm::outs(), QS))
return 1;
}
}
} else {
LineEditor LE("clang-query");
LE.setListCompleter([&QS](StringRef Line, size_t Pos) {
return QueryParser::complete(Line, Pos, QS);
});
while (llvm::Optional<std::string> Line = LE.readLine()) {
QueryRef Q = QueryParser::parse(*Line, QS);
Q->run(llvm::outs(), QS);
llvm::outs().flush();
if (QS.Terminate)
break;
}
}
return 0;
}
InternalizePass::InternalizePass()
: ModulePass(ID) {
initializeInternalizePassPass(*PassRegistry::getPassRegistry());
if (!APIFile.empty()) // If a filename is specified, use it.
LoadFile(APIFile.c_str());
ExternalNames.insert(APIList.begin(), APIList.end());
DSONames.insert(DSOList.begin(), DSOList.end());
}
// Helper function used by Build().
// Traverses initial portions of the toolchains (up to the first Join node).
// This function is also responsible for handling the -x option.
void CompilationGraph::BuildInitial (InputLanguagesSet& InLangs,
const sys::Path& TempDir) {
// This is related to -x option handling.
cl::list<std::string>::const_iterator xIter = Languages.begin(),
xBegin = xIter, xEnd = Languages.end();
bool xEmpty = true;
const std::string* xLanguage = 0;
unsigned xPos = 0, xPosNext = 0, filePos = 0;
if (xIter != xEnd) {
xEmpty = false;
xPos = Languages.getPosition(xIter - xBegin);
cl::list<std::string>::const_iterator xNext = llvm::next(xIter);
xPosNext = (xNext == xEnd) ? std::numeric_limits<unsigned>::max()
: Languages.getPosition(xNext - xBegin);
xLanguage = (*xIter == "none") ? 0 : &(*xIter);
}
// For each input file:
for (cl::list<std::string>::const_iterator B = InputFilenames.begin(),
CB = B, E = InputFilenames.end(); B != E; ++B) {
sys::Path In = sys::Path(*B);
// Code for handling the -x option.
// Output: std::string* xLanguage (can be NULL).
if (!xEmpty) {
filePos = InputFilenames.getPosition(B - CB);
if (xPos < filePos) {
if (filePos < xPosNext) {
xLanguage = (*xIter == "none") ? 0 : &(*xIter);
}
else { // filePos >= xPosNext
// Skip xIters while filePos > xPosNext
while (filePos > xPosNext) {
++xIter;
xPos = xPosNext;
cl::list<std::string>::const_iterator xNext = llvm::next(xIter);
if (xNext == xEnd)
xPosNext = std::numeric_limits<unsigned>::max();
else
xPosNext = Languages.getPosition(xNext - xBegin);
xLanguage = (*xIter == "none") ? 0 : &(*xIter);
}
}
}
}
// Find the toolchain corresponding to this file.
const Node* N = FindToolChain(In, xLanguage, InLangs);
// Pass file through the chain starting at head.
PassThroughGraph(In, N, InLangs, TempDir);
}
}
int main(int argc, char **argv) {
llvm::sys::PrintStackTraceOnErrorSignal();
llvm::PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
sys::SetInterruptFunction(BugpointInterruptFunction);
BugDriver D(argv[0], AsChild, FindBugs, TimeoutValue, MemoryLimit);
if (D.addSources(InputFilenames)) return 1;
D.addPasses(PassList.begin(), PassList.end());
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
sys::Process::PreventCoreFiles();
try {
return D.run();
} catch (ToolExecutionError &TEE) {
std::cerr << "Tool execution error: " << TEE.what() << '\n';
} catch (const std::string& msg) {
std::cerr << argv[0] << ": " << msg << "\n";
} catch (...) {
std::cerr << "Whoops, an exception leaked out of bugpoint. "
<< "This is a bug in bugpoint!\n";
}
return 1;
}
bool Preparer::runOnModule(Module &M) {
IdentifyThreadFuncs &ITF = getAnalysis<IdentifyThreadFuncs>();
for (cl::list<string>::const_iterator itr = OtherThreadFunctions.begin();
itr != OtherThreadFunctions.end(); ++itr) {
DEBUG(dbgs() << "Other thread functions: " << *itr << "\n";);
}
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n");
ToolName = argv[0];
if (OutputFormatShort.getNumOccurrences())
OutputFormat = OutputFormatShort;
if (RadixShort.getNumOccurrences())
Radix = RadixShort;
if (InputFilenames.size() == 0)
InputFilenames.push_back("a.out");
if (OutputFormat == berkeley)
outs() << " text data bss "
<< (Radix == octal ? "oct" : "dec")
<< " hex filename\n";
std::for_each(InputFilenames.begin(), InputFilenames.end(),
PrintFileSectionSizes);
return 0;
}
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n");
ToolName = argv[0];
if (OutputFormatShort.getNumOccurrences())
OutputFormat = OutputFormatShort;
if (RadixShort.getNumOccurrences())
Radix = RadixShort;
for (unsigned i = 0; i < ArchFlags.size(); ++i) {
if (ArchFlags[i] == "all") {
ArchAll = true;
} else {
if (!MachOObjectFile::isValidArch(ArchFlags[i])) {
outs() << ToolName << ": for the -arch option: Unknown architecture "
<< "named '" << ArchFlags[i] << "'";
return 1;
}
}
}
if (InputFilenames.size() == 0)
InputFilenames.push_back("a.out");
moreThanOneFile = InputFilenames.size() > 1;
std::for_each(InputFilenames.begin(), InputFilenames.end(),
PrintFileSectionSizes);
return 0;
}
bool DefineExtsPass::runOnModule(Module& M) {
bool modified = false;
for(cl::list<std::string>::iterator it = NullSymbols.begin(), it2 = NullSymbols.end(); it != it2; ++it) {
GlobalValue* GV = M.getNamedValue(*it);
if(!GV) {
errs() << "Warning: skipped value " << *it << " (symbol not found)\n";
continue;
}
if(Function* F = dyn_cast<Function>(GV)) {
if(!F->isDeclaration()) {
errs() << "Warning: skipped function " << *it << " because it has a definition\n";
continue;
}
}
GV->replaceAllUsesWith(Constant::getNullValue(GV->getType()));
modified = true;
}
return modified;
}
/// EmitShellScript - Output the wrapper file that invokes the JIT on the LLVM
/// bytecode file for the program.
static void EmitShellScript(char **argv) {
if (Verbose)
cout << "Emitting Shell Script\n";
#if defined(_WIN32) || defined(__CYGWIN__)
// Windows doesn't support #!/bin/sh style shell scripts in .exe files. To
// support windows systems, we copy the llvm-stub.exe executable from the
// build tree to the destination file.
std::string ErrMsg;
sys::Path llvmstub = FindExecutable("llvm-stub.exe", argv[0]);
if (llvmstub.isEmpty())
PrintAndExit("Could not find llvm-stub.exe executable!");
if (0 != sys::CopyFile(sys::Path(OutputFilename), llvmstub, &ErrMsg))
PrintAndExit(ErrMsg);
return;
#endif
// Output the script to start the program...
std::ofstream Out2(OutputFilename.c_str());
if (!Out2.good())
PrintAndExit("error opening '" + OutputFilename + "' for writing!");
Out2 << "#!/bin/sh\n";
// Allow user to setenv LLVMINTERP if lli is not in their PATH.
Out2 << "lli=${LLVMINTERP-lli}\n";
Out2 << "exec $lli \\\n";
// gcc accepts -l<lib> and implicitly searches /lib and /usr/lib.
LibPaths.push_back("/lib");
LibPaths.push_back("/usr/lib");
LibPaths.push_back("/usr/X11R6/lib");
// We don't need to link in libc! In fact, /usr/lib/libc.so may not be a
// shared object at all! See RH 8: plain text.
std::vector<std::string>::iterator libc =
std::find(Libraries.begin(), Libraries.end(), "c");
if (libc != Libraries.end()) Libraries.erase(libc);
// List all the shared object (native) libraries this executable will need
// on the command line, so that we don't have to do this manually!
for (std::vector<std::string>::iterator i = Libraries.begin(),
e = Libraries.end(); i != e; ++i) {
sys::Path FullLibraryPath = sys::Path::FindLibrary(*i);
if (!FullLibraryPath.isEmpty() && FullLibraryPath.isDynamicLibrary())
Out2 << " -load=" << FullLibraryPath.toString() << " \\\n";
}
Out2 << " $0.bc ${1+\"$@\"}\n";
Out2.close();
}
bool Preparer::is_specified_thread_function(const Function *f) const {
for (cl::list<string>::const_iterator itr = OtherThreadFunctions.begin();
itr != OtherThreadFunctions.end(); ++itr) {
if (f->getName() == *itr)
return true;
}
return false;
}
InternalizePass::InternalizePass(bool AllButMain)
: ModulePass(ID), AllButMain(AllButMain){
initializeInternalizePassPass(*PassRegistry::getPassRegistry());
if (!APIFile.empty()) // If a filename is specified, use it.
LoadFile(APIFile.c_str());
if (!APIList.empty()) // If a list is specified, use it as well.
ExternalNames.insert(APIList.begin(), APIList.end());
}
// Try to find the first match in buffer for any prefix. If a valid match is
// found, return that prefix and set its type and location. If there are almost
// matches (e.g. the actual prefix string is found, but is not an actual check
// string), but no valid match, return an empty string and set the position to
// resume searching from. If no partial matches are found, return an empty
// string and the location will be StringRef::npos. If one prefix is a substring
// of another, the maximal match should be found. e.g. if "A" and "AA" are
// prefixes then AA-CHECK: should match the second one.
static StringRef FindFirstCandidateMatch(StringRef &Buffer,
Check::CheckType &CheckTy,
size_t &CheckLoc) {
StringRef FirstPrefix;
size_t FirstLoc = StringRef::npos;
size_t SearchLoc = StringRef::npos;
Check::CheckType FirstTy = Check::CheckNone;
CheckTy = Check::CheckNone;
CheckLoc = StringRef::npos;
for (prefix_iterator I = CheckPrefixes.begin(), E = CheckPrefixes.end();
I != E; ++I) {
StringRef Prefix(*I);
size_t PrefixLoc = Buffer.find(Prefix);
if (PrefixLoc == StringRef::npos)
continue;
// Track where we are searching for invalid prefixes that look almost right.
// We need to only advance to the first partial match on the next attempt
// since a partial match could be a substring of a later, valid prefix.
// Need to skip to the end of the word, otherwise we could end up
// matching a prefix in a substring later.
if (PrefixLoc < SearchLoc)
SearchLoc = SkipWord(Buffer, PrefixLoc);
// We only want to find the first match to avoid skipping some.
if (PrefixLoc > FirstLoc)
continue;
// If one matching check-prefix is a prefix of another, choose the
// longer one.
if (PrefixLoc == FirstLoc && Prefix.size() < FirstPrefix.size())
continue;
StringRef Rest = Buffer.drop_front(PrefixLoc);
// Make sure we have actually found the prefix, and not a word containing
// it. This should also prevent matching the wrong prefix when one is a
// substring of another.
if (PrefixLoc != 0 && IsPartOfWord(Buffer[PrefixLoc - 1]))
FirstTy = Check::CheckNone;
else
FirstTy = FindCheckType(Rest, Prefix);
FirstLoc = PrefixLoc;
FirstPrefix = Prefix;
}
// If the first prefix is invalid, we should continue the search after it.
if (FirstTy == Check::CheckNone) {
CheckLoc = SearchLoc;
return "";
}
CheckTy = FirstTy;
CheckLoc = FirstLoc;
return FirstPrefix;
}
int main(int argc, const char **argv) {
CommonOptionsParser OptionsParser(argc, argv, NoGlobalStyleCategory);
ClangTool Tool(OptionsParser.getCompilations(),
OptionsParser.getSourcePathList());
MatchFinder finder;
// Snarf abstract-only namespaces from the environment.
std::vector<std::string> abstract_namespaces_v, banned_namespaces_v;
std::copy(abstract_namespaces.begin(), abstract_namespaces.end(), std::back_inserter(abstract_namespaces_v));
std::copy(banned_namespaces.begin(), banned_namespaces.end(), std::back_inserter(banned_namespaces_v));
std::unique_ptr<RuleCheckerBase> rules[] = {
make_unique<DisallowNew>(),
make_unique<DisallowDelete>(),
make_unique<DisallowGlobals>(),
make_unique<DisallowNonAbstract>(abstract_namespaces_v),
make_unique<DisallowCoupling>(banned_namespaces_v)
};
size_t rules_size = sizeof(rules) / sizeof(rules[0]);
auto rules_begin = &rules[0];
auto rules_end = &rules[rules_size];
std::vector<std::string> analyze_paths_v;
std::copy(analyze_paths.begin(), analyze_paths.end(), std::back_inserter(analyze_paths_v));
for (size_t i = 0; i < sizeof(rules) / sizeof(rules[0]); ++i) {
auto &rule = rules[i];
rule->setAnalyzePaths(analyze_paths_v);
rule->SetupMatches(finder);
rule->getPrinter().setDebug(Debug.getValue());
}
#ifndef NDEBUG
llvm::DebugFlag = Debug.getValue();
#endif
return Tool.run(newFrontendActionFactory(&finder).get()) ||
(Werror.getValue() &&
std::any_of
(rules_begin, rules_end,
[] (const std::unique_ptr<RuleCheckerBase> &rule) {
return rule->getPrinter().getWarnings();
}));
}
bool Mutator::runOnModule(Module &M) {
unsigned siteId = 0;
OperatorManager *OMgr = OperatorManager::getInstance();
OperatorInfoList oplst;
// Loop through all functions within module
for (Module::iterator F = M.begin(), ME = M.end(); F != ME; ++F) {
// Loop through all basic blocks within function
for (Function::iterator B = F->begin(), FE = F->end(); B != FE; ++B) {
// Loop through all instructions within basic block
for (BasicBlock::iterator I = B->begin(), BE = B->end(); I != BE; I++) {
// Consider only mutable instructions
OMgr->getCompatibleOperators(I, oplst);
bool mutated = false;
for (OperatorInfoList::iterator opi = oplst.begin(); opi != oplst.end(); opi++) {
cl::list<unsigned>::iterator sid = find (MutationIDS.begin(), MutationIDS.end(), siteId++);
if (sid != MutationIDS.end()) {
// One of the specified mutations was found
if (!mutated) {
MutationOperator *op = (*opi)->build();
Value *newv = op->apply(I);
//cerr << *I << " --> " << *newv << "\n";
if (newv != NULL) {
ReplaceInstWithValue(B->getInstList(), I, newv);
} else {
}
mutated = true;
} else {
throw std::string("An instruction is being mutated twice! Aborting...");
}
}
}
}
}
}
// notify change of program
return true;
}
void setTraces(Network* network){
std::list<Instance*>::iterator it;
std::list<Instance*>* instances = network->getInstances();
bool traceAll = false;
// Check if "all" option is activate
if (debexec.begin()->compare("all")==0){
traceAll = true;
}
for (it = instances->begin(); it != instances->end(); it++){
Instance* instance = *it;
if (traceAll || (debexec.end() != find(debexec.begin(), debexec.end(), instance->getId()))){
instance->setTrace(true);
}
}
}
// Determine whether the inliner will be run.
bool willInline() {
if (doInline())
return true;
// It may also have been specified explicitly on the command line as an explicit pass
typedef cl::list<const PassInfo*, bool, PassNameParser> PL;
for (PL::iterator I = passList.begin(), E = passList.end(); I != E; ++I) {
if (!std::strcmp((*I)->getPassArgument(), "inline"))
return true;
}
return false;
}
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv, "llvm dwarf dumper\n");
// Defaults to a.out if no filenames specified.
if (InputFilenames.size() == 0)
InputFilenames.push_back("a.out");
std::for_each(InputFilenames.begin(), InputFilenames.end(), DumpInput);
return 0;
}
static bool ValidateCheckPrefixes() {
StringSet<> PrefixSet;
for (prefix_iterator I = CheckPrefixes.begin(), E = CheckPrefixes.end();
I != E; ++I) {
StringRef Prefix(*I);
if (!PrefixSet.insert(Prefix))
return false;
if (!ValidateCheckPrefix(Prefix))
return false;
}
return true;
}
int main(int argc, char **argv) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
cl::ParseCommandLineOptions(argc, argv, "llvm MC markup parser\n");
ToolName = argv[0];
// If no input files specified, read from stdin.
if (InputFilenames.size() == 0)
InputFilenames.push_back("-");
std::for_each(InputFilenames.begin(), InputFilenames.end(),
parseMCMarkup);
return 0;
}
int main(int argc, char **argv) {
#ifndef DEBUG_BUGPOINT
llvm::sys::PrintStackTraceOnErrorSignal();
llvm::PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
#endif
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeObjCARCOpts(Registry);
initializeVectorization(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeIPA(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeInstrumentation(Registry);
initializeTarget(Registry);
#ifdef LINK_POLLY_INTO_TOOLS
polly::initializePollyPasses(Registry);
#endif
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
#ifndef DEBUG_BUGPOINT
sys::SetInterruptFunction(BugpointInterruptFunction);
#endif
LLVMContext& Context = getGlobalContext();
// If we have an override, set it and then track the triple we want Modules
// to use.
if (!OverrideTriple.empty()) {
TargetTriple.setTriple(Triple::normalize(OverrideTriple));
outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
}
if (MemoryLimit < 0) {
// Set the default MemoryLimit. Be sure to update the flag's description if
// you change this.
if (sys::RunningOnValgrind() || UseValgrind)
MemoryLimit = 800;
else
MemoryLimit = 400;
}
BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
UseValgrind, Context);
if (D.addSources(InputFilenames)) return 1;
AddToDriver PM(D);
if (StandardLinkOpts) {
PassManagerBuilder Builder;
Builder.Inliner = createFunctionInliningPass();
Builder.populateLTOPassManager(PM);
}
if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
PassManagerBuilder Builder;
if (OptLevelO1)
Builder.Inliner = createAlwaysInlinerPass();
else if (OptLevelO2)
Builder.Inliner = createFunctionInliningPass(225);
else
Builder.Inliner = createFunctionInliningPass(275);
// Note that although clang/llvm-gcc use two separate passmanagers
// here, it shouldn't normally make a difference.
Builder.populateFunctionPassManager(PM);
Builder.populateModulePassManager(PM);
}
for (std::vector<const PassInfo*>::iterator I = PassList.begin(),
E = PassList.end();
I != E; ++I) {
const PassInfo* PI = *I;
D.addPass(PI->getPassArgument());
}
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
#ifndef DEBUG_BUGPOINT
sys::Process::PreventCoreFiles();
#endif
std::string Error;
bool Failure = D.run(Error);
if (!Error.empty()) {
errs() << Error;
return 1;
}
return Failure;
}
/// EmitShellScript - Output the wrapper file that invokes the JIT on the LLVM
/// bitcode file for the program.
static void EmitShellScript(char **argv, Module *M) {
if (Verbose)
errs() << "Emitting Shell Script\n";
#if defined(_WIN32)
// Windows doesn't support #!/bin/sh style shell scripts in .exe files. To
// support windows systems, we copy the llvm-stub.exe executable from the
// build tree to the destination file.
std::string ErrMsg;
sys::Path llvmstub = PrependMainExecutablePath("llvm-stub", argv[0],
(void *)(intptr_t)&Optimize);
if (llvmstub.isEmpty())
PrintAndExit("Could not find llvm-stub.exe executable!", M);
if (0 != sys::CopyFile(sys::Path(OutputFilename), llvmstub, &ErrMsg))
PrintAndExit(ErrMsg, M);
return;
#endif
// Output the script to start the program...
std::string ErrorInfo;
tool_output_file Out2(OutputFilename.c_str(), ErrorInfo);
if (!ErrorInfo.empty())
PrintAndExit(ErrorInfo, M);
Out2.os() << "#!/bin/sh\n";
// Allow user to setenv LLVMINTERP if lli is not in their PATH.
Out2.os() << "lli=${LLVMINTERP-lli}\n";
Out2.os() << "exec $lli \\\n";
// gcc accepts -l<lib> and implicitly searches /lib and /usr/lib.
LibPaths.push_back("/lib");
LibPaths.push_back("/usr/lib");
LibPaths.push_back("/usr/X11R6/lib");
// We don't need to link in libc! In fact, /usr/lib/libc.so may not be a
// shared object at all! See RH 8: plain text.
std::vector<std::string>::iterator libc =
std::find(Libraries.begin(), Libraries.end(), "c");
if (libc != Libraries.end()) Libraries.erase(libc);
// List all the shared object (native) libraries this executable will need
// on the command line, so that we don't have to do this manually!
for (std::vector<std::string>::iterator i = Libraries.begin(),
e = Libraries.end(); i != e; ++i) {
// try explicit -L arguments first:
sys::Path FullLibraryPath;
for (cl::list<std::string>::const_iterator P = LibPaths.begin(),
E = LibPaths.end(); P != E; ++P) {
FullLibraryPath = *P;
FullLibraryPath.appendComponent("lib" + *i);
FullLibraryPath.appendSuffix(sys::Path::GetDLLSuffix());
if (!FullLibraryPath.isEmpty()) {
if (!FullLibraryPath.isDynamicLibrary()) {
// Not a native shared library; mark as invalid
FullLibraryPath = sys::Path();
} else break;
}
}
if (FullLibraryPath.isEmpty())
FullLibraryPath = sys::Path::FindLibrary(*i);
if (!FullLibraryPath.isEmpty())
Out2.os() << " -load=" << FullLibraryPath.str() << " \\\n";
}
Out2.os() << " " << BitcodeOutputFilename << " ${1+\"$@\"}\n";
Out2.keep();
}
int main(int argc, char **argv) {
llvm::sys::PrintStackTraceOnErrorSignal();
llvm::PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeIPA(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeInstrumentation(Registry);
initializeTarget(Registry);
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
sys::SetInterruptFunction(BugpointInterruptFunction);
LLVMContext& Context = getGlobalContext();
// If we have an override, set it and then track the triple we want Modules
// to use.
if (!OverrideTriple.empty()) {
TargetTriple.setTriple(Triple::normalize(OverrideTriple));
outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
}
if (MemoryLimit < 0) {
// Set the default MemoryLimit. Be sure to update the flag's description if
// you change this.
if (sys::RunningOnValgrind() || UseValgrind)
MemoryLimit = 800;
else
MemoryLimit = 100;
}
BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
UseValgrind, Context);
if (D.addSources(InputFilenames)) return 1;
AddToDriver PM(D);
if (StandardCompileOpts) {
createStandardModulePasses(&PM, 3,
/*OptimizeSize=*/ false,
/*UnitAtATime=*/ true,
/*UnrollLoops=*/ true,
/*SimplifyLibCalls=*/ true,
/*HaveExceptions=*/ true,
createFunctionInliningPass());
}
if (StandardLinkOpts)
createStandardLTOPasses(&PM, /*Internalize=*/true,
/*RunInliner=*/true,
/*VerifyEach=*/false);
for (std::vector<const PassInfo*>::iterator I = PassList.begin(),
E = PassList.end();
I != E; ++I) {
const PassInfo* PI = *I;
D.addPass(PI->getPassArgument());
}
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
sys::Process::PreventCoreFiles();
std::string Error;
bool Failure = D.run(Error);
if (!Error.empty()) {
errs() << Error;
return 1;
}
return Failure;
}
/// ReadCheckFile - Read the check file, which specifies the sequence of
/// expected strings. The strings are added to the CheckStrings vector.
/// Returns true in case of an error, false otherwise.
static bool ReadCheckFile(SourceMgr &SM,
std::vector<CheckString> &CheckStrings) {
ErrorOr<std::unique_ptr<MemoryBuffer>> FileOrErr =
MemoryBuffer::getFileOrSTDIN(CheckFilename);
if (std::error_code EC = FileOrErr.getError()) {
errs() << "Could not open check file '" << CheckFilename
<< "': " << EC.message() << '\n';
return true;
}
// If we want to canonicalize whitespace, strip excess whitespace from the
// buffer containing the CHECK lines. Remove DOS style line endings.
std::unique_ptr<MemoryBuffer> F = CanonicalizeInputFile(
std::move(FileOrErr.get()), NoCanonicalizeWhiteSpace);
// Find all instances of CheckPrefix followed by : in the file.
StringRef Buffer = F->getBuffer();
SM.AddNewSourceBuffer(std::move(F), SMLoc());
std::vector<Pattern> ImplicitNegativeChecks;
for (const auto &PatternString : ImplicitCheckNot) {
// Create a buffer with fake command line content in order to display the
// command line option responsible for the specific implicit CHECK-NOT.
std::string Prefix = std::string("-") + ImplicitCheckNot.ArgStr + "='";
std::string Suffix = "'";
std::unique_ptr<MemoryBuffer> CmdLine = MemoryBuffer::getMemBufferCopy(
Prefix + PatternString + Suffix, "command line");
StringRef PatternInBuffer =
CmdLine->getBuffer().substr(Prefix.size(), PatternString.size());
SM.AddNewSourceBuffer(std::move(CmdLine), SMLoc());
ImplicitNegativeChecks.push_back(Pattern(Check::CheckNot));
ImplicitNegativeChecks.back().ParsePattern(PatternInBuffer,
"IMPLICIT-CHECK", SM, 0);
}
std::vector<Pattern> DagNotMatches = ImplicitNegativeChecks;
// LineNumber keeps track of the line on which CheckPrefix instances are
// found.
unsigned LineNumber = 1;
while (1) {
Check::CheckType CheckTy;
size_t PrefixLoc;
// See if a prefix occurs in the memory buffer.
StringRef UsedPrefix = FindFirstMatchingPrefix(Buffer,
LineNumber,
CheckTy,
PrefixLoc);
if (UsedPrefix.empty())
break;
Buffer = Buffer.drop_front(PrefixLoc);
// Location to use for error messages.
const char *UsedPrefixStart = Buffer.data() + (PrefixLoc == 0 ? 0 : 1);
// PrefixLoc is to the start of the prefix. Skip to the end.
Buffer = Buffer.drop_front(UsedPrefix.size() + CheckTypeSize(CheckTy));
// Okay, we found the prefix, yay. Remember the rest of the line, but ignore
// leading and trailing whitespace.
Buffer = Buffer.substr(Buffer.find_first_not_of(" \t"));
// Scan ahead to the end of line.
size_t EOL = Buffer.find_first_of("\n\r");
// Remember the location of the start of the pattern, for diagnostics.
SMLoc PatternLoc = SMLoc::getFromPointer(Buffer.data());
// Parse the pattern.
Pattern P(CheckTy);
if (P.ParsePattern(Buffer.substr(0, EOL), UsedPrefix, SM, LineNumber))
return true;
// Verify that CHECK-LABEL lines do not define or use variables
if ((CheckTy == Check::CheckLabel) && P.hasVariable()) {
SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
SourceMgr::DK_Error,
"found '" + UsedPrefix + "-LABEL:'"
" with variable definition or use");
return true;
}
Buffer = Buffer.substr(EOL);
// Verify that CHECK-NEXT lines have at least one CHECK line before them.
if ((CheckTy == Check::CheckNext || CheckTy == Check::CheckSame) &&
CheckStrings.empty()) {
StringRef Type = CheckTy == Check::CheckNext ? "NEXT" : "SAME";
SM.PrintMessage(SMLoc::getFromPointer(UsedPrefixStart),
SourceMgr::DK_Error,
"found '" + UsedPrefix + "-" + Type + "' without previous '"
+ UsedPrefix + ": line");
return true;
}
// Handle CHECK-DAG/-NOT.
if (CheckTy == Check::CheckDAG || CheckTy == Check::CheckNot) {
DagNotMatches.push_back(P);
continue;
}
// Okay, add the string we captured to the output vector and move on.
CheckStrings.emplace_back(P, UsedPrefix, PatternLoc, CheckTy);
std::swap(DagNotMatches, CheckStrings.back().DagNotStrings);
DagNotMatches = ImplicitNegativeChecks;
}
// Add an EOF pattern for any trailing CHECK-DAG/-NOTs, and use the first
// prefix as a filler for the error message.
if (!DagNotMatches.empty()) {
CheckStrings.emplace_back(Pattern(Check::CheckEOF), *CheckPrefixes.begin(),
SMLoc::getFromPointer(Buffer.data()),
Check::CheckEOF);
std::swap(DagNotMatches, CheckStrings.back().DagNotStrings);
}
if (CheckStrings.empty()) {
errs() << "error: no check strings found with prefix"
<< (CheckPrefixes.size() > 1 ? "es " : " ");
prefix_iterator I = CheckPrefixes.begin();
prefix_iterator E = CheckPrefixes.end();
if (I != E) {
errs() << "\'" << *I << ":'";
++I;
}
for (; I != E; ++I)
errs() << ", \'" << *I << ":'";
errs() << '\n';
return true;
}
return false;
}
int main(int argc, char **argv, char **envp) {
// Print a stack trace if we signal out.
sys::PrintStackTraceOnErrorSignal();
PrettyStackTraceProgram X(argc, argv);
LLVMContext &Context = getGlobalContext();
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeIPA(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeTarget(Registry);
// Initial global variable above for convenience printing of program name.
progname = sys::path::stem(argv[0]);
// Parse the command line options
cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
#if defined(_WIN32) || defined(__CYGWIN__)
if (!LinkAsLibrary) {
// Default to "a.exe" instead of "a.out".
if (OutputFilename.getNumOccurrences() == 0)
OutputFilename = "a.exe";
// If there is no suffix add an "exe" one.
if (sys::path::extension(OutputFilename).empty())
OutputFilename.append(".exe");
}
#endif
// Generate the bitcode for the optimized module.
// If -b wasn't specified, use the name specified
// with -o to construct BitcodeOutputFilename.
if (BitcodeOutputFilename.empty()) {
BitcodeOutputFilename = OutputFilename;
if (!LinkAsLibrary) BitcodeOutputFilename += ".bc";
}
// Arrange for the bitcode output file to be deleted on any errors.
BitcodeOutputRemover.setFile(BitcodeOutputFilename);
sys::RemoveFileOnSignal(sys::Path(BitcodeOutputFilename));
// Arrange for the output file to be deleted on any errors.
if (!LinkAsLibrary) {
OutputRemover.setFile(OutputFilename);
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
}
// Construct a Linker (now that Verbose is set)
Linker TheLinker(progname, OutputFilename, Context, Verbose);
// Keep track of the native link items (versus the bitcode items)
Linker::ItemList NativeLinkItems;
// Add library paths to the linker
TheLinker.addPaths(LibPaths);
TheLinker.addSystemPaths();
// Remove any consecutive duplicates of the same library...
Libraries.erase(std::unique(Libraries.begin(), Libraries.end()),
Libraries.end());
if (LinkAsLibrary) {
std::vector<sys::Path> Files;
for (unsigned i = 0; i < InputFilenames.size(); ++i )
Files.push_back(sys::Path(InputFilenames[i]));
if (TheLinker.LinkInFiles(Files))
return 1; // Error already printed
// The libraries aren't linked in but are noted as "dependent" in the
// module.
for (cl::list<std::string>::const_iterator I = Libraries.begin(),
E = Libraries.end(); I != E ; ++I) {
TheLinker.getModule()->addLibrary(*I);
}
} else {
// Build a list of the items from our command line
Linker::ItemList Items;
BuildLinkItems(Items, InputFilenames, Libraries);
// Link all the items together
if (TheLinker.LinkInItems(Items, NativeLinkItems) )
return 1; // Error already printed
}
std::auto_ptr<Module> Composite(TheLinker.releaseModule());
// Optimize the module
Optimize(Composite.get());
// Generate the bitcode output.
GenerateBitcode(Composite.get(), BitcodeOutputFilename);
// If we are not linking a library, generate either a native executable
// or a JIT shell script, depending upon what the user wants.
if (!LinkAsLibrary) {
// If the user wants to run a post-link optimization, run it now.
if (!PostLinkOpts.empty()) {
std::vector<std::string> opts = PostLinkOpts;
for (std::vector<std::string>::iterator I = opts.begin(),
E = opts.end(); I != E; ++I) {
sys::Path prog(*I);
if (!prog.canExecute()) {
prog = sys::Program::FindProgramByName(*I);
if (prog.isEmpty())
PrintAndExit(std::string("Optimization program '") + *I +
"' is not found or not executable.", Composite.get());
}
// Get the program arguments
sys::Path tmp_output("opt_result");
std::string ErrMsg;
if (tmp_output.createTemporaryFileOnDisk(true, &ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
const char* args[4];
args[0] = I->c_str();
args[1] = BitcodeOutputFilename.c_str();
args[2] = tmp_output.c_str();
args[3] = 0;
if (0 == sys::Program::ExecuteAndWait(prog, args, 0,0,0,0, &ErrMsg)) {
if (tmp_output.isBitcodeFile()) {
sys::Path target(BitcodeOutputFilename);
target.eraseFromDisk();
if (tmp_output.renamePathOnDisk(target, &ErrMsg))
PrintAndExit(ErrMsg, Composite.get(), 2);
} else
PrintAndExit("Post-link optimization output is not bitcode",
Composite.get());
} else {
PrintAndExit(ErrMsg, Composite.get());
}
}
}
// If the user wants to generate a native executable, compile it from the
// bitcode file.
//
// Otherwise, create a script that will run the bitcode through the JIT.
if (Native) {
// Name of the Assembly Language output file
sys::Path AssemblyFile ( OutputFilename);
AssemblyFile.appendSuffix("s");
// Mark the output files for removal.
FileRemover AssemblyFileRemover(AssemblyFile.str());
sys::RemoveFileOnSignal(AssemblyFile);
// Determine the locations of the llc and gcc programs.
sys::Path llc = PrependMainExecutablePath("llc", argv[0],
(void *)(intptr_t)&Optimize);
if (llc.isEmpty())
PrintAndExit("Failed to find llc", Composite.get());
sys::Path gcc = sys::Program::FindProgramByName("gcc");
if (gcc.isEmpty())
PrintAndExit("Failed to find gcc", Composite.get());
// Generate an assembly language file for the bitcode.
std::string ErrMsg;
if (0 != GenerateAssembly(AssemblyFile.str(), BitcodeOutputFilename,
llc, ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
if (0 != GenerateNative(OutputFilename, AssemblyFile.str(),
NativeLinkItems, gcc, envp, ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
} else if (NativeCBE) {
sys::Path CFile (OutputFilename);
CFile.appendSuffix("cbe.c");
// Mark the output files for removal.
FileRemover CFileRemover(CFile.str());
sys::RemoveFileOnSignal(CFile);
// Determine the locations of the llc and gcc programs.
sys::Path llc = PrependMainExecutablePath("llc", argv[0],
(void *)(intptr_t)&Optimize);
if (llc.isEmpty())
PrintAndExit("Failed to find llc", Composite.get());
sys::Path gcc = sys::Program::FindProgramByName("gcc");
if (gcc.isEmpty())
PrintAndExit("Failed to find gcc", Composite.get());
// Generate an assembly language file for the bitcode.
std::string ErrMsg;
if (GenerateCFile(CFile.str(), BitcodeOutputFilename, llc, ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
if (GenerateNative(OutputFilename, CFile.str(),
NativeLinkItems, gcc, envp, ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
} else {
EmitShellScript(argv, Composite.get());
}
// Make the script executable...
std::string ErrMsg;
if (sys::Path(OutputFilename).makeExecutableOnDisk(&ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
// Make the bitcode file readable and directly executable in LLEE as well
if (sys::Path(BitcodeOutputFilename).makeExecutableOnDisk(&ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
if (sys::Path(BitcodeOutputFilename).makeReadableOnDisk(&ErrMsg))
PrintAndExit(ErrMsg, Composite.get());
}
// Operations which may fail are now complete.
BitcodeOutputRemover.releaseFile();
if (!LinkAsLibrary)
OutputRemover.releaseFile();
// Graceful exit
return 0;
}
int main(int argc, char **argv) {
#ifndef DEBUG_BUGPOINT
llvm::sys::PrintStackTraceOnErrorSignal();
llvm::PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
#endif
// Initialize passes
PassRegistry &Registry = *PassRegistry::getPassRegistry();
initializeCore(Registry);
initializeScalarOpts(Registry);
initializeObjCARCOpts(Registry);
initializeVectorization(Registry);
initializeIPO(Registry);
initializeAnalysis(Registry);
initializeIPA(Registry);
initializeTransformUtils(Registry);
initializeInstCombine(Registry);
initializeInstrumentation(Registry);
initializeTarget(Registry);
#ifdef LINK_POLLY_INTO_TOOLS
polly::initializePollyPasses(Registry);
#endif
// @LOCALMOD-BEGIN
initializeAddPNaClExternalDeclsPass(Registry);
initializeAllocateDataSegmentPass(Registry);
initializeBackendCanonicalizePass(Registry);
initializeCanonicalizeMemIntrinsicsPass(Registry);
initializeCleanupUsedGlobalsMetadataPass(Registry);
initializeConstantInsertExtractElementIndexPass(Registry);
initializeExpandAllocasPass(Registry);
initializeExpandArithWithOverflowPass(Registry);
initializeExpandByValPass(Registry);
initializeExpandConstantExprPass(Registry);
initializeExpandCtorsPass(Registry);
initializeExpandGetElementPtrPass(Registry);
initializeExpandIndirectBrPass(Registry);
initializeExpandLargeIntegersPass(Registry);
initializeExpandShuffleVectorPass(Registry);
initializeExpandSmallArgumentsPass(Registry);
initializeExpandStructRegsPass(Registry);
initializeExpandTlsConstantExprPass(Registry);
initializeExpandTlsPass(Registry);
initializeExpandVarArgsPass(Registry);
initializeFixVectorLoadStoreAlignmentPass(Registry);
initializeFlattenGlobalsPass(Registry);
initializeGlobalCleanupPass(Registry);
initializeGlobalizeConstantVectorsPass(Registry);
initializeInsertDivideCheckPass(Registry);
initializeInternalizeUsedGlobalsPass(Registry);
initializeNormalizeAlignmentPass(Registry);
initializePNaClABIVerifyFunctionsPass(Registry);
initializePNaClABIVerifyModulePass(Registry);
initializePNaClSjLjEHPass(Registry);
initializePromoteI1OpsPass(Registry);
initializePromoteIntegersPass(Registry);
initializeRemoveAsmMemoryPass(Registry);
initializeRenameEntryPointPass(Registry);
initializeReplacePtrsWithIntsPass(Registry);
initializeResolveAliasesPass(Registry);
initializeResolvePNaClIntrinsicsPass(Registry);
initializeRewriteAtomicsPass(Registry);
initializeRewriteLLVMIntrinsicsPass(Registry);
initializeRewritePNaClLibraryCallsPass(Registry);
initializeSandboxIndirectCallsPass(Registry);
initializeSandboxMemoryAccessesPass(Registry);
initializeSimplifyAllocasPass(Registry);
initializeSimplifyStructRegSignaturesPass(Registry);
initializeStripAttributesPass(Registry);
initializeStripMetadataPass(Registry);
initializeStripModuleFlagsPass(Registry);
initializeStripTlsPass(Registry);
initializeSubstituteUndefsPass(Registry);
// Emscripten passes:
initializeExpandI64Pass(Registry);
initializeExpandInsertExtractElementPass(Registry);
initializeLowerEmAsyncifyPass(Registry);
initializeLowerEmExceptionsPass(Registry);
initializeLowerEmSetjmpPass(Registry);
initializeNoExitRuntimePass(Registry);
// Emscripten passes end.
// @LOCALMOD-END
cl::ParseCommandLineOptions(argc, argv,
"LLVM automatic testcase reducer. See\nhttp://"
"llvm.org/cmds/bugpoint.html"
" for more information.\n");
#ifndef DEBUG_BUGPOINT
sys::SetInterruptFunction(BugpointInterruptFunction);
#endif
LLVMContext& Context = getGlobalContext();
// If we have an override, set it and then track the triple we want Modules
// to use.
if (!OverrideTriple.empty()) {
TargetTriple.setTriple(Triple::normalize(OverrideTriple));
outs() << "Override triple set to '" << TargetTriple.getTriple() << "'\n";
}
if (MemoryLimit < 0) {
// Set the default MemoryLimit. Be sure to update the flag's description if
// you change this.
if (sys::RunningOnValgrind() || UseValgrind)
MemoryLimit = 800;
else
MemoryLimit = 300;
}
BugDriver D(argv[0], FindBugs, TimeoutValue, MemoryLimit,
UseValgrind, Context);
if (D.addSources(InputFilenames)) return 1;
AddToDriver PM(D);
if (StandardLinkOpts) {
PassManagerBuilder Builder;
Builder.Inliner = createFunctionInliningPass();
Builder.populateLTOPassManager(PM);
}
if (OptLevelO1 || OptLevelO2 || OptLevelO3) {
PassManagerBuilder Builder;
if (OptLevelO1)
Builder.Inliner = createAlwaysInlinerPass();
else if (OptLevelO2)
Builder.Inliner = createFunctionInliningPass(225);
else
Builder.Inliner = createFunctionInliningPass(275);
// Note that although clang/llvm-gcc use two separate passmanagers
// here, it shouldn't normally make a difference.
Builder.populateFunctionPassManager(PM);
Builder.populateModulePassManager(PM);
}
for (std::vector<const PassInfo*>::iterator I = PassList.begin(),
E = PassList.end();
I != E; ++I) {
const PassInfo* PI = *I;
D.addPass(PI->getPassArgument());
}
// Bugpoint has the ability of generating a plethora of core files, so to
// avoid filling up the disk, we prevent it
#ifndef DEBUG_BUGPOINT
sys::Process::PreventCoreFiles();
#endif
std::string Error;
bool Failure = D.run(Error);
if (!Error.empty()) {
errs() << Error;
return 1;
}
return Failure;
}
virtual bool
runOnModule(Module& M)
{
AliasAnalysis& aa = this->getAnalysis<AliasAnalysis>();
bool checked = false;
errs() << "GatherInterfacePass::runOnModule: " << M.getModuleIdentifier() << "\n";
if (!GatherInterfaceMain.empty()) {
checked = true;
for (cl::list<std::string>::const_iterator i = GatherInterfaceMain.begin(), e = GatherInterfaceMain.end();
i != e; ++i) {
Function* f = M.getFunction(*i);
if (f == NULL) {
errs() << "Function '" << *i << "' not found, skipping\n";
continue;
}
if (f->isDeclaration()) {
errs() << "Function '" << *i << "' is declaration, skipping\n";
continue;
}
errs() << "Gathering from: " << *f << "\n";
GatherInterface(*f, this->interface, &aa);
}
}
if (!GatherInterfaceEntry.empty()) {
checked = true;
ComponentInterface ci;
for (cl::list<std::string>::const_iterator i = GatherInterfaceEntry.begin(), e = GatherInterfaceEntry.end();
i != e; ++i) {
errs() << "Reading interface from '" << *i << "'...";
if (ci.readFromFile(*i)) {
errs() << "success\n";
} else {
errs() << "failed\n";
continue;
}
}
for (ComponentInterface::FunctionIterator i = ci.begin(), e = ci.end(); i != e; ++i) {
Function* f = M.getFunction(i->first());
if (f == NULL) continue;
if (!GatherInterface(*f, this->interface, &aa)) break;
}
}
if (!checked) {
GatherInterface(M, this->interface, &aa);
}
if (GatherInterfaceOutput != "") {
proto::ComponentInterface ci;
codeInto<ComponentInterface, proto::ComponentInterface> (
this->interface, ci);
std::ofstream output(GatherInterfaceOutput.c_str(), std::ios::binary);
assert(ci.SerializeToOstream(&output));
output.close();
}
return false;
}
bool LowerEmAsyncify::runOnModule(Module &M) {
TheModule = &M;
DL = &M.getDataLayout();
std::set<std::string> WhiteList(AsyncifyWhiteList.begin(), AsyncifyWhiteList.end());
/*
* collect all the functions that should be asyncified
* any function that _might_ call an async function is also async
*/
std::vector<Function*> AsyncFunctionsPending;
for(unsigned i = 0; i < AsyncifyFunctions.size(); ++i) {
std::string const& AFName = AsyncifyFunctions[i];
Function *F = TheModule->getFunction(AFName);
if (F && !WhiteList.count(F->getName())) {
AsyncFunctionsPending.push_back(F);
}
}
// No function needed to transform
if (AsyncFunctionsPending.empty()) return false;
// Walk through the call graph and find all the async functions
FunctionInstructionsMap AsyncFunctionCalls;
{
// pessimistic: consider all indirect calls as possibly async
// TODO: deduce based on function types
for (Module::iterator FI = TheModule->begin(), FE = TheModule->end(); FI != FE; ++FI) {
if (WhiteList.count(FI->getName())) continue;
bool has_indirect_call = false;
for (inst_iterator I = inst_begin(FI), E = inst_end(FI); I != E; ++I) {
if (IsFunctionPointerCall(&*I)) {
has_indirect_call = true;
AsyncFunctionCalls[FI].push_back(&*I);
}
}
if (has_indirect_call) AsyncFunctionsPending.push_back(FI);
}
while (!AsyncFunctionsPending.empty()) {
Function *CurFunction = AsyncFunctionsPending.back();
AsyncFunctionsPending.pop_back();
for (Value::user_iterator UI = CurFunction->user_begin(), E = CurFunction->user_end(); UI != E; ++UI) {
ImmutableCallSite ICS(*UI);
if (!ICS) continue;
// we only need those instructions calling the function
// if the function address is used for other purpose, we don't care
if (CurFunction != ICS.getCalledValue()->stripPointerCasts()) continue;
// Now I is either CallInst or InvokeInst
Instruction *I = cast<Instruction>(*UI);
Function *F = I->getParent()->getParent();
if (AsyncFunctionCalls.count(F) == 0) {
AsyncFunctionsPending.push_back(F);
}
AsyncFunctionCalls[F].push_back(I);
}
}
}
// exit if no async function is found at all
if (AsyncFunctionCalls.empty()) return false;
initTypesAndFunctions();
for (FunctionInstructionsMap::iterator I = AsyncFunctionCalls.begin(), E = AsyncFunctionCalls.end();
I != E; ++I) {
transformAsyncFunction(*(I->first), I->second);
}
return true;
}
int main(int argc, char **argv, char **envp) {
llvm_shutdown_obj X; // Call llvm_shutdown() on exit.
try {
// Initial global variable above for convenience printing of program name.
progname = sys::Path(argv[0]).getBasename();
// Parse the command line options
cl::ParseCommandLineOptions(argc, argv, " llvm linker\n");
sys::PrintStackTraceOnErrorSignal();
// Construct a Linker (now that Verbose is set)
Linker TheLinker(progname, OutputFilename, Verbose);
// Keep track of the native link items (versus the bytecode items)
Linker::ItemList NativeLinkItems;
// Add library paths to the linker
TheLinker.addPaths(LibPaths);
TheLinker.addSystemPaths();
// Remove any consecutive duplicates of the same library...
Libraries.erase(std::unique(Libraries.begin(), Libraries.end()),
Libraries.end());
if (LinkAsLibrary) {
std::vector<sys::Path> Files;
for (unsigned i = 0; i < InputFilenames.size(); ++i )
Files.push_back(sys::Path(InputFilenames[i]));
if (TheLinker.LinkInFiles(Files))
return 1; // Error already printed
// The libraries aren't linked in but are noted as "dependent" in the
// module.
for (cl::list<std::string>::const_iterator I = Libraries.begin(),
E = Libraries.end(); I != E ; ++I) {
TheLinker.getModule()->addLibrary(*I);
}
} else {
// Build a list of the items from our command line
Linker::ItemList Items;
BuildLinkItems(Items, InputFilenames, Libraries);
// Link all the items together
if (TheLinker.LinkInItems(Items, NativeLinkItems) )
return 1; // Error already printed
}
std::auto_ptr<Module> Composite(TheLinker.releaseModule());
// Optimize the module
Optimize(Composite.get());
// Generate the bytecode for the optimized module.
std::string RealBytecodeOutput = OutputFilename;
if (!LinkAsLibrary) RealBytecodeOutput += ".bc";
GenerateBytecode(Composite.get(), RealBytecodeOutput);
// If we are not linking a library, generate either a native executable
// or a JIT shell script, depending upon what the user wants.
if (!LinkAsLibrary) {
// If the user wants to run a post-link optimization, run it now.
if (!PostLinkOpts.empty()) {
std::vector<std::string> opts = PostLinkOpts;
for (std::vector<std::string>::iterator I = opts.begin(),
E = opts.end(); I != E; ++I) {
sys::Path prog(*I);
if (!prog.canExecute()) {
prog = sys::Program::FindProgramByName(*I);
if (prog.isEmpty())
PrintAndExit(std::string("Optimization program '") + *I +
"' is not found or not executable.");
}
// Get the program arguments
sys::Path tmp_output("opt_result");
std::string ErrMsg;
if (tmp_output.createTemporaryFileOnDisk(true, &ErrMsg))
PrintAndExit(ErrMsg);
const char* args[4];
args[0] = I->c_str();
args[1] = RealBytecodeOutput.c_str();
args[2] = tmp_output.c_str();
args[3] = 0;
if (0 == sys::Program::ExecuteAndWait(prog, args, 0,0,0,0, &ErrMsg)) {
if (tmp_output.isBytecodeFile() || tmp_output.isBitcodeFile()) {
sys::Path target(RealBytecodeOutput);
target.eraseFromDisk();
if (tmp_output.renamePathOnDisk(target, &ErrMsg))
PrintAndExit(ErrMsg, 2);
} else
PrintAndExit("Post-link optimization output is not bytecode");
} else {
PrintAndExit(ErrMsg);
}
}
}
// If the user wants to generate a native executable, compile it from the
// bytecode file.
//
// Otherwise, create a script that will run the bytecode through the JIT.
if (Native) {
// Name of the Assembly Language output file
sys::Path AssemblyFile ( OutputFilename);
AssemblyFile.appendSuffix("s");
// Mark the output files for removal if we get an interrupt.
sys::RemoveFileOnSignal(AssemblyFile);
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
// Determine the locations of the llc and gcc programs.
sys::Path llc = FindExecutable("llc", argv[0]);
if (llc.isEmpty())
PrintAndExit("Failed to find llc");
sys::Path gcc = FindExecutable("gcc", argv[0]);
if (gcc.isEmpty())
PrintAndExit("Failed to find gcc");
// Generate an assembly language file for the bytecode.
std::string ErrMsg;
if (0 != GenerateAssembly(AssemblyFile.toString(), RealBytecodeOutput,
llc, ErrMsg))
PrintAndExit(ErrMsg);
if (0 != GenerateNative(OutputFilename, AssemblyFile.toString(),
NativeLinkItems, gcc, envp, ErrMsg))
PrintAndExit(ErrMsg);
// Remove the assembly language file.
AssemblyFile.eraseFromDisk();
} else if (NativeCBE) {
sys::Path CFile (OutputFilename);
CFile.appendSuffix("cbe.c");
// Mark the output files for removal if we get an interrupt.
sys::RemoveFileOnSignal(CFile);
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
// Determine the locations of the llc and gcc programs.
sys::Path llc = FindExecutable("llc", argv[0]);
if (llc.isEmpty())
PrintAndExit("Failed to find llc");
sys::Path gcc = FindExecutable("gcc", argv[0]);
if (gcc.isEmpty())
PrintAndExit("Failed to find gcc");
// Generate an assembly language file for the bytecode.
std::string ErrMsg;
if (0 != GenerateCFile(
CFile.toString(), RealBytecodeOutput, llc, ErrMsg))
PrintAndExit(ErrMsg);
if (0 != GenerateNative(OutputFilename, CFile.toString(),
NativeLinkItems, gcc, envp, ErrMsg))
PrintAndExit(ErrMsg);
// Remove the assembly language file.
CFile.eraseFromDisk();
} else {
EmitShellScript(argv);
}
// Make the script executable...
std::string ErrMsg;
if (sys::Path(OutputFilename).makeExecutableOnDisk(&ErrMsg))
PrintAndExit(ErrMsg);
// Make the bytecode file readable and directly executable in LLEE as well
if (sys::Path(RealBytecodeOutput).makeExecutableOnDisk(&ErrMsg))
PrintAndExit(ErrMsg);
if (sys::Path(RealBytecodeOutput).makeReadableOnDisk(&ErrMsg))
PrintAndExit(ErrMsg);
}
} catch (const std::string& msg) {
PrintAndExit(msg,2);
} catch (...) {
PrintAndExit("Unexpected unknown exception occurred.", 2);
}
// Graceful exit
return 0;
}
RewriteComponentPass() :
ModulePass(ID), transform()
{
errs() << "RewriteComponentPass()\n";
for (cl::list<std::string>::const_iterator b = RewriteComponentInput.begin(), e = RewriteComponentInput.end();
b != e; ++b) {
errs() << "Reading file '" << *b << "'...";
if (transform.readTransformFromFile(*b)) {
errs() << "success\n";
} else {
errs() << "failed\n";
}
}
transform.dump();
errs() << "Done reading (" << transform.rewriteCount() << " rewrites)\n";
}