Home | History | Annotate | Download | only in llvm-link 
      1 //===- llvm-link.cpp - Low-level LLVM linker ------------------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This utility may be invoked in the following manner:
     11 //  llvm-link a.bc b.bc c.bc -o x.bc
     12 //
     13 //===----------------------------------------------------------------------===//
     14 
     15 #include "llvm/Linker.h"
     16 #include "llvm/LLVMContext.h"
     17 #include "llvm/Module.h"
     18 #include "llvm/Analysis/Verifier.h"
     19 #include "llvm/Bitcode/ReaderWriter.h"
     20 #include "llvm/Support/CommandLine.h"
     21 #include "llvm/Support/ManagedStatic.h"
     22 #include "llvm/Support/PrettyStackTrace.h"
     23 #include "llvm/Support/ToolOutputFile.h"
     24 #include "llvm/Support/SystemUtils.h"
     25 #include "llvm/Support/IRReader.h"
     26 #include "llvm/Support/Signals.h"
     27 #include "llvm/Support/Path.h"
     28 #include <memory>
     29 using namespace llvm;
     30 
     31 static cl::list<std::string>
     32 InputFilenames(cl::Positional, cl::OneOrMore,
     33                cl::desc("<input bitcode files>"));
     34 
     35 static cl::opt<std::string>
     36 OutputFilename("o", cl::desc("Override output filename"), cl::init("-"),
     37                cl::value_desc("filename"));
     38 
     39 static cl::opt<bool>
     40 Force("f", cl::desc("Enable binary output on terminals"));
     41 
     42 static cl::opt<bool>
     43 OutputAssembly("S",
     44          cl::desc("Write output as LLVM assembly"), cl::Hidden);
     45 
     46 static cl::opt<bool>
     47 Verbose("v", cl::desc("Print information about actions taken"));
     48 
     49 static cl::opt<bool>
     50 DumpAsm("d", cl::desc("Print assembly as linked"), cl::Hidden);
     51 
     52 // LoadFile - Read the specified bitcode file in and return it.  This routine
     53 // searches the link path for the specified file to try to find it...
     54 //
     55 static inline std::auto_ptr<Module> LoadFile(const char *argv0,
     56                                              const std::string &FN,
     57                                              LLVMContext& Context) {
     58   sys::Path Filename;
     59   if (!Filename.set(FN)) {
     60     errs() << "Invalid file name: '" << FN << "'\n";
     61     return std::auto_ptr<Module>();
     62   }
     63 
     64   SMDiagnostic Err;
     65   if (Verbose) errs() << "Loading '" << Filename.c_str() << "'\n";
     66   Module* Result = 0;
     67 
     68   const std::string &FNStr = Filename.str();
     69   Result = ParseIRFile(FNStr, Err, Context);
     70   if (Result) return std::auto_ptr<Module>(Result);   // Load successful!
     71 
     72   Err.Print(argv0, errs());
     73   return std::auto_ptr<Module>();
     74 }
     75 
     76 int main(int argc, char **argv) {
     77   // Print a stack trace if we signal out.
     78   sys::PrintStackTraceOnErrorSignal();
     79   PrettyStackTraceProgram X(argc, argv);
     80 
     81   LLVMContext &Context = getGlobalContext();
     82   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
     83   cl::ParseCommandLineOptions(argc, argv, "llvm linker\n");
     84 
     85   unsigned BaseArg = 0;
     86   std::string ErrorMessage;
     87 
     88   std::auto_ptr<Module> Composite(LoadFile(argv[0],
     89                                            InputFilenames[BaseArg], Context));
     90   if (Composite.get() == 0) {
     91     errs() << argv[0] << ": error loading file '"
     92            << InputFilenames[BaseArg] << "'\n";
     93     return 1;
     94   }
     95 
     96   for (unsigned i = BaseArg+1; i < InputFilenames.size(); ++i) {
     97     std::auto_ptr<Module> M(LoadFile(argv[0],
     98                                      InputFilenames[i], Context));
     99     if (M.get() == 0) {
    100       errs() << argv[0] << ": error loading file '" <<InputFilenames[i]<< "'\n";
    101       return 1;
    102     }
    103 
    104     if (Verbose) errs() << "Linking in '" << InputFilenames[i] << "'\n";
    105 
    106     if (Linker::LinkModules(Composite.get(), M.get(), Linker::DestroySource,
    107                             &ErrorMessage)) {
    108       errs() << argv[0] << ": link error in '" << InputFilenames[i]
    109              << "': " << ErrorMessage << "\n";
    110       return 1;
    111     }
    112   }
    113 
    114   // TODO: Iterate over the -l list and link in any modules containing
    115   // global symbols that have not been resolved so far.
    116 
    117   if (DumpAsm) errs() << "Here's the assembly:\n" << *Composite;
    118 
    119   std::string ErrorInfo;
    120   tool_output_file Out(OutputFilename.c_str(), ErrorInfo,
    121                        raw_fd_ostream::F_Binary);
    122   if (!ErrorInfo.empty()) {
    123     errs() << ErrorInfo << '\n';
    124     return 1;
    125   }
    126 
    127   if (verifyModule(*Composite)) {
    128     errs() << argv[0] << ": linked module is broken!\n";
    129     return 1;
    130   }
    131 
    132   if (Verbose) errs() << "Writing bitcode...\n";
    133   if (OutputAssembly) {
    134     Out.os() << *Composite;
    135   } else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
    136     WriteBitcodeToFile(Composite.get(), Out.os());
    137 
    138   // Declare success.
    139   Out.keep();
    140 
    141   return 0;
    142 }
    143