1 //===- LTO.cpp ------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include "LTO.h" 10 #include "COFFLinkerContext.h" 11 #include "Config.h" 12 #include "InputFiles.h" 13 #include "Symbols.h" 14 #include "lld/Common/Args.h" 15 #include "lld/Common/CommonLinkerContext.h" 16 #include "lld/Common/Strings.h" 17 #include "lld/Common/TargetOptionsCommandFlags.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/ADT/SmallString.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/ADT/Twine.h" 22 #include "llvm/Bitcode/BitcodeWriter.h" 23 #include "llvm/IR/DiagnosticPrinter.h" 24 #include "llvm/LTO/Config.h" 25 #include "llvm/LTO/LTO.h" 26 #include "llvm/Object/SymbolicFile.h" 27 #include "llvm/Support/Caching.h" 28 #include "llvm/Support/CodeGen.h" 29 #include "llvm/Support/Error.h" 30 #include "llvm/Support/FileSystem.h" 31 #include "llvm/Support/MemoryBuffer.h" 32 #include "llvm/Support/raw_ostream.h" 33 #include <algorithm> 34 #include <cstddef> 35 #include <memory> 36 #include <string> 37 #include <system_error> 38 #include <vector> 39 40 using namespace llvm; 41 using namespace llvm::object; 42 using namespace lld; 43 using namespace lld::coff; 44 45 // Creates an empty file to and returns a raw_fd_ostream to write to it. 46 static std::unique_ptr<raw_fd_ostream> openFile(StringRef file) { 47 std::error_code ec; 48 auto ret = 49 std::make_unique<raw_fd_ostream>(file, ec, sys::fs::OpenFlags::OF_None); 50 if (ec) { 51 error("cannot open " + file + ": " + ec.message()); 52 return nullptr; 53 } 54 return ret; 55 } 56 57 std::string BitcodeCompiler::getThinLTOOutputFile(StringRef path) { 58 return lto::getThinLTOOutputFile( 59 std::string(path), std::string(ctx.config.thinLTOPrefixReplace.first), 60 std::string(ctx.config.thinLTOPrefixReplace.second)); 61 } 62 63 lto::Config BitcodeCompiler::createConfig() { 64 lto::Config c; 65 c.Options = initTargetOptionsFromCodeGenFlags(); 66 c.Options.EmitAddrsig = true; 67 for (StringRef C : ctx.config.mllvmOpts) 68 c.MllvmArgs.emplace_back(C.str()); 69 70 // Always emit a section per function/datum with LTO. LLVM LTO should get most 71 // of the benefit of linker GC, but there are still opportunities for ICF. 72 c.Options.FunctionSections = true; 73 c.Options.DataSections = true; 74 75 // Use static reloc model on 32-bit x86 because it usually results in more 76 // compact code, and because there are also known code generation bugs when 77 // using the PIC model (see PR34306). 78 if (ctx.config.machine == COFF::IMAGE_FILE_MACHINE_I386) 79 c.RelocModel = Reloc::Static; 80 else 81 c.RelocModel = Reloc::PIC_; 82 #ifndef NDEBUG 83 c.DisableVerify = false; 84 #else 85 c.DisableVerify = true; 86 #endif 87 c.DiagHandler = diagnosticHandler; 88 c.OptLevel = ctx.config.ltoo; 89 c.CPU = getCPUStr(); 90 c.MAttrs = getMAttrs(); 91 c.CGOptLevel = args::getCGOptLevel(ctx.config.ltoo); 92 c.AlwaysEmitRegularLTOObj = !ctx.config.ltoObjPath.empty(); 93 c.DebugPassManager = ctx.config.ltoDebugPassManager; 94 c.CSIRProfile = std::string(ctx.config.ltoCSProfileFile); 95 c.RunCSIRInstr = ctx.config.ltoCSProfileGenerate; 96 c.PGOWarnMismatch = ctx.config.ltoPGOWarnMismatch; 97 98 if (ctx.config.saveTemps) 99 checkError(c.addSaveTemps(std::string(ctx.config.outputFile) + ".", 100 /*UseInputModulePath*/ true)); 101 return c; 102 } 103 104 BitcodeCompiler::BitcodeCompiler(COFFLinkerContext &c) : ctx(c) { 105 // Initialize indexFile. 106 if (!ctx.config.thinLTOIndexOnlyArg.empty()) 107 indexFile = openFile(ctx.config.thinLTOIndexOnlyArg); 108 109 // Initialize ltoObj. 110 lto::ThinBackend backend; 111 if (ctx.config.thinLTOIndexOnly) { 112 auto OnIndexWrite = [&](StringRef S) { thinIndices.erase(S); }; 113 backend = lto::createWriteIndexesThinBackend( 114 std::string(ctx.config.thinLTOPrefixReplace.first), 115 std::string(ctx.config.thinLTOPrefixReplace.second), 116 ctx.config.thinLTOEmitImportsFiles, indexFile.get(), OnIndexWrite); 117 } else { 118 backend = lto::createInProcessThinBackend( 119 llvm::heavyweight_hardware_concurrency(ctx.config.thinLTOJobs)); 120 } 121 122 ltoObj = std::make_unique<lto::LTO>(createConfig(), backend, 123 ctx.config.ltoPartitions); 124 } 125 126 BitcodeCompiler::~BitcodeCompiler() = default; 127 128 static void undefine(Symbol *s) { replaceSymbol<Undefined>(s, s->getName()); } 129 130 void BitcodeCompiler::add(BitcodeFile &f) { 131 lto::InputFile &obj = *f.obj; 132 unsigned symNum = 0; 133 std::vector<Symbol *> symBodies = f.getSymbols(); 134 std::vector<lto::SymbolResolution> resols(symBodies.size()); 135 136 if (ctx.config.thinLTOIndexOnly) 137 thinIndices.insert(obj.getName()); 138 139 // Provide a resolution to the LTO API for each symbol. 140 for (const lto::InputFile::Symbol &objSym : obj.symbols()) { 141 Symbol *sym = symBodies[symNum]; 142 lto::SymbolResolution &r = resols[symNum]; 143 ++symNum; 144 145 // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile 146 // reports two symbols for module ASM defined. Without this check, lld 147 // flags an undefined in IR with a definition in ASM as prevailing. 148 // Once IRObjectFile is fixed to report only one symbol this hack can 149 // be removed. 150 r.Prevailing = !objSym.isUndefined() && sym->getFile() == &f; 151 r.VisibleToRegularObj = sym->isUsedInRegularObj; 152 if (r.Prevailing) 153 undefine(sym); 154 155 // We tell LTO to not apply interprocedural optimization for wrapped 156 // (with -wrap) symbols because otherwise LTO would inline them while 157 // their values are still not final. 158 r.LinkerRedefined = !sym->canInline; 159 } 160 checkError(ltoObj->add(std::move(f.obj), resols)); 161 } 162 163 // Merge all the bitcode files we have seen, codegen the result 164 // and return the resulting objects. 165 std::vector<InputFile *> BitcodeCompiler::compile() { 166 unsigned maxTasks = ltoObj->getMaxTasks(); 167 buf.resize(maxTasks); 168 files.resize(maxTasks); 169 file_names.resize(maxTasks); 170 171 // The /lldltocache option specifies the path to a directory in which to cache 172 // native object files for ThinLTO incremental builds. If a path was 173 // specified, configure LTO to use it as the cache directory. 174 FileCache cache; 175 if (!ctx.config.ltoCache.empty()) 176 cache = check(localCache("ThinLTO", "Thin", ctx.config.ltoCache, 177 [&](size_t task, const Twine &moduleName, 178 std::unique_ptr<MemoryBuffer> mb) { 179 files[task] = std::move(mb); 180 file_names[task] = moduleName.str(); 181 })); 182 183 checkError(ltoObj->run( 184 [&](size_t task, const Twine &moduleName) { 185 buf[task].first = moduleName.str(); 186 return std::make_unique<CachedFileStream>( 187 std::make_unique<raw_svector_ostream>(buf[task].second)); 188 }, 189 cache)); 190 191 // Emit empty index files for non-indexed files 192 for (StringRef s : thinIndices) { 193 std::string path = getThinLTOOutputFile(s); 194 openFile(path + ".thinlto.bc"); 195 if (ctx.config.thinLTOEmitImportsFiles) 196 openFile(path + ".imports"); 197 } 198 199 // ThinLTO with index only option is required to generate only the index 200 // files. After that, we exit from linker and ThinLTO backend runs in a 201 // distributed environment. 202 if (ctx.config.thinLTOIndexOnly) { 203 if (!ctx.config.ltoObjPath.empty()) 204 saveBuffer(buf[0].second, ctx.config.ltoObjPath); 205 if (indexFile) 206 indexFile->close(); 207 return {}; 208 } 209 210 if (!ctx.config.ltoCache.empty()) 211 pruneCache(ctx.config.ltoCache, ctx.config.ltoCachePolicy, files); 212 213 std::vector<InputFile *> ret; 214 for (unsigned i = 0; i != maxTasks; ++i) { 215 StringRef bitcodeFilePath; 216 // Get the native object contents either from the cache or from memory. Do 217 // not use the cached MemoryBuffer directly, or the PDB will not be 218 // deterministic. 219 StringRef objBuf; 220 if (files[i]) { 221 objBuf = files[i]->getBuffer(); 222 bitcodeFilePath = file_names[i]; 223 } else { 224 objBuf = buf[i].second; 225 bitcodeFilePath = buf[i].first; 226 } 227 if (objBuf.empty()) 228 continue; 229 230 // If the input bitcode file is path/to/a.obj, then the corresponding lto 231 // object file name will look something like: path/to/main.exe.lto.a.obj. 232 StringRef ltoObjName; 233 if (bitcodeFilePath == "ld-temp.o") { 234 ltoObjName = 235 saver().save(Twine(ctx.config.outputFile) + ".lto" + 236 (i == 0 ? Twine("") : Twine('.') + Twine(i)) + ".obj"); 237 } else { 238 StringRef directory = sys::path::parent_path(bitcodeFilePath); 239 StringRef baseName = sys::path::filename(bitcodeFilePath); 240 StringRef outputFileBaseName = sys::path::filename(ctx.config.outputFile); 241 SmallString<64> path; 242 sys::path::append(path, directory, 243 outputFileBaseName + ".lto." + baseName); 244 sys::path::remove_dots(path, true); 245 ltoObjName = saver().save(path.str()); 246 } 247 if (ctx.config.saveTemps) 248 saveBuffer(buf[i].second, ltoObjName); 249 ret.push_back(make<ObjFile>(ctx, MemoryBufferRef(objBuf, ltoObjName))); 250 } 251 252 return ret; 253 } 254