static int ExecuteToolAndWait(llvm::sys::Path tool, std::vector<std::string> args, bool verbose = false) { // Construct real argument list. // First entry is the tool itself, last entry must be NULL. std::vector<const char *> realargs; realargs.reserve(args.size() + 2); realargs.push_back(tool.c_str()); for (std::vector<std::string>::const_iterator it = args.begin(); it != args.end(); ++it) { realargs.push_back((*it).c_str()); } realargs.push_back(NULL); // Print command line if requested if (verbose) { // Print it for (int i = 0; i < realargs.size()-1; i++) printf("%s ", realargs[i]); printf("\n"); fflush(stdout); } // Execute tool. std::string errstr; if (int status = llvm::sys::Program::ExecuteAndWait(tool, &realargs[0], NULL, NULL, 0, 0, &errstr)) { error("%s failed with status: %d", tool.c_str(), status); if (!errstr.empty()) error("message: %s", errstr.c_str()); return status; } return 0; }
bool SerializationTest::Serialize(llvm::sys::Path& Filename, llvm::sys::Path& FNameDeclPrint, ASTContext &Ctx) { { // Pretty-print the decls to a temp file. std::string Err; llvm::raw_fd_ostream DeclPP(FNameDeclPrint.c_str(), true, Err); assert (Err.empty() && "Could not open file for printing out decls."); llvm::OwningPtr<ASTConsumer> FilePrinter(CreateASTPrinter(&DeclPP)); TranslationUnitDecl *TUD = Ctx.getTranslationUnitDecl(); for (DeclContext::decl_iterator I = TUD->decls_begin(Ctx), E = TUD->decls_end(Ctx); I != E; ++I) FilePrinter->HandleTopLevelDecl(DeclGroupRef(*I)); } // Serialize the translation unit. // Reserve 256K for bitstream buffer. std::vector<unsigned char> Buffer; Buffer.reserve(256*1024); Ctx.EmitASTBitcodeBuffer(Buffer); // Write the bits to disk. if (FILE* fp = fopen(Filename.c_str(),"wb")) { fwrite((char*)&Buffer.front(), sizeof(char), Buffer.size(), fp); fclose(fp); return true; } return false; }
int runExecutable() { assert(!gExePath.isEmpty()); assert(gExePath.isValid()); // build arguments std::vector<const char*> args; // args[0] should be the name of the executable args.push_back(gExePath.c_str()); // Skip first argument to -run; it's a D source file. for (size_t i = 1, length = opts::runargs.size(); i < length; i++) { args.push_back(opts::runargs[i].c_str()); } // terminate args list args.push_back(NULL); // try to call linker!!! std::string errstr; int status = llvm::sys::Program::ExecuteAndWait(gExePath, &args[0], NULL, NULL, 0,0, &errstr); if (status < 0) { error("program received signal %d (%s)", -status, strsignal(-status)); return -status; } if (!errstr.empty()) { error("failed to execute program"); if (!errstr.empty()) error("error message: %s", errstr.c_str()); fatal(); } return status; }
/** * Prints usage information to stdout. */ void printUsage(const char* argv0, ls::Path ldcPath) { // Print version information by actually invoking ldc -version. const char* args[] = { ldcPath.c_str(), "-version", NULL }; execute(ldcPath, args); printf("\n\ Usage:\n\ %s files.d ... { -switch }\n\
/** * Runs the given executable, returning its error code. */ int execute(ls::Path exePath, const char** args) { std::string errorMsg; int rc = ls::Program::ExecuteAndWait(exePath, args, NULL, NULL, 0, 0, &errorMsg); if (!errorMsg.empty()) { error("Could not execute %s: %s", exePath.c_str(), errorMsg.c_str()); } return rc; }
void clang::LoadSerializedDiagnostics(const llvm::sys::Path &DiagnosticsPath, unsigned num_unsaved_files, struct CXUnsavedFile *unsaved_files, FileManager &FileMgr, SourceManager &SourceMgr, SmallVectorImpl<StoredDiagnostic> &Diags) { using llvm::MemoryBuffer; using llvm::StringRef; MemoryBuffer *F = MemoryBuffer::getFile(DiagnosticsPath.c_str()); if (!F) return; // Enter the unsaved files into the file manager. for (unsigned I = 0; I != num_unsaved_files; ++I) { const FileEntry *File = FileMgr.getVirtualFile(unsaved_files[I].Filename, unsaved_files[I].Length, 0); if (!File) { // FIXME: Hard to localize when we have no diagnostics engine! Diags.push_back(StoredDiagnostic(Diagnostic::Fatal, (Twine("could not remap from missing file ") + unsaved_files[I].Filename).str())); delete F; return; } MemoryBuffer *Buffer = MemoryBuffer::getMemBuffer(unsaved_files[I].Contents, unsaved_files[I].Contents + unsaved_files[I].Length); if (!Buffer) { delete F; return; } SourceMgr.overrideFileContents(File, Buffer); SourceMgr.createFileID(File, SourceLocation(), SrcMgr::C_User); } // Parse the diagnostics, emitting them one by one until we've // exhausted the data. StringRef Buffer = F->getBuffer(); const char *Memory = Buffer.data(), *MemoryEnd = Memory + Buffer.size(); while (Memory != MemoryEnd) { StoredDiagnostic Stored = StoredDiagnostic::Deserialize(FileMgr, SourceMgr, Memory, MemoryEnd); if (!Stored) break; Diags.push_back(Stored); } delete F; }
bool SerializationTest::Deserialize(llvm::sys::Path& Filename, llvm::sys::Path& FNameDeclPrint) { // Deserialize the translation unit. ASTContext *NewCtx; { // Create the memory buffer that contains the contents of the file. llvm::OwningPtr<llvm::MemoryBuffer> MBuffer(llvm::MemoryBuffer::getFile(Filename.c_str())); if (!MBuffer) return false; NewCtx = ASTContext::ReadASTBitcodeBuffer(*MBuffer, FMgr); } if (!NewCtx) return false; { // Pretty-print the deserialized decls to a temp file. std::string Err; llvm::raw_fd_ostream DeclPP(FNameDeclPrint.c_str(), true, Err); assert (Err.empty() && "Could not open file for printing out decls."); llvm::OwningPtr<ASTConsumer> FilePrinter(CreateASTPrinter(&DeclPP)); TranslationUnitDecl *TUD = NewCtx->getTranslationUnitDecl(); for (DeclContext::decl_iterator I = TUD->decls_begin(*NewCtx), E = TUD->decls_end(*NewCtx); I != E; ++I) FilePrinter->HandleTopLevelDecl(DeclGroupRef(*I)); } delete NewCtx; return true; }
static bool generateBinary(llvm::Module *module, const string &outputFile, const llvm::sys::Path &gccPath, unsigned optLevel, bool /*exceptions*/, bool sharedLib, bool genPIC, const vector<string> &arguments) { llvm::sys::Path tempAsm("clayasm"); string errMsg; if (tempAsm.createTemporaryFileOnDisk(false, &errMsg)) { cerr << "error: " << errMsg << '\n'; return false; } llvm::sys::RemoveFileOnSignal(tempAsm); errMsg.clear(); llvm::raw_fd_ostream asmOut(tempAsm.c_str(), errMsg, llvm::raw_fd_ostream::F_Binary); if (!errMsg.empty()) { cerr << "error: " << errMsg << '\n'; return false; } generateAssembly(module, &asmOut, false, optLevel, sharedLib, genPIC); asmOut.close(); vector<const char *> gccArgs; gccArgs.push_back(gccPath.c_str()); switch (llvmTargetData->getPointerSizeInBits()) { case 32 : gccArgs.push_back("-m32"); break; case 64 : gccArgs.push_back("-m64"); break; default : assert(false); } if (sharedLib) gccArgs.push_back("-shared"); gccArgs.push_back("-o"); gccArgs.push_back(outputFile.c_str()); gccArgs.push_back("-x"); gccArgs.push_back("assembler"); gccArgs.push_back(tempAsm.c_str()); for (unsigned i = 0; i < arguments.size(); ++i) gccArgs.push_back(arguments[i].c_str()); gccArgs.push_back(NULL); int result = llvm::sys::Program::ExecuteAndWait(gccPath, &gccArgs[0]); if (tempAsm.eraseFromDisk(false, &errMsg)) { cerr << "error: " << errMsg << '\n'; return false; } return (result == 0); }