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/Linker.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/Bitcode/ReaderWriter.h" 18 #include "llvm/IR/AutoUpgrade.h" 19 #include "llvm/IR/DiagnosticInfo.h" 20 #include "llvm/IR/DiagnosticPrinter.h" 21 #include "llvm/IR/FunctionInfo.h" 22 #include "llvm/IR/LLVMContext.h" 23 #include "llvm/IR/Module.h" 24 #include "llvm/IR/Verifier.h" 25 #include "llvm/IRReader/IRReader.h" 26 #include "llvm/Object/FunctionIndexObjectFile.h" 27 #include "llvm/Support/CommandLine.h" 28 #include "llvm/Support/FileSystem.h" 29 #include "llvm/Support/ManagedStatic.h" 30 #include "llvm/Support/Path.h" 31 #include "llvm/Support/PrettyStackTrace.h" 32 #include "llvm/Support/Signals.h" 33 #include "llvm/Support/SourceMgr.h" 34 #include "llvm/Support/SystemUtils.h" 35 #include "llvm/Support/ToolOutputFile.h" 36 #include <memory> 37 using namespace llvm; 38 39 static cl::list<std::string> 40 InputFilenames(cl::Positional, cl::OneOrMore, 41 cl::desc("<input bitcode files>")); 42 43 static cl::list<std::string> OverridingInputs( 44 "override", cl::ZeroOrMore, cl::value_desc("filename"), 45 cl::desc( 46 "input bitcode file which can override previously defined symbol(s)")); 47 48 // Option to simulate function importing for testing. This enables using 49 // llvm-link to simulate ThinLTO backend processes. 50 static cl::list<std::string> Imports( 51 "import", cl::ZeroOrMore, cl::value_desc("function:filename"), 52 cl::desc("Pair of function name and filename, where function should be " 53 "imported from bitcode in filename")); 54 55 // Option to support testing of function importing. The function index 56 // must be specified in the case were we request imports via the -import 57 // option, as well as when compiling any module with functions that may be 58 // exported (imported by a different llvm-link -import invocation), to ensure 59 // consistent promotion and renaming of locals. 60 static cl::opt<std::string> FunctionIndex("functionindex", 61 cl::desc("Function index filename"), 62 cl::init(""), 63 cl::value_desc("filename")); 64 65 static cl::opt<std::string> 66 OutputFilename("o", cl::desc("Override output filename"), cl::init("-"), 67 cl::value_desc("filename")); 68 69 static cl::opt<bool> 70 Internalize("internalize", cl::desc("Internalize linked symbols")); 71 72 static cl::opt<bool> 73 OnlyNeeded("only-needed", cl::desc("Link only needed symbols")); 74 75 static cl::opt<bool> 76 Force("f", cl::desc("Enable binary output on terminals")); 77 78 static cl::opt<bool> 79 OutputAssembly("S", 80 cl::desc("Write output as LLVM assembly"), cl::Hidden); 81 82 static cl::opt<bool> 83 Verbose("v", cl::desc("Print information about actions taken")); 84 85 static cl::opt<bool> 86 DumpAsm("d", cl::desc("Print assembly as linked"), cl::Hidden); 87 88 static cl::opt<bool> 89 SuppressWarnings("suppress-warnings", cl::desc("Suppress all linking warnings"), 90 cl::init(false)); 91 92 static cl::opt<bool> 93 PreserveModules("preserve-modules", 94 cl::desc("Preserve linked modules for testing")); 95 96 static cl::opt<bool> PreserveBitcodeUseListOrder( 97 "preserve-bc-uselistorder", 98 cl::desc("Preserve use-list order when writing LLVM bitcode."), 99 cl::init(true), cl::Hidden); 100 101 static cl::opt<bool> PreserveAssemblyUseListOrder( 102 "preserve-ll-uselistorder", 103 cl::desc("Preserve use-list order when writing LLVM assembly."), 104 cl::init(false), cl::Hidden); 105 106 // Read the specified bitcode file in and return it. This routine searches the 107 // link path for the specified file to try to find it... 108 // 109 static std::unique_ptr<Module> loadFile(const char *argv0, 110 const std::string &FN, 111 LLVMContext &Context, 112 bool MaterializeMetadata = true) { 113 SMDiagnostic Err; 114 if (Verbose) errs() << "Loading '" << FN << "'\n"; 115 std::unique_ptr<Module> Result = 116 getLazyIRFileModule(FN, Err, Context, !MaterializeMetadata); 117 if (!Result) 118 Err.print(argv0, errs()); 119 120 if (MaterializeMetadata) { 121 Result->materializeMetadata(); 122 UpgradeDebugInfo(*Result); 123 } 124 125 return Result; 126 } 127 128 static void diagnosticHandler(const DiagnosticInfo &DI) { 129 unsigned Severity = DI.getSeverity(); 130 switch (Severity) { 131 case DS_Error: 132 errs() << "ERROR: "; 133 break; 134 case DS_Warning: 135 if (SuppressWarnings) 136 return; 137 errs() << "WARNING: "; 138 break; 139 case DS_Remark: 140 case DS_Note: 141 llvm_unreachable("Only expecting warnings and errors"); 142 } 143 144 DiagnosticPrinterRawOStream DP(errs()); 145 DI.print(DP); 146 errs() << '\n'; 147 } 148 149 static void diagnosticHandlerWithContext(const DiagnosticInfo &DI, void *C) { 150 diagnosticHandler(DI); 151 } 152 153 /// Import any functions requested via the -import option. 154 static bool importFunctions(const char *argv0, LLVMContext &Context, 155 Linker &L) { 156 StringMap<std::unique_ptr<DenseMap<unsigned, MDNode *>>> 157 ModuleToTempMDValsMap; 158 for (const auto &Import : Imports) { 159 // Identify the requested function and its bitcode source file. 160 size_t Idx = Import.find(':'); 161 if (Idx == std::string::npos) { 162 errs() << "Import parameter bad format: " << Import << "\n"; 163 return false; 164 } 165 std::string FunctionName = Import.substr(0, Idx); 166 std::string FileName = Import.substr(Idx + 1, std::string::npos); 167 168 // Load the specified source module. 169 std::unique_ptr<Module> M = loadFile(argv0, FileName, Context, false); 170 if (!M.get()) { 171 errs() << argv0 << ": error loading file '" << FileName << "'\n"; 172 return false; 173 } 174 175 if (verifyModule(*M, &errs())) { 176 errs() << argv0 << ": " << FileName 177 << ": error: input module is broken!\n"; 178 return false; 179 } 180 181 Function *F = M->getFunction(FunctionName); 182 if (!F) { 183 errs() << "Ignoring import request for non-existent function " 184 << FunctionName << " from " << FileName << "\n"; 185 continue; 186 } 187 // We cannot import weak_any functions without possibly affecting the 188 // order they are seen and selected by the linker, changing program 189 // semantics. 190 if (F->hasWeakAnyLinkage()) { 191 errs() << "Ignoring import request for weak-any function " << FunctionName 192 << " from " << FileName << "\n"; 193 continue; 194 } 195 196 if (Verbose) 197 errs() << "Importing " << FunctionName << " from " << FileName << "\n"; 198 199 std::unique_ptr<FunctionInfoIndex> Index; 200 if (!FunctionIndex.empty()) { 201 ErrorOr<std::unique_ptr<FunctionInfoIndex>> IndexOrErr = 202 llvm::getFunctionIndexForFile(FunctionIndex, diagnosticHandler); 203 std::error_code EC = IndexOrErr.getError(); 204 if (EC) { 205 errs() << EC.message() << '\n'; 206 return false; 207 } 208 Index = std::move(IndexOrErr.get()); 209 } 210 211 // Save the mapping of value ids to temporary metadata created when 212 // importing this function. If we have already imported from this module, 213 // add new temporary metadata to the existing mapping. 214 auto &TempMDVals = ModuleToTempMDValsMap[FileName]; 215 if (!TempMDVals) 216 TempMDVals = llvm::make_unique<DenseMap<unsigned, MDNode *>>(); 217 218 // Link in the specified function. 219 DenseSet<const GlobalValue *> FunctionsToImport; 220 FunctionsToImport.insert(F); 221 if (L.linkInModule(std::move(M), Linker::Flags::None, Index.get(), 222 &FunctionsToImport, TempMDVals.get())) 223 return false; 224 } 225 226 // Now link in metadata for all modules from which we imported functions. 227 for (StringMapEntry<std::unique_ptr<DenseMap<unsigned, MDNode *>>> &SME : 228 ModuleToTempMDValsMap) { 229 // Load the specified source module. 230 std::unique_ptr<Module> M = loadFile(argv0, SME.getKey(), Context, true); 231 if (!M.get()) { 232 errs() << argv0 << ": error loading file '" << SME.getKey() << "'\n"; 233 return false; 234 } 235 236 if (verifyModule(*M, &errs())) { 237 errs() << argv0 << ": " << SME.getKey() 238 << ": error: input module is broken!\n"; 239 return false; 240 } 241 242 // Link in all necessary metadata from this module. 243 if (L.linkInMetadata(*M, SME.getValue().get())) 244 return false; 245 } 246 return true; 247 } 248 249 static bool linkFiles(const char *argv0, LLVMContext &Context, Linker &L, 250 const cl::list<std::string> &Files, 251 unsigned Flags) { 252 // Filter out flags that don't apply to the first file we load. 253 unsigned ApplicableFlags = Flags & Linker::Flags::OverrideFromSrc; 254 for (const auto &File : Files) { 255 std::unique_ptr<Module> M = loadFile(argv0, File, Context); 256 if (!M.get()) { 257 errs() << argv0 << ": error loading file '" << File << "'\n"; 258 return false; 259 } 260 261 if (verifyModule(*M, &errs())) { 262 errs() << argv0 << ": " << File << ": error: input module is broken!\n"; 263 return false; 264 } 265 266 // If a function index is supplied, load it so linkInModule can treat 267 // local functions/variables as exported and promote if necessary. 268 std::unique_ptr<FunctionInfoIndex> Index; 269 if (!FunctionIndex.empty()) { 270 ErrorOr<std::unique_ptr<FunctionInfoIndex>> IndexOrErr = 271 llvm::getFunctionIndexForFile(FunctionIndex, diagnosticHandler); 272 std::error_code EC = IndexOrErr.getError(); 273 if (EC) { 274 errs() << EC.message() << '\n'; 275 return false; 276 } 277 Index = std::move(IndexOrErr.get()); 278 } 279 280 if (Verbose) 281 errs() << "Linking in '" << File << "'\n"; 282 283 if (L.linkInModule(std::move(M), ApplicableFlags, Index.get())) 284 return false; 285 // All linker flags apply to linking of subsequent files. 286 ApplicableFlags = Flags; 287 288 // If requested for testing, preserve modules by releasing them from 289 // the unique_ptr before the are freed. This can help catch any 290 // cross-module references from e.g. unneeded metadata references 291 // that aren't properly set to null but instead mapped to the source 292 // module version. The bitcode writer will assert if it finds any such 293 // cross-module references. 294 if (PreserveModules) 295 M.release(); 296 } 297 298 return true; 299 } 300 301 int main(int argc, char **argv) { 302 // Print a stack trace if we signal out. 303 sys::PrintStackTraceOnErrorSignal(); 304 PrettyStackTraceProgram X(argc, argv); 305 306 LLVMContext &Context = getGlobalContext(); 307 Context.setDiagnosticHandler(diagnosticHandlerWithContext, nullptr, true); 308 309 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. 310 cl::ParseCommandLineOptions(argc, argv, "llvm linker\n"); 311 312 auto Composite = make_unique<Module>("llvm-link", Context); 313 Linker L(*Composite); 314 315 unsigned Flags = Linker::Flags::None; 316 if (Internalize) 317 Flags |= Linker::Flags::InternalizeLinkedSymbols; 318 if (OnlyNeeded) 319 Flags |= Linker::Flags::LinkOnlyNeeded; 320 321 // First add all the regular input files 322 if (!linkFiles(argv[0], Context, L, InputFilenames, Flags)) 323 return 1; 324 325 // Next the -override ones. 326 if (!linkFiles(argv[0], Context, L, OverridingInputs, 327 Flags | Linker::Flags::OverrideFromSrc)) 328 return 1; 329 330 // Import any functions requested via -import 331 if (!importFunctions(argv[0], Context, L)) 332 return 1; 333 334 if (DumpAsm) errs() << "Here's the assembly:\n" << *Composite; 335 336 std::error_code EC; 337 tool_output_file Out(OutputFilename, EC, sys::fs::F_None); 338 if (EC) { 339 errs() << EC.message() << '\n'; 340 return 1; 341 } 342 343 if (verifyModule(*Composite, &errs())) { 344 errs() << argv[0] << ": error: linked module is broken!\n"; 345 return 1; 346 } 347 348 if (Verbose) errs() << "Writing bitcode...\n"; 349 if (OutputAssembly) { 350 Composite->print(Out.os(), nullptr, PreserveAssemblyUseListOrder); 351 } else if (Force || !CheckBitcodeOutputToConsole(Out.os(), true)) 352 WriteBitcodeToFile(Composite.get(), Out.os(), PreserveBitcodeUseListOrder); 353 354 // Declare success. 355 Out.keep(); 356 357 return 0; 358 } 359
