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());
}
// Helper function to handle -of, -od, etc.
static void initFromString(const char*& dest, const cl::opt<std::string>& src) {
dest = 0;
if (src.getNumOccurrences() != 0) {
if (src.empty())
error(Loc(), "Expected argument to '-%s'", src.ArgStr);
dest = mem.xstrdup(src.c_str());
}
}
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());
}
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;
}
// search for a BlockString with a name of "hsa_dwarf_debug", this marks
// the beginning of a group of BlockNumerics which make up the elf container
//
// Input: any directive inside the debug section
// the debug section
// Returns: the directive following the matching BlockString (the beginning of
// the BlockNumerics), or the end directive of the section if no
// matching BlockString is found
//
static void DumpDebugInfoToFile( BrigContainer & c )
{
std::ofstream ofs( (const char*)(DebugInfoFilename.c_str()), std::ofstream::binary );
if ( ! ofs.is_open() || ofs.bad() )
std::cout << "Could not create output debug info file " << DebugInfoFilename << ", not dumping debug info\n";
else {
SRef data = c.debugInfo().payload();
ofs.write(data.begin, data.length());
}
}
bool EnforcingLandmarks::runOnModule(Module &M) {
if (EnforcingLandmarksFile == "") {
const static size_t len = sizeof(DEFAULT_ENFORCING_LANDMARK_FUNCS) /
sizeof(const char *[2]);
for (size_t i = 0; i < len; ++i) {
string func_name = DEFAULT_ENFORCING_LANDMARK_FUNCS[i][0];
string is_blocking = DEFAULT_ENFORCING_LANDMARK_FUNCS[i][1];
insert_enforcing_landmark_func(func_name, is_blocking);
}
} else {
ifstream fin(EnforcingLandmarksFile.c_str());
string func_name, is_blocking;
while (fin >> func_name >> is_blocking)
insert_enforcing_landmark_func(func_name, is_blocking);
}
// Mark any function call to landmark functions as enforcing landmarks.
for (Module::iterator f = M.begin(); f != M.end(); ++f) {
if (f->getName() == "MyMalloc")
continue;
if (f->getName() == "MyFree")
continue;
if (f->getName() == "MyFreeNow")
continue;
if (f->getName() == "maketree")
continue;
for (Function::iterator bb = f->begin(); bb != f->end(); ++bb) {
for (BasicBlock::iterator ins = bb->begin(); ins != bb->end(); ++ins) {
CallSite cs(ins);
if (cs.getInstruction()) {
if (Function *callee = cs.getCalledFunction()) {
StringRef callee_name = callee->getName();
if (enforcing_landmark_funcs.count(callee_name)) {
if (OnlyMain && callee_name != "pthread_self" &&
f->getName() != "main")
continue;
if (callee_name.startswith("pthread_mutex")
|| callee_name.startswith("pthread_cond")
|| callee_name.startswith("pthread_barrier")
|| callee_name.startswith("pthread_rwlock")
|| callee_name.startswith("pthread_spin")) {
if (rand() % 100 < PruningRate)
continue;
}
enforcing_landmarks.insert(ins);
}
}
}
}
}
}
return false;
}
int main(int argc, char **argv) {
cl::ParseCommandLineOptions(argc, argv,
" llvm .bc -> .bc modular optimizer\n");
// Load the input module...
std::auto_ptr<Module> M(ParseBytecodeFile(InputFilename));
if (M.get() == 0) {
cerr << "bytecode didn't read correctly.\n";
return 1;
}
// Figure out what stream we are supposed to write to...
std::ostream *Out = &std::cout; // Default to printing to stdout...
if (OutputFilename != "") {
Out = new std::ofstream(OutputFilename.c_str());
if (!Out->good()) {
cerr << "Error opening " << OutputFilename << "!\n";
return 1;
}
}
//
PassManager Passes;
Passes.add(new DataLayout("embec", M.get()));
//Add passes
Passes.add(createCZeroUninitPtrPass());
/*
Passes.add(createABCPreProcessPass());
Passes.add(createArrayBoundsCheckPass());
Passes.add(createStackSafetyPass());
*/
Passes.add(createEmbeCFreeRemovalPass());
// Now that we have all of the passes ready, run them.
if (Passes.run(*M.get()))
cerr << "Program modified.\n";
(*Out) << M.get();
// WriteToC(M.get(), *Out, false);
return 0;
}
static void readNames(std::set<std::string>& names) {
std::ifstream msf(epaFile.c_str(), std::ifstream::in);
if (!msf.good())
errs() << "Failed to open file: " << epaFile << " (continuing anyway)\n";
while (msf.good()) {
std::string n;
msf >> n;
if (n.size()) {
names.insert(n);
// errs() << "Read " << n << "\n";
}
}
}
int main(int argc, char **argv) {
cl::ParseCommandLineOptions(argc, argv, "LLJVM Backend\n");
std::string err;
MemoryBuffer *buf = MemoryBuffer::getFileOrSTDIN(input, &err);
if(!buf) {
std::cerr << "Unable to open bitcode file: " << err << std::endl;
return 1;
}
Module *mod = ParseBitcodeFile(buf, getGlobalContext(), &err);
if(!mod) {
std::cerr << "Unable to parse bitcode file: " << err << std::endl;
return 1;
}
llvm::raw_fd_ostream *trace_stream(0);
if (!tracefile.empty()) {
if (debugLevel < 3) {
std::cerr << "May only specify a trace file if generating -g3 debugging information" << std::endl;
return 1;
}
err = "";
trace_stream = new llvm::raw_fd_ostream(tracefile.c_str(), err);
if (!err.empty()) {
std::cerr << "Unable to open tracefile " << tracefile << " : " << err << std::endl;
return 1;
}
}
PassManager pm;
TargetData td("e-p:32:32:32"
"-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64"
"-f32:32:32-f64:64:64");
pm.add(new TargetData(td));
pm.add(createVerifierPass());
pm.add(createGCLoweringPass());
// TODO: fix switch generation so the following pass is not needed
pm.add(createLowerSwitchPass());
pm.add(createIndVarSimplifyPass());
pm.add(createPromoteMemoryToRegisterPass()); //good
pm.add(createDeadStoreEliminationPass());
pm.add(createAggressiveDCEPass());
pm.add(createCFGSimplificationPass());
pm.add(new JVMWriter(&td, fouts(), classname
, sourcename, debugLevel, trace_stream));
pm.add(createGCInfoDeleter());
pm.run(*mod);
return 0;
}
int main(int argc, char * argv[]) {
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
LLVMContext &Context = getGlobalContext();
cl::ParseCommandLineOptions(argc, argv, "Anteater compiler\n");
SMDiagnostic Err;
// Load the input module...
std::auto_ptr<Module> M;
M.reset(ParseIRFile(InputFilename, Err, Context));
if (M.get() == 0) {
Err.Print(argv[0], errs());
return 1;
}
// Figure out what stream we are supposed to write to...
// FIXME: outs() is not binary!
raw_ostream *Out = &outs(); // Default to printing to stdout...
if (OutputFilename != "-") {
std::string ErrorInfo;
Out = new raw_fd_ostream(OutputFilename.c_str(), ErrorInfo,
raw_fd_ostream::F_Binary);
if (!ErrorInfo.empty()) {
errs() << ErrorInfo << '\n';
delete Out;
return 1;
}
}
PassManager Passes;
if (Backend == "yices") {
Passes.add(anteater::createXorEliminationPass(&Context));
Passes.add(anteater::createAnteaterInstructionNamerPass());
Passes.add(anteater::createYicesWriter(Out));
} else {
Passes.add(anteater::createAnteaterInstructionNamerPass());
Passes.add(anteater::createSMT12Writer(Out));
}
Passes.run(*M.get());
// Delete the raw_fd_ostream.
if (Out != &outs())
delete Out;
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 coverage tool\n");
std::string ErrorInfo;
raw_fd_ostream OS(OutputFile.c_str(), ErrorInfo);
if (!ErrorInfo.empty())
errs() << ErrorInfo << "\n";
GCOVFile GF;
if (InputGCNO.empty())
errs() << " " << argv[0] << ": No gcov input file!\n";
OwningPtr<MemoryBuffer> GCNO_Buff;
if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputGCNO, GCNO_Buff)) {
errs() << InputGCNO << ": " << ec.message() << "\n";
return 1;
}
GCOVBuffer GCNO_GB(GCNO_Buff.get());
if (!GF.read(GCNO_GB)) {
errs() << "Invalid .gcno File!\n";
return 1;
}
if (!InputGCDA.empty()) {
OwningPtr<MemoryBuffer> GCDA_Buff;
if (error_code ec = MemoryBuffer::getFileOrSTDIN(InputGCDA, GCDA_Buff)) {
errs() << InputGCDA << ": " << ec.message() << "\n";
return 1;
}
GCOVBuffer GCDA_GB(GCDA_Buff.get());
if (!GF.read(GCDA_GB)) {
errs() << "Invalid .gcda File!\n";
return 1;
}
}
if (DumpGCOV)
GF.dump();
FileInfo FI;
GF.collectLineCounts(FI);
FI.print(OS, InputGCNO, InputGCDA);
return 0;
}
int main(int argc, char ** argv)
{
unsigned char * bytes;
unsigned byte_count;
std::auto_ptr<Module> M;
LLVMContext &Context = getGlobalContext();
SMDiagnostic Err;
cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
M.reset(ParseIRFile(InputFilename, Err, Context));
Module * mod = M.get();
radeon_llvm_compile(wrap(mod), &bytes, &byte_count, TargetGPUName.c_str(), 1);
}
bool PointToDrawer::runOnModule(Module &M) {
PointerAnalysis &PA = getAnalysis<PointerAnalysis>();
if (DotFileName != "") {
string ErrorInfo;
raw_fd_ostream DotFile(DotFileName.c_str(), ErrorInfo);
printToDot(DotFile);
}
if (ShouldPrintStat) {
PA.printStats(errs());
}
return false;
}
void DisassembleOneInput(const uint8_t *Data, size_t Size) {
char AssemblyText[AssemblyTextBufSize];
std::vector<uint8_t> DataCopy(Data, Data + Size);
LLVMDisasmContextRef Ctx = LLVMCreateDisasmCPUFeatures(
TripleName.c_str(), MCPU.c_str(), FeaturesStr.c_str(), nullptr, 0,
nullptr, nullptr);
assert(Ctx);
uint8_t *p = DataCopy.data();
unsigned Consumed;
unsigned InstructionsProcessed = 0;
do {
Consumed = LLVMDisasmInstruction(Ctx, p, Size, 0, AssemblyText,
AssemblyTextBufSize);
Size -= Consumed;
p += Consumed;
InstructionsProcessed ++;
if (InsnLimit != 0 && InstructionsProcessed < InsnLimit)
break;
} while (Consumed != 0);
LLVMDisasmDispose(Ctx);
}
GCOVOptions GCOVOptions::getDefault() {
GCOVOptions Options;
Options.EmitNotes = true;
Options.EmitData = true;
Options.UseCfgChecksum = false;
Options.NoRedZone = false;
Options.FunctionNamesInData = true;
if (DefaultGCOVVersion.size() != 4) {
llvm::report_fatal_error(std::string("Invalid -default-gcov-version: ") +
DefaultGCOVVersion);
}
memcpy(Options.Version, DefaultGCOVVersion.c_str(), 4);
return Options;
}
static tool_output_file *GetOutputStream() {
if (OutputFilename == "")
OutputFilename = "-";
std::string Err;
tool_output_file *Out = new tool_output_file(OutputFilename.c_str(), Err,
raw_fd_ostream::F_Binary);
if (!Err.empty()) {
errs() << Err << '\n';
delete Out;
return 0;
}
return Out;
}
static tool_output_file *GetOutputStream() {
if (OutputFilename == "")
OutputFilename = "-";
std::string Err;
tool_output_file *Out =
new tool_output_file(OutputFilename.c_str(), Err, sys::fs::F_None);
if (!Err.empty()) {
errs() << Err << '\n';
delete Out;
return nullptr;
}
return Out;
}
static void WriteOutputFile(const Module *M) {
std::string ErrorInfo;
OwningPtr<tool_output_file> Out
(new tool_output_file(OutputFilename.c_str(), ErrorInfo,
raw_fd_ostream::F_Binary));
if (!ErrorInfo.empty()) {
errs() << ErrorInfo << '\n';
exit(1);
}
NaClWriteBitcodeToFile(M, Out->os(), /* AcceptSupportedOnly = */ false);
// Declare success.
Out->keep();
}
void DynamicGiri::printBackwardsSlice(const Instruction *Criterion,
std::set<Value *> &Slice,
std::unordered_set<DynValue> &DynSlice,
std::set<DynValue *> &DataFlowGraph) {
// Print out the dynamic backwards slice.
std::string errinfo;
raw_fd_ostream SliceFile(SliceFilename.c_str(),
errinfo,
sys::fs::F_Append);
if (!errinfo.empty()) {
errs() << "Error opening the slice output file: " << SliceFilename
<< " : " << errinfo << "\n";
return;
}
SliceFile << "----------------------------------------------------------\n";
SliceFile << "Static Slice from instruction: \n";
Criterion->print(SliceFile);
SliceFile << "\n----------------------------------------------------------\n";
for (std::set<Value *>::iterator i = Slice.begin(); i != Slice.end(); ++i) {
Value *V = *i;
V->print(SliceFile);
SliceFile << "\n";
if (Instruction *I = dyn_cast<Instruction>(V))
SliceFile << "Source Line Info: "
<< SourceLineMappingPass::locateSrcInfo(I)
<< "\n";
}
// Print out the instructions in the dynamic backwards slice that
// failed their invariants.
SliceFile << "----------------------------------------------------------\n";
SliceFile << "Dynamic Slice from instruction: \n";
Criterion->print(SliceFile);
SliceFile << "\n----------------------------------------------------------\n";
for (std::unordered_set<DynValue>::iterator i = DynSlice.begin();
i != DynSlice.end();
++i) {
DynValue DV = *i;
DV.print(SliceFile, lsNumPass);
if (Instruction *I = dyn_cast<Instruction>(i->getValue()))
SliceFile << "Source Line Info: "
<< SourceLineMappingPass::locateSrcInfo(I)
<< "\n";
}
SliceFile << "\n";
SliceFile.close();
}
static void WriteOutputFile(const Module *M) {
// Infer the output filename if needed.
if (OutputFilename.empty()) {
if (InputFilename == "-") {
OutputFilename = "-";
} else {
std::string IFN = InputFilename;
int Len = IFN.length();
if (IFN[Len-3] == '.' && IFN[Len-2] == 'l' && IFN[Len-1] == 'l') {
// Source ends in .ll
OutputFilename = std::string(IFN.begin(), IFN.end()-3);
} else {
OutputFilename = IFN; // Append a .bc to it
}
OutputFilename += ".bc";
}
}
std::string ErrorInfo;
OwningPtr<tool_output_file> Out
(new tool_output_file(OutputFilename.c_str(), ErrorInfo,
llvm::sys::fs::F_Binary));
if (!ErrorInfo.empty()) {
errs() << ErrorInfo << '\n';
exit(1);
}
if (Force || !CheckBitcodeOutputToConsole(Out->os(), true)) {
switch(BitcodeVersion) {
case BC29:
llvm_2_9::WriteBitcodeToFile(M, Out->os());
break;
case BC29Func:
llvm_2_9_func::WriteBitcodeToFile(M, Out->os());
break;
case BC32:
llvm_3_2::WriteBitcodeToFile(M, Out->os());
break;
case BCHEAD:
llvm::WriteBitcodeToFile(M, Out->os());
break;
}
}
// Declare success.
Out->keep();
}
/// 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();
}
int main(int argc, char **argv) {
// 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.
cl::ParseCommandLineOptions(argc, argv, "strip function attribute pass\n");
std::string ErrorMessage;
std::unique_ptr<Module> M(LoadFile(argv[0], InputFilenames[0], Context));
if (M.get() == 0) {
errs() << argv[0] << ": error loading file '"
<< InputFilenames[0] << "'\n";
return 1;
}
// Perform the actual function attribute stripping.
legacy::PassManager PM;
PM.add(createStripAttributePass());
PM.run(*M.get());
std::error_code EC;
tool_output_file Out(OutputFilename.c_str(), EC,
sys::fs::F_None);
if (EC) {
errs() << EC.message() << '\n';
return 1;
}
if (verifyModule(*M)) {
errs() << argv[0] << ": stripped module is broken!\n";
return 1;
}
if (OutputAssembly) {
Out.os() << *M;
} else if (!CheckBitcodeOutputToConsole(Out.os(), true)) {
WriteBitcodeToFile(M.get(), Out.os());
}
Out.keep();
return 0;
}
void AliasAnalysisChecker::collectDynamicAliases(
DenseSet<ValuePair> &DynamicAliases) {
DynamicAliases.clear();
if (InputDynamicAliases == "") {
DynamicAliasAnalysis &DAA = getAnalysis<DynamicAliasAnalysis>();
DynamicAliases.insert(DAA.getAllAliases().begin(),
DAA.getAllAliases().end());
} else {
IDAssigner &IDA = getAnalysis<IDAssigner>();
ifstream InputFile(InputDynamicAliases.c_str());
unsigned VID1, VID2;
while (InputFile >> VID1 >> VID2) {
Value *V1 = IDA.getValue(VID1), *V2 = IDA.getValue(VID2);
DynamicAliases.insert(make_pair(V1, V2));
}
}
}
std::map<std::string, int>* FeatureExtractor::getTripCountMap() {
std::map<std::string, int> *trip_count_map = new std::map<std::string, int>;
std::string line;
std::ifstream infile(tripcount_filename.c_str());
while (getline(infile,line)) {
std::string token;
std::istringstream ss(line);
std::vector<std::string> v;
while(std::getline(ss, token, ',')) {
v.push_back(token);
}
if (v.size() == 2) {
std::istringstream buffer(v[1]);
int reuses;
buffer >> reuses;
(*trip_count_map)[v[0]] = reuses;
}
}
static formatted_raw_ostream *GetOutputStream() {
if (OutputFilename == "")
OutputFilename = "-";
// Make sure that the Out file gets unlinked from the disk if we get a
// SIGINT.
if (OutputFilename != "-")
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
std::string Err;
raw_fd_ostream *Out = new raw_fd_ostream(OutputFilename.c_str(), Err,
raw_fd_ostream::F_Binary);
if (!Err.empty()) {
errs() << Err << '\n';
delete Out;
return 0;
}
return new formatted_raw_ostream(*Out, formatted_raw_ostream::DELETE_STREAM);
}
static formatted_raw_ostream *GetOutputStream() {
if (OutputFilename == "" || OutputFilename == "-")
return &fouts();
// Make sure that the Out file gets unlinked from the disk if we get a
// SIGINT
sys::RemoveFileOnSignal(sys::Path(OutputFilename));
std::string Err;
raw_fd_ostream *Out = new raw_fd_ostream(OutputFilename.c_str(),
/*Binary=*/false, Force, Err);
if (!Err.empty()) {
errs() << Err << '\n';
if (!Force)
errs() << "Use -f command line argument to force output\n";
delete Out;
return 0;
}
return new formatted_raw_ostream(*Out, formatted_raw_ostream::DELETE_STREAM);
}
static std::string getProgram(const char *name, const cl::opt<std::string> &opt, const char *envVar = 0)
{
std::string path;
const char *prog = NULL;
if (opt.getNumOccurrences() > 0 && opt.length() > 0 && (prog = opt.c_str()))
path = findProgramByName(prog);
if (path.empty() && envVar && (prog = getenv(envVar)))
path = findProgramByName(prog);
if (path.empty())
path = findProgramByName(name);
if (path.empty()) {
error(Loc(), "failed to locate %s", name);
fatal();
}
return path;
}
std::unique_ptr<FDRPCChannel> connect() {
int sockfd = socket(PF_INET, SOCK_STREAM, 0);
hostent *server = gethostbyname(HostName.c_str());
if (!server) {
errs() << "Could not find host " << HostName << "\n";
exit(1);
}
sockaddr_in servAddr;
bzero(&servAddr, sizeof(servAddr));
servAddr.sin_family = PF_INET;
bcopy(server->h_addr, &servAddr.sin_addr.s_addr, server->h_length);
servAddr.sin_port = htons(Port);
if (connect(sockfd, reinterpret_cast<sockaddr*>(&servAddr),
sizeof(servAddr)) < 0) {
errs() << "Failure to connect.\n";
exit(1);
}
return llvm::make_unique<FDRPCChannel>(sockfd, sockfd);
}
int main(int argc, const char * argv[]) {
cl::ParseCommandLineOptions(argc, argv);
std::ifstream file(filename, std::iostream::binary | std::iostream::ate);
if (!file) {
std::cerr << "Could not open file \"" + filename + "\"" << std::endl;
return EXIT_FAILURE;
}
std::streamsize size = file.tellg();
file.seekg(0, std::ios::beg);
char *code = (char *)malloc(size * sizeof(char));
file.read(code, size);
Options options = (Options) { filename.c_str(), code, optimizationLevel, emitAST, emitIR };
Driver::run(options);
free(code);
return 0;
}
int main(int argc, char **argv) {
// Init LLVM, call llvm_shutdown() on exit, parse args, etc.
llvm::PrettyStackTraceProgram X(argc, argv);
cl::ParseCommandLineOptions(argc, argv, "llvm codegen stress-tester\n");
llvm_shutdown_obj Y;
OwningPtr<Module> M(new Module("/tmp/autogen.bc", getGlobalContext()));
Function *F = GenEmptyFunction(M.get());
// Pick an initial seed value
Random R(SeedCL);
// Generate lots of random instructions inside a single basic block.
FillFunction(F, R);
// Break the basic block into many loops.
IntroduceControlFlow(F, R);
// Figure out what stream we are supposed to write to...
OwningPtr<tool_output_file> Out;
// Default to standard output.
if (OutputFilename.empty())
OutputFilename = "-";
std::string ErrorInfo;
Out.reset(new tool_output_file(OutputFilename.c_str(), ErrorInfo,
sys::fs::F_Binary));
if (!ErrorInfo.empty()) {
errs() << ErrorInfo << '\n';
return 1;
}
PassManager Passes;
Passes.add(createVerifierPass());
Passes.add(createPrintModulePass(Out->os()));
Passes.run(*M.get());
Out->keep();
return 0;
}
