1 //===- LTO.cpp ------------------------------------------------------------===// 2 // 3 // The LLVM Linker 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "LTO.h" 11 #include "Config.h" 12 #include "Driver.h" 13 #include "Error.h" 14 #include "InputFiles.h" 15 #include "Symbols.h" 16 #include "llvm/Analysis/AliasAnalysis.h" 17 #include "llvm/Analysis/CGSCCPassManager.h" 18 #include "llvm/Analysis/LoopPassManager.h" 19 #include "llvm/Analysis/TargetLibraryInfo.h" 20 #include "llvm/Analysis/TargetTransformInfo.h" 21 #include "llvm/Bitcode/ReaderWriter.h" 22 #include "llvm/CodeGen/CommandFlags.h" 23 #include "llvm/CodeGen/ParallelCG.h" 24 #include "llvm/IR/AutoUpgrade.h" 25 #include "llvm/IR/LegacyPassManager.h" 26 #include "llvm/IR/PassManager.h" 27 #include "llvm/IR/Verifier.h" 28 #include "llvm/Linker/IRMover.h" 29 #include "llvm/Passes/PassBuilder.h" 30 #include "llvm/Support/StringSaver.h" 31 #include "llvm/Support/TargetRegistry.h" 32 #include "llvm/Target/TargetMachine.h" 33 #include "llvm/Transforms/IPO.h" 34 #include "llvm/Transforms/IPO/PassManagerBuilder.h" 35 #include "llvm/Transforms/Utils/ModuleUtils.h" 36 37 using namespace llvm; 38 using namespace llvm::object; 39 using namespace llvm::ELF; 40 41 using namespace lld; 42 using namespace lld::elf; 43 44 // This is for use when debugging LTO. 45 static void saveLtoObjectFile(StringRef Buffer, unsigned I, bool Many) { 46 SmallString<128> Filename = Config->OutputFile; 47 if (Many) 48 Filename += utostr(I); 49 Filename += ".lto.o"; 50 std::error_code EC; 51 raw_fd_ostream OS(Filename, EC, sys::fs::OpenFlags::F_None); 52 check(EC); 53 OS << Buffer; 54 } 55 56 // This is for use when debugging LTO. 57 static void saveBCFile(Module &M, StringRef Suffix) { 58 std::error_code EC; 59 raw_fd_ostream OS(Config->OutputFile.str() + Suffix.str(), EC, 60 sys::fs::OpenFlags::F_None); 61 check(EC); 62 WriteBitcodeToFile(&M, OS, /* ShouldPreserveUseListOrder */ true); 63 } 64 65 static void runNewCustomLtoPasses(Module &M, TargetMachine &TM) { 66 PassBuilder PB(&TM); 67 68 AAManager AA; 69 70 // Parse a custom AA pipeline if asked to. 71 if (!PB.parseAAPipeline(AA, Config->LtoAAPipeline)) { 72 error("Unable to parse AA pipeline description: " + Config->LtoAAPipeline); 73 return; 74 } 75 76 LoopAnalysisManager LAM; 77 FunctionAnalysisManager FAM; 78 CGSCCAnalysisManager CGAM; 79 ModuleAnalysisManager MAM; 80 81 // Register the AA manager first so that our version is the one used. 82 FAM.registerPass([&] { return std::move(AA); }); 83 84 // Register all the basic analyses with the managers. 85 PB.registerModuleAnalyses(MAM); 86 PB.registerCGSCCAnalyses(CGAM); 87 PB.registerFunctionAnalyses(FAM); 88 PB.registerLoopAnalyses(LAM); 89 PB.crossRegisterProxies(LAM, FAM, CGAM, MAM); 90 91 ModulePassManager MPM; 92 if (!Config->DisableVerify) 93 MPM.addPass(VerifierPass()); 94 95 // Now, add all the passes we've been requested to. 96 if (!PB.parsePassPipeline(MPM, Config->LtoNewPmPasses)) { 97 error("unable to parse pass pipeline description: " + 98 Config->LtoNewPmPasses); 99 return; 100 } 101 102 if (!Config->DisableVerify) 103 MPM.addPass(VerifierPass()); 104 MPM.run(M, MAM); 105 } 106 107 static void runOldLtoPasses(Module &M, TargetMachine &TM) { 108 // Note that the gold plugin has a similar piece of code, so 109 // it is probably better to move this code to a common place. 110 legacy::PassManager LtoPasses; 111 LtoPasses.add(createTargetTransformInfoWrapperPass(TM.getTargetIRAnalysis())); 112 PassManagerBuilder PMB; 113 PMB.LibraryInfo = new TargetLibraryInfoImpl(Triple(TM.getTargetTriple())); 114 PMB.Inliner = createFunctionInliningPass(); 115 PMB.VerifyInput = PMB.VerifyOutput = !Config->DisableVerify; 116 PMB.LoopVectorize = true; 117 PMB.SLPVectorize = true; 118 PMB.OptLevel = Config->LtoO; 119 PMB.populateLTOPassManager(LtoPasses); 120 LtoPasses.run(M); 121 } 122 123 static void runLTOPasses(Module &M, TargetMachine &TM) { 124 if (!Config->LtoNewPmPasses.empty()) { 125 // The user explicitly asked for a set of passes to be run. 126 // This needs the new PM to work as there's no clean way to 127 // pass a set of passes to run in the legacy PM. 128 runNewCustomLtoPasses(M, TM); 129 if (HasError) 130 return; 131 } else { 132 // Run the 'default' set of LTO passes. This code still uses 133 // the legacy PM as the new one is not the default. 134 runOldLtoPasses(M, TM); 135 } 136 137 if (Config->SaveTemps) 138 saveBCFile(M, ".lto.opt.bc"); 139 } 140 141 static bool shouldInternalize(const SmallPtrSet<GlobalValue *, 8> &Used, 142 Symbol *S, GlobalValue *GV) { 143 if (S->IsUsedInRegularObj || Used.count(GV)) 144 return false; 145 return !S->includeInDynsym(); 146 } 147 148 BitcodeCompiler::BitcodeCompiler() 149 : Combined(new llvm::Module("ld-temp.o", Driver->Context)), 150 Mover(*Combined) {} 151 152 static void undefine(Symbol *S) { 153 replaceBody<Undefined>(S, S->body()->getName(), STV_DEFAULT, S->body()->Type); 154 } 155 156 void BitcodeCompiler::add(BitcodeFile &F) { 157 std::unique_ptr<IRObjectFile> Obj = std::move(F.Obj); 158 std::vector<GlobalValue *> Keep; 159 unsigned BodyIndex = 0; 160 ArrayRef<Symbol *> Syms = F.getSymbols(); 161 162 Module &M = Obj->getModule(); 163 if (M.getDataLayoutStr().empty()) 164 fatal("invalid bitcode file: " + F.getName() + " has no datalayout"); 165 166 // Discard non-compatible debug infos if necessary. 167 M.materializeMetadata(); 168 UpgradeDebugInfo(M); 169 170 // If a symbol appears in @llvm.used, the linker is required 171 // to treat the symbol as there is a reference to the symbol 172 // that it cannot see. Therefore, we can't internalize. 173 SmallPtrSet<GlobalValue *, 8> Used; 174 collectUsedGlobalVariables(M, Used, /* CompilerUsed */ false); 175 176 for (const BasicSymbolRef &Sym : Obj->symbols()) { 177 uint32_t Flags = Sym.getFlags(); 178 GlobalValue *GV = Obj->getSymbolGV(Sym.getRawDataRefImpl()); 179 if (GV && GV->hasAppendingLinkage()) 180 Keep.push_back(GV); 181 if (BitcodeFile::shouldSkip(Flags)) 182 continue; 183 Symbol *S = Syms[BodyIndex++]; 184 if (Flags & BasicSymbolRef::SF_Undefined) 185 continue; 186 auto *B = dyn_cast<DefinedBitcode>(S->body()); 187 if (!B || B->File != &F) 188 continue; 189 190 // We collect the set of symbols we want to internalize here 191 // and change the linkage after the IRMover executed, i.e. after 192 // we imported the symbols and satisfied undefined references 193 // to it. We can't just change linkage here because otherwise 194 // the IRMover will just rename the symbol. 195 if (GV && shouldInternalize(Used, S, GV)) 196 InternalizedSyms.insert(GV->getName()); 197 198 // At this point we know that either the combined LTO object will provide a 199 // definition of a symbol, or we will internalize it. In either case, we 200 // need to undefine the symbol. In the former case, the real definition 201 // needs to be able to replace the original definition without conflicting. 202 // In the latter case, we need to allow the combined LTO object to provide a 203 // definition with the same name, for example when doing parallel codegen. 204 undefine(S); 205 206 if (!GV) 207 // Module asm symbol. 208 continue; 209 210 switch (GV->getLinkage()) { 211 default: 212 break; 213 case llvm::GlobalValue::LinkOnceAnyLinkage: 214 GV->setLinkage(GlobalValue::WeakAnyLinkage); 215 break; 216 case llvm::GlobalValue::LinkOnceODRLinkage: 217 GV->setLinkage(GlobalValue::WeakODRLinkage); 218 break; 219 } 220 221 Keep.push_back(GV); 222 } 223 224 if (Error E = Mover.move(Obj->takeModule(), Keep, 225 [](GlobalValue &, IRMover::ValueAdder) {})) { 226 handleAllErrors(std::move(E), [&](const llvm::ErrorInfoBase &EIB) { 227 fatal("failed to link module " + F.getName() + ": " + EIB.message()); 228 }); 229 } 230 } 231 232 static void internalize(GlobalValue &GV) { 233 assert(!GV.hasLocalLinkage() && 234 "Trying to internalize a symbol with local linkage!"); 235 GV.setLinkage(GlobalValue::InternalLinkage); 236 } 237 238 std::vector<std::unique_ptr<InputFile>> BitcodeCompiler::runSplitCodegen( 239 const std::function<std::unique_ptr<TargetMachine>()> &TMFactory) { 240 unsigned NumThreads = Config->LtoJobs; 241 OwningData.resize(NumThreads); 242 243 std::list<raw_svector_ostream> OSs; 244 std::vector<raw_pwrite_stream *> OSPtrs; 245 for (SmallString<0> &Obj : OwningData) { 246 OSs.emplace_back(Obj); 247 OSPtrs.push_back(&OSs.back()); 248 } 249 250 splitCodeGen(std::move(Combined), OSPtrs, {}, TMFactory); 251 252 std::vector<std::unique_ptr<InputFile>> ObjFiles; 253 for (SmallString<0> &Obj : OwningData) 254 ObjFiles.push_back(createObjectFile( 255 MemoryBufferRef(Obj, "LLD-INTERNAL-combined-lto-object"))); 256 257 if (Config->SaveTemps) 258 for (unsigned I = 0; I < NumThreads; ++I) 259 saveLtoObjectFile(OwningData[I], I, NumThreads > 1); 260 261 return ObjFiles; 262 } 263 264 // Merge all the bitcode files we have seen, codegen the result 265 // and return the resulting ObjectFile. 266 std::vector<std::unique_ptr<InputFile>> BitcodeCompiler::compile() { 267 TheTriple = Combined->getTargetTriple(); 268 for (const auto &Name : InternalizedSyms) { 269 GlobalValue *GV = Combined->getNamedValue(Name.first()); 270 assert(GV); 271 internalize(*GV); 272 } 273 274 if (Config->SaveTemps) 275 saveBCFile(*Combined, ".lto.bc"); 276 277 std::string Msg; 278 const Target *T = TargetRegistry::lookupTarget(TheTriple, Msg); 279 if (!T) 280 fatal("target not found: " + Msg); 281 TargetOptions Options = InitTargetOptionsFromCodeGenFlags(); 282 Reloc::Model R = Config->Pic ? Reloc::PIC_ : Reloc::Static; 283 284 auto CreateTargetMachine = [&]() { 285 return std::unique_ptr<TargetMachine>( 286 T->createTargetMachine(TheTriple, "", "", Options, R)); 287 }; 288 289 std::unique_ptr<TargetMachine> TM = CreateTargetMachine(); 290 runLTOPasses(*Combined, *TM); 291 if (HasError) 292 return {}; 293 294 return runSplitCodegen(CreateTargetMachine); 295 } 296