+//===- 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 'cr' 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/Linker/Linker.h"
+#include "llvm/ADT/STLExtras.h"
+#include "llvm/Bitcode/ReaderWriter.h"
+#include "llvm/IR/AutoUpgrade.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IR/Verifier.h"
+#include "llvm/IRReader/IRReader.h"
#include "llvm/Support/CommandLine.h"
-#include "llvm/Module.h"
-#include "llvm/Method.h"
-#include <fstream.h>
+#include "llvm/Support/FileSystem.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 <memory>
+using namespace llvm;
+static cl::list<std::string>
+InputFilenames(cl::Positional, cl::OneOrMore,
+ cl::desc("<input bitcode files>"));
-cl::StringList InputFilenames("", "Load <arg> 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);
+static cl::list<std::string> OverridingInputs(
+ "override", cl::ZeroOrMore, cl::value_desc("filename"),
+ cl::desc(
+ "input bitcode file which can override previously defined symbol(s)"));
+static cl::opt<std::string>
+OutputFilename("o", cl::desc("Override output filename"), cl::init("-"),
+ cl::value_desc("filename"));
-int main(int argc, char **argv) {
- cl::ParseCommandLineOptions(argc, argv, " llvm linker\n");
- assert(InputFilenames.size() > 0 && "OneOrMore is not working");
+static cl::opt<bool>
+Force("f", cl::desc("Enable binary output on terminals"));
- // TODO: TEST argv[0]
-
+static cl::opt<bool>
+OutputAssembly("S",
+ cl::desc("Write output as LLVM assembly"), cl::Hidden);
- if (Verbose) cerr << "Loading '" << InputFilenames[0] << "'\n";
- std::auto_ptr<Module> Composite(ParseBytecodeFile(InputFilenames[0]));
- if (Composite.get() == 0) {
- cerr << "Error opening bytecode file: '" << InputFilenames[0] << "'\n";
- return 1;
+static cl::opt<bool>
+Verbose("v", cl::desc("Print information about actions taken"));
+
+static cl::opt<bool>
+DumpAsm("d", cl::desc("Print assembly as linked"), cl::Hidden);
+
+static cl::opt<bool>
+SuppressWarnings("suppress-warnings", cl::desc("Suppress all linking warnings"),
+ cl::init(false));
+
+static cl::opt<bool> PreserveBitcodeUseListOrder(
+ "preserve-bc-uselistorder",
+ cl::desc("Preserve use-list order when writing LLVM bitcode."),
+ cl::init(true), cl::Hidden);
+
+static cl::opt<bool> PreserveAssemblyUseListOrder(
+ "preserve-ll-uselistorder",
+ cl::desc("Preserve use-list order when writing LLVM assembly."),
+ cl::init(false), cl::Hidden);
+
+// 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 std::unique_ptr<Module>
+loadFile(const char *argv0, const std::string &FN, LLVMContext &Context) {
+ SMDiagnostic Err;
+ if (Verbose) errs() << "Loading '" << FN << "'\n";
+ std::unique_ptr<Module> Result = getLazyIRFileModule(FN, Err, Context);
+ if (!Result)
+ Err.print(argv0, errs());
+
+ Result->materializeMetadata();
+ UpgradeDebugInfo(*Result);
+
+ return Result;
+}
+
+static void diagnosticHandler(const DiagnosticInfo &DI) {
+ unsigned Severity = DI.getSeverity();
+ switch (Severity) {
+ case DS_Error:
+ errs() << "ERROR: ";
+ break;
+ case DS_Warning:
+ if (SuppressWarnings)
+ return;
+ errs() << "WARNING: ";
+ break;
+ case DS_Remark:
+ case DS_Note:
+ llvm_unreachable("Only expecting warnings and errors");
}
- for (unsigned i = 1; i < InputFilenames.size(); ++i) {
- if (Verbose) cerr << "Loading '" << InputFilenames[i] << "'\n";
- auto_ptr<Module> M(ParseBytecodeFile(InputFilenames[i]));
- if (M.get() == 0) {
- cerr << "Error opening bytecode file: '" << InputFilenames[i] << "'\n";
- return 1;
- }
+ DiagnosticPrinterRawOStream DP(errs());
+ DI.print(DP);
+ errs() << '\n';
+}
- if (Verbose) cerr << "Linking in '" << InputFilenames[i] << "'\n";
+static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L,
+ const cl::list<std::string> &Files,
+ bool OverrideDuplicateSymbols) {
+ for (const auto &File : Files) {
+ std::unique_ptr<Module> M = loadFile(argv0, File, Context);
+ if (!M.get()) {
+ errs() << argv0 << ": error loading file '" << File << "'\n";
+ return false;
+ }
- string ErrorMessage;
- if (LinkModules(Composite.get(), M.get(), &ErrorMessage)) {
- cerr << "Error linking in '" << InputFilenames[i] << "': "
- << ErrorMessage << endl;
- return 1;
+ if (verifyModule(*M, &errs())) {
+ errs() << argv0 << ": " << File << ": error: input module is broken!\n";
+ return false;
}
+
+ if (Verbose)
+ errs() << "Linking in '" << File << "'\n";
+
+ if (L.linkInModule(M.get(), OverrideDuplicateSymbols))
+ return false;
}
- if (DumpAsm)
- cerr << "Here's the assembly:\n" << Composite.get();
+ return true;
+}
- ostream *Out = &cout; // Default to printing to stdout...
- if (OutputFilename != "-") {
- Out = new ofstream(OutputFilename.c_str(),
- (Force ? 0 : ios::noreplace)|ios::out);
- if (!Out->good()) {
- cerr << "Error opening '" << OutputFilename << "'!\n";
- return 1;
- }
+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, "llvm linker\n");
+
+ auto Composite = make_unique<Module>("llvm-link", Context);
+ Linker L(Composite.get(), diagnosticHandler);
+
+ // First add all the regular input files
+ if (!linkFiles(argv[0], Context, L, InputFilenames, false))
+ return 1;
+
+ // Next the -override ones.
+ if (!linkFiles(argv[0], Context, L, OverridingInputs, true))
+ return 1;
+
+ if (DumpAsm) errs() << "Here's the assembly:\n" << *Composite;
+
+ std::error_code EC;
+ tool_output_file Out(OutputFilename, EC, sys::fs::F_None);
+ if (EC) {
+ errs() << EC.message() << '\n';
+ return 1;
}
- if (Verbose) cerr << "Writing bytecode...\n";
- WriteBytecodeToFile(Composite.get(), *Out);
+ if (verifyModule(*Composite, &errs())) {
+ errs() << argv[0] << ": error: linked module is broken!\n";
+ return 1;
+ }
+
+ if (Verbose) errs() << "Writing bitcode...\n";
+ if (OutputAssembly) {
+ Composite->print(Out.os(), nullptr, PreserveAssemblyUseListOrder);
+ } else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true))
+ WriteBitcodeToFile(Composite.get(), Out.os(), PreserveBitcodeUseListOrder);
+
+ // Declare success.
+ Out.keep();
- if (Out != &cout) delete Out;
return 0;
}