X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=tools%2Fllvm-link%2Fllvm-link.cpp;h=99cca2322d8a8ce701f3492f1a21a80ba24862da;hb=5be77762a3aa434ee877b0a03b98b5c3a7571918;hp=83141c86e7d438edd3e0965b86390c361a9c5e8b;hpb=952d365a3a446ebfbf14a8db27e26c5c2abec651;p=oota-llvm.git diff --git a/tools/llvm-link/llvm-link.cpp b/tools/llvm-link/llvm-link.cpp index 83141c86e7d..99cca2322d8 100644 --- a/tools/llvm-link/llvm-link.cpp +++ b/tools/llvm-link/llvm-link.cpp @@ -1,127 +1,130 @@ +//===- llvm-link.cpp - Low-level LLVM linker ------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// //===----------------------------------------------------------------------===// -// LLVM 'LINK' UTILITY // // This utility may be invoked in the following manner: -// link a.bc b.bc c.bc -o x.bc -// -// Alternatively, this can be used as an 'ar' tool as well. If invoked as -// either 'ar' or 'llvm-ar', it accepts a 'rc' parameter as well. +// llvm-link a.bc b.bc c.bc -o x.bc // //===----------------------------------------------------------------------===// -#include "llvm/Transforms/Linker.h" -#include "llvm/Bytecode/Reader.h" -#include "llvm/Bytecode/Writer.h" -#include "llvm/Assembly/Writer.h" -#include "llvm/Module.h" -#include "llvm/Method.h" -#include "Support/CommandLine.h" -#include +#include "llvm/Linker.h" +#include "llvm/Analysis/Verifier.h" +#include "llvm/Bitcode/ReaderWriter.h" +#include "llvm/IR/LLVMContext.h" +#include "llvm/IR/Module.h" +#include "llvm/IRReader/IRReader.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/ManagedStatic.h" +#include "llvm/Support/Path.h" +#include "llvm/Support/PrettyStackTrace.h" +#include "llvm/Support/Signals.h" +#include "llvm/Support/SourceMgr.h" +#include "llvm/Support/SystemUtils.h" +#include "llvm/Support/ToolOutputFile.h" #include -#include // For FileExists -#include +using namespace llvm; +static cl::list +InputFilenames(cl::Positional, cl::OneOrMore, + cl::desc("")); -cl::StringList InputFilenames("", "Load files, linking them together", - cl::OneOrMore); -cl::String OutputFilename("o", "Override output filename", cl::NoFlags, "-"); -cl::Flag Force ("f", "Overwrite output files", cl::NoFlags, false); -cl::Flag Verbose ("v", "Print information about actions taken"); -cl::Flag DumpAsm ("d", "Print assembly as linked", cl::Hidden, false); -cl::StringList LibPaths ("L", "Specify a library search path", cl::ZeroOrMore); +static cl::opt +OutputFilename("o", cl::desc("Override output filename"), cl::init("-"), + cl::value_desc("filename")); +static cl::opt +Force("f", cl::desc("Enable binary output on terminals")); -// FileExists - Return true if the specified string is an openable file... -static inline bool FileExists(const string &FN) { - struct stat StatBuf; - return stat(FN.c_str(), &StatBuf) != -1; -} +static cl::opt +OutputAssembly("S", + cl::desc("Write output as LLVM assembly"), cl::Hidden); -// LoadFile - Read the specified bytecode file in and return it. This routine -// searches the link path for the specified file to try to find it... -// -static inline std::auto_ptr LoadFile(const string &FN) { - string Filename = FN; - string ErrorMessage; - - unsigned NextLibPathIdx = 0; - bool FoundAFile = false; - - while (1) { - if (Verbose) cerr << "Loading '" << Filename << "'\n"; - if (FileExists(Filename)) FoundAFile = true; - Module *Result = ParseBytecodeFile(Filename, &ErrorMessage); - if (Result) return std::auto_ptr(Result); // Load successful! - - if (Verbose) { - cerr << "Error opening bytecode file: '" << Filename << "'"; - if (ErrorMessage.size()) cerr << ": " << ErrorMessage; - cerr << endl; - } - - if (NextLibPathIdx == LibPaths.size()) break; - Filename = LibPaths[NextLibPathIdx++] + "/" + FN; - } +static cl::opt +Verbose("v", cl::desc("Print information about actions taken")); - if (FoundAFile) - cerr << "Bytecode file '" << FN << "' corrupt! " - << "Use 'link -v ...' for more info.\n"; - else - cerr << "Could not locate bytecode file: '" << FN << "'\n"; - return std::auto_ptr(); -} +static cl::opt +DumpAsm("d", cl::desc("Print assembly as linked"), cl::Hidden); +// LoadFile - Read the specified bitcode file in and return it. This routine +// searches the link path for the specified file to try to find it... +// +static inline Module *LoadFile(const char *argv0, const std::string &FN, + LLVMContext& Context) { + SMDiagnostic Err; + if (Verbose) errs() << "Loading '" << FN << "'\n"; + Module* Result = 0; + Result = ParseIRFile(FN, Err, Context); + if (Result) return Result; // Load successful! + Err.print(argv0, errs()); + return NULL; +} int main(int argc, char **argv) { - cl::ParseCommandLineOptions(argc, argv, " llvm linker\n", - cl::EnableSingleLetterArgValue | - cl::DisableSingleLetterArgGrouping); - assert(InputFilenames.size() > 0 && "OneOrMore is not working"); + // Print a stack trace if we signal out. + sys::PrintStackTraceOnErrorSignal(); + PrettyStackTraceProgram X(argc, argv); - unsigned BaseArg = 0; - string ErrorMessage; + LLVMContext &Context = getGlobalContext(); + llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. + cl::ParseCommandLineOptions(argc, argv, "llvm linker\n"); - // TODO: TEST argv[0] for llvm-ar forms... for now, this is a huge hack. - if (InputFilenames.size() >= 3 && InputFilenames[0] == "rc" && - OutputFilename == "-") { - BaseArg = 2; - OutputFilename = InputFilenames[1]; + unsigned BaseArg = 0; + std::string ErrorMessage; + + OwningPtr Composite(LoadFile(argv[0], + InputFilenames[BaseArg], Context)); + if (Composite.get() == 0) { + errs() << argv[0] << ": error loading file '" + << InputFilenames[BaseArg] << "'\n"; + return 1; } - std::auto_ptr Composite(LoadFile(InputFilenames[BaseArg])); - if (Composite.get() == 0) return 1; - + Linker L(Composite.get()); for (unsigned i = BaseArg+1; i < InputFilenames.size(); ++i) { - auto_ptr M(LoadFile(InputFilenames[i])); - if (M.get() == 0) return 1; + OwningPtr M(LoadFile(argv[0], InputFilenames[i], Context)); + if (M.get() == 0) { + errs() << argv[0] << ": error loading file '" <good()) { - cerr << "Error opening '" << OutputFilename << "'!\n"; - return 1; - } + std::string ErrorInfo; + tool_output_file Out(OutputFilename.c_str(), ErrorInfo, sys::fs::F_Binary); + if (!ErrorInfo.empty()) { + errs() << ErrorInfo << '\n'; + return 1; } - if (Verbose) cerr << "Writing bytecode...\n"; - WriteBytecodeToFile(Composite.get(), *Out); + if (verifyModule(*Composite)) { + errs() << argv[0] << ": linked module is broken!\n"; + return 1; + } + + if (Verbose) errs() << "Writing bitcode...\n"; + if (OutputAssembly) { + Out.os() << *Composite; + } else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true)) + WriteBitcodeToFile(Composite.get(), Out.os()); + + // Declare success. + Out.keep(); - if (Out != &cout) delete Out; return 0; }