| //===- LTO.cpp ------------------------------------------------------------===// |
| // |
| // The LLVM Linker |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "LTO.h" |
| #include "Config.h" |
| #include "InputFiles.h" |
| #include "Symbols.h" |
| #include "lld/Common/ErrorHandler.h" |
| #include "lld/Common/TargetOptionsCommandFlags.h" |
| #include "llvm/ADT/STLExtras.h" |
| #include "llvm/ADT/SmallString.h" |
| #include "llvm/ADT/StringRef.h" |
| #include "llvm/ADT/Twine.h" |
| #include "llvm/IR/DiagnosticPrinter.h" |
| #include "llvm/LTO/Caching.h" |
| #include "llvm/LTO/Config.h" |
| #include "llvm/LTO/LTO.h" |
| #include "llvm/Object/SymbolicFile.h" |
| #include "llvm/Support/CodeGen.h" |
| #include "llvm/Support/Error.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/MemoryBuffer.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include <algorithm> |
| #include <cstddef> |
| #include <memory> |
| #include <string> |
| #include <system_error> |
| #include <vector> |
| |
| using namespace llvm; |
| using namespace llvm::object; |
| |
| using namespace lld; |
| using namespace lld::coff; |
| |
| static void diagnosticHandler(const DiagnosticInfo &DI) { |
| SmallString<128> ErrStorage; |
| raw_svector_ostream OS(ErrStorage); |
| DiagnosticPrinterRawOStream DP(OS); |
| DI.print(DP); |
| warn(ErrStorage); |
| } |
| |
| static void checkError(Error E) { |
| handleAllErrors(std::move(E), |
| [&](ErrorInfoBase &EIB) { error(EIB.message()); }); |
| } |
| |
| static void saveBuffer(StringRef Buffer, const Twine &Path) { |
| std::error_code EC; |
| raw_fd_ostream OS(Path.str(), EC, sys::fs::OpenFlags::F_None); |
| if (EC) |
| error("cannot create " + Path + ": " + EC.message()); |
| OS << Buffer; |
| } |
| |
| static std::unique_ptr<lto::LTO> createLTO() { |
| lto::Config Conf; |
| Conf.Options = InitTargetOptionsFromCodeGenFlags(); |
| // Use static reloc model on 32-bit x86 because it usually results in more |
| // compact code, and because there are also known code generation bugs when |
| // using the PIC model (see PR34306). |
| if (Config->Machine == COFF::IMAGE_FILE_MACHINE_I386) |
| Conf.RelocModel = Reloc::Static; |
| else |
| Conf.RelocModel = Reloc::PIC_; |
| Conf.DisableVerify = true; |
| Conf.DiagHandler = diagnosticHandler; |
| Conf.OptLevel = Config->LTOOptLevel; |
| if (Config->SaveTemps) |
| checkError(Conf.addSaveTemps(std::string(Config->OutputFile) + ".", |
| /*UseInputModulePath*/ true)); |
| lto::ThinBackend Backend; |
| if (Config->LTOJobs != 0) |
| Backend = lto::createInProcessThinBackend(Config->LTOJobs); |
| return llvm::make_unique<lto::LTO>(std::move(Conf), Backend, |
| Config->LTOPartitions); |
| } |
| |
| BitcodeCompiler::BitcodeCompiler() : LTOObj(createLTO()) {} |
| |
| BitcodeCompiler::~BitcodeCompiler() = default; |
| |
| static void undefine(Symbol *S) { replaceSymbol<Undefined>(S, S->getName()); } |
| |
| void BitcodeCompiler::add(BitcodeFile &F) { |
| lto::InputFile &Obj = *F.Obj; |
| unsigned SymNum = 0; |
| std::vector<Symbol *> SymBodies = F.getSymbols(); |
| std::vector<lto::SymbolResolution> Resols(SymBodies.size()); |
| |
| // Provide a resolution to the LTO API for each symbol. |
| for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) { |
| Symbol *Sym = SymBodies[SymNum]; |
| lto::SymbolResolution &R = Resols[SymNum]; |
| ++SymNum; |
| |
| // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile |
| // reports two symbols for module ASM defined. Without this check, lld |
| // flags an undefined in IR with a definition in ASM as prevailing. |
| // Once IRObjectFile is fixed to report only one symbol this hack can |
| // be removed. |
| R.Prevailing = !ObjSym.isUndefined() && Sym->getFile() == &F; |
| R.VisibleToRegularObj = Sym->IsUsedInRegularObj; |
| if (R.Prevailing) |
| undefine(Sym); |
| } |
| checkError(LTOObj->add(std::move(F.Obj), Resols)); |
| } |
| |
| // Merge all the bitcode files we have seen, codegen the result |
| // and return the resulting objects. |
| std::vector<StringRef> BitcodeCompiler::compile() { |
| unsigned MaxTasks = LTOObj->getMaxTasks(); |
| Buff.resize(MaxTasks); |
| Files.resize(MaxTasks); |
| |
| // The /lldltocache option specifies the path to a directory in which to cache |
| // native object files for ThinLTO incremental builds. If a path was |
| // specified, configure LTO to use it as the cache directory. |
| lto::NativeObjectCache Cache; |
| if (!Config->LTOCache.empty()) |
| Cache = check( |
| lto::localCache(Config->LTOCache, |
| [&](size_t Task, std::unique_ptr<MemoryBuffer> MB, |
| StringRef Path) { Files[Task] = std::move(MB); })); |
| |
| checkError(LTOObj->run( |
| [&](size_t Task) { |
| return llvm::make_unique<lto::NativeObjectStream>( |
| llvm::make_unique<raw_svector_ostream>(Buff[Task])); |
| }, |
| Cache)); |
| |
| if (!Config->LTOCache.empty()) |
| pruneCache(Config->LTOCache, Config->LTOCachePolicy); |
| |
| std::vector<StringRef> Ret; |
| for (unsigned I = 0; I != MaxTasks; ++I) { |
| if (Buff[I].empty()) |
| continue; |
| if (Config->SaveTemps) { |
| if (I == 0) |
| saveBuffer(Buff[I], Config->OutputFile + ".lto.obj"); |
| else |
| saveBuffer(Buff[I], Config->OutputFile + Twine(I) + ".lto.obj"); |
| } |
| Ret.emplace_back(Buff[I].data(), Buff[I].size()); |
| } |
| |
| for (std::unique_ptr<MemoryBuffer> &File : Files) |
| if (File) |
| Ret.push_back(File->getBuffer()); |
| |
| return Ret; |
| } |