lld/wasm/LTO.cpp

   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 "Config.h"
  11 #include "InputFiles.h"
  12 #include "Symbols.h"
  13 #include "lld/Common/Args.h"
  14 #include "lld/Common/ErrorHandler.h"
  15 #include "lld/Common/Strings.h"
  16 #include "lld/Common/TargetOptionsCommandFlags.h"
  17 #include "llvm/ADT/STLExtras.h"
  18 #include "llvm/ADT/SmallString.h"
  19 #include "llvm/ADT/StringRef.h"
  20 #include "llvm/ADT/Twine.h"
  21 #include "llvm/IR/DiagnosticPrinter.h"
  22 #include "llvm/LTO/Config.h"
  23 #include "llvm/LTO/LTO.h"
  24 #include "llvm/Object/SymbolicFile.h"
  25 #include "llvm/Support/Caching.h"
  26 #include "llvm/Support/CodeGen.h"
  27 #include "llvm/Support/Error.h"
  28 #include "llvm/Support/FileSystem.h"
  29 #include "llvm/Support/MemoryBuffer.h"
  30 #include "llvm/Support/raw_ostream.h"
  31 #include <algorithm>
  32 #include <cstddef>
  33 #include <memory>
  34 #include <string>
  35 #include <system_error>
  36 #include <vector>
  37
  38 using namespace llvm;
  39
  40 namespace lld::wasm {
  41 static std::unique_ptr<lto::LTO> createLTO() {
  42   lto::Config c;
  43   c.Options = initTargetOptionsFromCodeGenFlags();
  44
  45   // Always emit a section per function/data with LTO.
  46   c.Options.FunctionSections = true;
  47   c.Options.DataSections = true;
  48
  49   c.DisableVerify = config->disableVerify;
  50   c.DiagHandler = diagnosticHandler;
  51   c.OptLevel = config->ltoo;
  52   c.MAttrs = getMAttrs();
  53   c.CGOptLevel = config->ltoCgo;
  54   c.DebugPassManager = config->ltoDebugPassManager;
  55
  56   if (config->relocatable)
  57     c.RelocModel = std::nullopt;
  58   else if (config->isPic)
  59     c.RelocModel = Reloc::PIC_;
  60   else
  61     c.RelocModel = Reloc::Static;
  62
  63   if (config->saveTemps)
  64     checkError(c.addSaveTemps(config->outputFile.str() + ".",
  65                               /*UseInputModulePath*/ true));
  66   lto::ThinBackend backend = lto::createInProcessThinBackend(
  67       llvm::heavyweight_hardware_concurrency(config->thinLTOJobs));
  68   return std::make_unique<lto::LTO>(std::move(c), backend,
  69                                      config->ltoPartitions);
  70 }
  71
  72 BitcodeCompiler::BitcodeCompiler() : ltoObj(createLTO()) {}
  73
  74 BitcodeCompiler::~BitcodeCompiler() = default;
  75
  76 static void undefine(Symbol *s) {
  77   if (auto f = dyn_cast<DefinedFunction>(s))
  78     replaceSymbol<UndefinedFunction>(f, f->getName(), std::nullopt,
  79                                      std::nullopt, 0, f->getFile(),
  80                                      f->signature);
  81   else if (isa<DefinedData>(s))
  82     replaceSymbol<UndefinedData>(s, s->getName(), 0, s->getFile());
  83   else
  84     llvm_unreachable("unexpected symbol kind");
  85 }
  86
  87 void BitcodeCompiler::add(BitcodeFile &f) {
  88   lto::InputFile &obj = *f.obj;
  89   unsigned symNum = 0;
  90   ArrayRef<Symbol *> syms = f.getSymbols();
  91   std::vector<lto::SymbolResolution> resols(syms.size());
  92
  93   // Provide a resolution to the LTO API for each symbol.
  94   for (const lto::InputFile::Symbol &objSym : obj.symbols()) {
  95     Symbol *sym = syms[symNum];
  96     lto::SymbolResolution &r = resols[symNum];
  97     ++symNum;
  98
  99     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
 100     // reports two symbols for module ASM defined. Without this check, lld
 101     // flags an undefined in IR with a definition in ASM as prevailing.
 102     // Once IRObjectFile is fixed to report only one symbol this hack can
 103     // be removed.
 104     r.Prevailing = !objSym.isUndefined() && sym->getFile() == &f;
 105     r.VisibleToRegularObj = config->relocatable || sym->isUsedInRegularObj ||
 106                             sym->isNoStrip() ||
 107                             (r.Prevailing && sym->isExported());
 108     if (r.Prevailing)
 109       undefine(sym);
 110
 111     // We tell LTO to not apply interprocedural optimization for wrapped
 112     // (with --wrap) symbols because otherwise LTO would inline them while
 113     // their values are still not final.
 114     r.LinkerRedefined = !sym->canInline;
 115   }
 116   checkError(ltoObj->add(std::move(f.obj), resols));
 117 }
 118
 119 // Merge all the bitcode files we have seen, codegen the result
 120 // and return the resulting objects.
 121 std::vector<StringRef> BitcodeCompiler::compile() {
 122   unsigned maxTasks = ltoObj->getMaxTasks();
 123   buf.resize(maxTasks);
 124   files.resize(maxTasks);
 125
 126   // The --thinlto-cache-dir option specifies the path to a directory in which
 127   // to cache native object files for ThinLTO incremental builds. If a path was
 128   // specified, configure LTO to use it as the cache directory.
 129   FileCache cache;
 130   if (!config->thinLTOCacheDir.empty())
 131     cache = check(localCache("ThinLTO", "Thin", config->thinLTOCacheDir,
 132                              [&](size_t task, const Twine &moduleName,
 133                                  std::unique_ptr<MemoryBuffer> mb) {
 134                                files[task] = std::move(mb);
 135                              }));
 136
 137   checkError(ltoObj->run(
 138       [&](size_t task, const Twine &moduleName) {
 139         return std::make_unique<CachedFileStream>(
 140             std::make_unique<raw_svector_ostream>(buf[task]));
 141       },
 142       cache));
 143
 144   if (!config->thinLTOCacheDir.empty())
 145     pruneCache(config->thinLTOCacheDir, config->thinLTOCachePolicy, files);
 146
 147   std::vector<StringRef> ret;
 148   for (unsigned i = 0; i != maxTasks; ++i) {
 149     if (buf[i].empty())
 150       continue;
 151     if (config->saveTemps) {
 152       if (i == 0)
 153         saveBuffer(buf[i], config->outputFile + ".lto.o");
 154       else
 155         saveBuffer(buf[i], config->outputFile + Twine(i) + ".lto.o");
 156     }
 157     ret.emplace_back(buf[i].data(), buf[i].size());
 158   }
 159
 160   for (std::unique_ptr<MemoryBuffer> &file : files)
 161     if (file)
 162       ret.push_back(file->getBuffer());
 163
 164   return ret;
 165 }
 166
 167 } // namespace lld::wasm