xref: /freebsd-src/contrib/llvm-project/llvm/lib/Object/IRSymtab.cpp (revision 0fca6ea1d4eea4c934cfff25ac9ee8ad6fe95583)
10b57cec5SDimitry Andric //===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//
20b57cec5SDimitry Andric //
30b57cec5SDimitry Andric // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
40b57cec5SDimitry Andric // See https://llvm.org/LICENSE.txt for license information.
50b57cec5SDimitry Andric // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
60b57cec5SDimitry Andric //
70b57cec5SDimitry Andric //===----------------------------------------------------------------------===//
80b57cec5SDimitry Andric 
90b57cec5SDimitry Andric #include "llvm/Object/IRSymtab.h"
100b57cec5SDimitry Andric #include "llvm/ADT/ArrayRef.h"
110b57cec5SDimitry Andric #include "llvm/ADT/DenseMap.h"
120b57cec5SDimitry Andric #include "llvm/ADT/SmallPtrSet.h"
130b57cec5SDimitry Andric #include "llvm/ADT/SmallString.h"
140b57cec5SDimitry Andric #include "llvm/ADT/SmallVector.h"
150b57cec5SDimitry Andric #include "llvm/ADT/StringRef.h"
1604eeddc0SDimitry Andric #include "llvm/Bitcode/BitcodeReader.h"
170b57cec5SDimitry Andric #include "llvm/Config/llvm-config.h"
180b57cec5SDimitry Andric #include "llvm/IR/Comdat.h"
190b57cec5SDimitry Andric #include "llvm/IR/DataLayout.h"
200b57cec5SDimitry Andric #include "llvm/IR/GlobalAlias.h"
210b57cec5SDimitry Andric #include "llvm/IR/GlobalObject.h"
220b57cec5SDimitry Andric #include "llvm/IR/Mangler.h"
230b57cec5SDimitry Andric #include "llvm/IR/Metadata.h"
240b57cec5SDimitry Andric #include "llvm/IR/Module.h"
25*0fca6ea1SDimitry Andric #include "llvm/IR/RuntimeLibcalls.h"
260b57cec5SDimitry Andric #include "llvm/MC/StringTableBuilder.h"
270b57cec5SDimitry Andric #include "llvm/Object/ModuleSymbolTable.h"
280b57cec5SDimitry Andric #include "llvm/Object/SymbolicFile.h"
290b57cec5SDimitry Andric #include "llvm/Support/Allocator.h"
300b57cec5SDimitry Andric #include "llvm/Support/Casting.h"
3104eeddc0SDimitry Andric #include "llvm/Support/CommandLine.h"
320b57cec5SDimitry Andric #include "llvm/Support/Error.h"
330b57cec5SDimitry Andric #include "llvm/Support/StringSaver.h"
340b57cec5SDimitry Andric #include "llvm/Support/VCSRevision.h"
350b57cec5SDimitry Andric #include "llvm/Support/raw_ostream.h"
3606c3fb27SDimitry Andric #include "llvm/TargetParser/Triple.h"
370b57cec5SDimitry Andric #include <cassert>
380b57cec5SDimitry Andric #include <string>
390b57cec5SDimitry Andric #include <utility>
400b57cec5SDimitry Andric #include <vector>
410b57cec5SDimitry Andric 
420b57cec5SDimitry Andric using namespace llvm;
430b57cec5SDimitry Andric using namespace irsymtab;
440b57cec5SDimitry Andric 
4506c3fb27SDimitry Andric static cl::opt<bool> DisableBitcodeVersionUpgrade(
4606c3fb27SDimitry Andric     "disable-bitcode-version-upgrade", cl::Hidden,
4704eeddc0SDimitry Andric     cl::desc("Disable automatic bitcode upgrade for version mismatch"));
4804eeddc0SDimitry Andric 
49349cc55cSDimitry Andric static const char *PreservedSymbols[] = {
50349cc55cSDimitry Andric     // There are global variables, so put it here instead of in
51349cc55cSDimitry Andric     // RuntimeLibcalls.def.
52349cc55cSDimitry Andric     // TODO: Are there similar such variables?
53349cc55cSDimitry Andric     "__ssp_canary_word",
54349cc55cSDimitry Andric     "__stack_chk_guard",
550b57cec5SDimitry Andric };
560b57cec5SDimitry Andric 
570b57cec5SDimitry Andric namespace {
580b57cec5SDimitry Andric 
590b57cec5SDimitry Andric const char *getExpectedProducerName() {
600b57cec5SDimitry Andric   static char DefaultName[] = LLVM_VERSION_STRING
610b57cec5SDimitry Andric #ifdef LLVM_REVISION
620b57cec5SDimitry Andric       " " LLVM_REVISION
630b57cec5SDimitry Andric #endif
640b57cec5SDimitry Andric       ;
650b57cec5SDimitry Andric   // Allows for testing of the irsymtab writer and upgrade mechanism. This
660b57cec5SDimitry Andric   // environment variable should not be set by users.
670b57cec5SDimitry Andric   if (char *OverrideName = getenv("LLVM_OVERRIDE_PRODUCER"))
680b57cec5SDimitry Andric     return OverrideName;
690b57cec5SDimitry Andric   return DefaultName;
700b57cec5SDimitry Andric }
710b57cec5SDimitry Andric 
720b57cec5SDimitry Andric const char *kExpectedProducerName = getExpectedProducerName();
730b57cec5SDimitry Andric 
740b57cec5SDimitry Andric /// Stores the temporary state that is required to build an IR symbol table.
750b57cec5SDimitry Andric struct Builder {
760b57cec5SDimitry Andric   SmallVector<char, 0> &Symtab;
770b57cec5SDimitry Andric   StringTableBuilder &StrtabBuilder;
780b57cec5SDimitry Andric   StringSaver Saver;
790b57cec5SDimitry Andric 
800b57cec5SDimitry Andric   // This ctor initializes a StringSaver using the passed in BumpPtrAllocator.
810b57cec5SDimitry Andric   // The StringTableBuilder does not create a copy of any strings added to it,
820b57cec5SDimitry Andric   // so this provides somewhere to store any strings that we create.
830b57cec5SDimitry Andric   Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,
840b57cec5SDimitry Andric           BumpPtrAllocator &Alloc)
850b57cec5SDimitry Andric       : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc) {}
860b57cec5SDimitry Andric 
870b57cec5SDimitry Andric   DenseMap<const Comdat *, int> ComdatMap;
880b57cec5SDimitry Andric   Mangler Mang;
890b57cec5SDimitry Andric   Triple TT;
900b57cec5SDimitry Andric 
910b57cec5SDimitry Andric   std::vector<storage::Comdat> Comdats;
920b57cec5SDimitry Andric   std::vector<storage::Module> Mods;
930b57cec5SDimitry Andric   std::vector<storage::Symbol> Syms;
940b57cec5SDimitry Andric   std::vector<storage::Uncommon> Uncommons;
950b57cec5SDimitry Andric 
960b57cec5SDimitry Andric   std::string COFFLinkerOpts;
970b57cec5SDimitry Andric   raw_string_ostream COFFLinkerOptsOS{COFFLinkerOpts};
980b57cec5SDimitry Andric 
990b57cec5SDimitry Andric   std::vector<storage::Str> DependentLibraries;
1000b57cec5SDimitry Andric 
1010b57cec5SDimitry Andric   void setStr(storage::Str &S, StringRef Value) {
1020b57cec5SDimitry Andric     S.Offset = StrtabBuilder.add(Value);
1030b57cec5SDimitry Andric     S.Size = Value.size();
1040b57cec5SDimitry Andric   }
1050b57cec5SDimitry Andric 
1060b57cec5SDimitry Andric   template <typename T>
1070b57cec5SDimitry Andric   void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
1080b57cec5SDimitry Andric     R.Offset = Symtab.size();
1090b57cec5SDimitry Andric     R.Size = Objs.size();
1100b57cec5SDimitry Andric     Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
1110b57cec5SDimitry Andric                   reinterpret_cast<const char *>(Objs.data() + Objs.size()));
1120b57cec5SDimitry Andric   }
1130b57cec5SDimitry Andric 
1140b57cec5SDimitry Andric   Expected<int> getComdatIndex(const Comdat *C, const Module *M);
1150b57cec5SDimitry Andric 
1160b57cec5SDimitry Andric   Error addModule(Module *M);
1170b57cec5SDimitry Andric   Error addSymbol(const ModuleSymbolTable &Msymtab,
118fe6060f1SDimitry Andric                   const SmallPtrSet<GlobalValue *, 4> &Used,
1190b57cec5SDimitry Andric                   ModuleSymbolTable::Symbol Sym);
1200b57cec5SDimitry Andric 
1210b57cec5SDimitry Andric   Error build(ArrayRef<Module *> Mods);
1220b57cec5SDimitry Andric };
1230b57cec5SDimitry Andric 
1240b57cec5SDimitry Andric Error Builder::addModule(Module *M) {
1250b57cec5SDimitry Andric   if (M->getDataLayoutStr().empty())
1260b57cec5SDimitry Andric     return make_error<StringError>("input module has no datalayout",
1270b57cec5SDimitry Andric                                    inconvertibleErrorCode());
1280b57cec5SDimitry Andric 
129fe6060f1SDimitry Andric   // Symbols in the llvm.used list will get the FB_Used bit and will not be
130fe6060f1SDimitry Andric   // internalized. We do this for llvm.compiler.used as well:
131fe6060f1SDimitry Andric   //
132fe6060f1SDimitry Andric   // IR symbol table tracks module-level asm symbol references but not inline
133fe6060f1SDimitry Andric   // asm. A symbol only referenced by inline asm is not in the IR symbol table,
134fe6060f1SDimitry Andric   // so we may not know that the definition (in another translation unit) is
135fe6060f1SDimitry Andric   // referenced. That definition may have __attribute__((used)) (which lowers to
136fe6060f1SDimitry Andric   // llvm.compiler.used on ELF targets) to communicate to the compiler that it
137fe6060f1SDimitry Andric   // may be used by inline asm. The usage is perfectly fine, so we treat
138fe6060f1SDimitry Andric   // llvm.compiler.used conservatively as llvm.used to work around our own
139fe6060f1SDimitry Andric   // limitation.
140fe6060f1SDimitry Andric   SmallVector<GlobalValue *, 4> UsedV;
141fe6060f1SDimitry Andric   collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/false);
142fe6060f1SDimitry Andric   collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/true);
143fe6060f1SDimitry Andric   SmallPtrSet<GlobalValue *, 4> Used(UsedV.begin(), UsedV.end());
1440b57cec5SDimitry Andric 
1450b57cec5SDimitry Andric   ModuleSymbolTable Msymtab;
1460b57cec5SDimitry Andric   Msymtab.addModule(M);
1470b57cec5SDimitry Andric 
1480b57cec5SDimitry Andric   storage::Module Mod;
1490b57cec5SDimitry Andric   Mod.Begin = Syms.size();
1500b57cec5SDimitry Andric   Mod.End = Syms.size() + Msymtab.symbols().size();
1510b57cec5SDimitry Andric   Mod.UncBegin = Uncommons.size();
1520b57cec5SDimitry Andric   Mods.push_back(Mod);
1530b57cec5SDimitry Andric 
1540b57cec5SDimitry Andric   if (TT.isOSBinFormatCOFF()) {
1550b57cec5SDimitry Andric     if (auto E = M->materializeMetadata())
1560b57cec5SDimitry Andric       return E;
1570b57cec5SDimitry Andric     if (NamedMDNode *LinkerOptions =
1580b57cec5SDimitry Andric             M->getNamedMetadata("llvm.linker.options")) {
1590b57cec5SDimitry Andric       for (MDNode *MDOptions : LinkerOptions->operands())
1600b57cec5SDimitry Andric         for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())
1610b57cec5SDimitry Andric           COFFLinkerOptsOS << " " << cast<MDString>(MDOption)->getString();
1620b57cec5SDimitry Andric     }
1630b57cec5SDimitry Andric   }
1640b57cec5SDimitry Andric 
1650b57cec5SDimitry Andric   if (TT.isOSBinFormatELF()) {
1660b57cec5SDimitry Andric     if (auto E = M->materializeMetadata())
1670b57cec5SDimitry Andric       return E;
1680b57cec5SDimitry Andric     if (NamedMDNode *N = M->getNamedMetadata("llvm.dependent-libraries")) {
1690b57cec5SDimitry Andric       for (MDNode *MDOptions : N->operands()) {
1700b57cec5SDimitry Andric         const auto OperandStr =
1710b57cec5SDimitry Andric             cast<MDString>(cast<MDNode>(MDOptions)->getOperand(0))->getString();
1720b57cec5SDimitry Andric         storage::Str Specifier;
1730b57cec5SDimitry Andric         setStr(Specifier, OperandStr);
1740b57cec5SDimitry Andric         DependentLibraries.emplace_back(Specifier);
1750b57cec5SDimitry Andric       }
1760b57cec5SDimitry Andric     }
1770b57cec5SDimitry Andric   }
1780b57cec5SDimitry Andric 
1790b57cec5SDimitry Andric   for (ModuleSymbolTable::Symbol Msym : Msymtab.symbols())
1800b57cec5SDimitry Andric     if (Error Err = addSymbol(Msymtab, Used, Msym))
1810b57cec5SDimitry Andric       return Err;
1820b57cec5SDimitry Andric 
1830b57cec5SDimitry Andric   return Error::success();
1840b57cec5SDimitry Andric }
1850b57cec5SDimitry Andric 
1860b57cec5SDimitry Andric Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
1870b57cec5SDimitry Andric   auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));
1880b57cec5SDimitry Andric   if (P.second) {
1890b57cec5SDimitry Andric     std::string Name;
1900b57cec5SDimitry Andric     if (TT.isOSBinFormatCOFF()) {
1910b57cec5SDimitry Andric       const GlobalValue *GV = M->getNamedValue(C->getName());
1920b57cec5SDimitry Andric       if (!GV)
1930b57cec5SDimitry Andric         return make_error<StringError>("Could not find leader",
1940b57cec5SDimitry Andric                                        inconvertibleErrorCode());
1950b57cec5SDimitry Andric       // Internal leaders do not affect symbol resolution, therefore they do not
1960b57cec5SDimitry Andric       // appear in the symbol table.
1970b57cec5SDimitry Andric       if (GV->hasLocalLinkage()) {
1980b57cec5SDimitry Andric         P.first->second = -1;
1990b57cec5SDimitry Andric         return -1;
2000b57cec5SDimitry Andric       }
2010b57cec5SDimitry Andric       llvm::raw_string_ostream OS(Name);
2020b57cec5SDimitry Andric       Mang.getNameWithPrefix(OS, GV, false);
2030b57cec5SDimitry Andric     } else {
2045ffd83dbSDimitry Andric       Name = std::string(C->getName());
2050b57cec5SDimitry Andric     }
2060b57cec5SDimitry Andric 
2070b57cec5SDimitry Andric     storage::Comdat Comdat;
2080b57cec5SDimitry Andric     setStr(Comdat.Name, Saver.save(Name));
209fe6060f1SDimitry Andric     Comdat.SelectionKind = C->getSelectionKind();
2100b57cec5SDimitry Andric     Comdats.push_back(Comdat);
2110b57cec5SDimitry Andric   }
2120b57cec5SDimitry Andric 
2130b57cec5SDimitry Andric   return P.first->second;
2140b57cec5SDimitry Andric }
2150b57cec5SDimitry Andric 
216*0fca6ea1SDimitry Andric static DenseSet<StringRef> buildPreservedSymbolsSet(const Triple &TT) {
217*0fca6ea1SDimitry Andric   DenseSet<StringRef> PreservedSymbolSet(std::begin(PreservedSymbols),
2185f757f3fSDimitry Andric                                          std::end(PreservedSymbols));
219*0fca6ea1SDimitry Andric 
220*0fca6ea1SDimitry Andric   RTLIB::RuntimeLibcallsInfo Libcalls(TT);
221*0fca6ea1SDimitry Andric   for (const char *Name : Libcalls.getLibcallNames()) {
222*0fca6ea1SDimitry Andric     if (Name)
223*0fca6ea1SDimitry Andric       PreservedSymbolSet.insert(Name);
224*0fca6ea1SDimitry Andric   }
225*0fca6ea1SDimitry Andric   return PreservedSymbolSet;
2265f757f3fSDimitry Andric }
2275f757f3fSDimitry Andric 
2280b57cec5SDimitry Andric Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
229fe6060f1SDimitry Andric                          const SmallPtrSet<GlobalValue *, 4> &Used,
2300b57cec5SDimitry Andric                          ModuleSymbolTable::Symbol Msym) {
2310b57cec5SDimitry Andric   Syms.emplace_back();
2320b57cec5SDimitry Andric   storage::Symbol &Sym = Syms.back();
2330b57cec5SDimitry Andric   Sym = {};
2340b57cec5SDimitry Andric 
2350b57cec5SDimitry Andric   storage::Uncommon *Unc = nullptr;
2360b57cec5SDimitry Andric   auto Uncommon = [&]() -> storage::Uncommon & {
2370b57cec5SDimitry Andric     if (Unc)
2380b57cec5SDimitry Andric       return *Unc;
2390b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_has_uncommon;
2400b57cec5SDimitry Andric     Uncommons.emplace_back();
2410b57cec5SDimitry Andric     Unc = &Uncommons.back();
2420b57cec5SDimitry Andric     *Unc = {};
2430b57cec5SDimitry Andric     setStr(Unc->COFFWeakExternFallbackName, "");
2440b57cec5SDimitry Andric     setStr(Unc->SectionName, "");
2450b57cec5SDimitry Andric     return *Unc;
2460b57cec5SDimitry Andric   };
2470b57cec5SDimitry Andric 
2480b57cec5SDimitry Andric   SmallString<64> Name;
2490b57cec5SDimitry Andric   {
2500b57cec5SDimitry Andric     raw_svector_ostream OS(Name);
2510b57cec5SDimitry Andric     Msymtab.printSymbolName(OS, Msym);
2520b57cec5SDimitry Andric   }
253fe6060f1SDimitry Andric   setStr(Sym.Name, Saver.save(Name.str()));
2540b57cec5SDimitry Andric 
2550b57cec5SDimitry Andric   auto Flags = Msymtab.getSymbolFlags(Msym);
2560b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Undefined)
2570b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_undefined;
2580b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Weak)
2590b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_weak;
2600b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Common)
2610b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_common;
2620b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Indirect)
2630b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_indirect;
2640b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Global)
2650b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_global;
2660b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
2670b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_format_specific;
2680b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Executable)
2690b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_executable;
2700b57cec5SDimitry Andric 
2710b57cec5SDimitry Andric   Sym.ComdatIndex = -1;
27206c3fb27SDimitry Andric   auto *GV = dyn_cast_if_present<GlobalValue *>(Msym);
2730b57cec5SDimitry Andric   if (!GV) {
2740b57cec5SDimitry Andric     // Undefined module asm symbols act as GC roots and are implicitly used.
2750b57cec5SDimitry Andric     if (Flags & object::BasicSymbolRef::SF_Undefined)
2760b57cec5SDimitry Andric       Sym.Flags |= 1 << storage::Symbol::FB_used;
2770b57cec5SDimitry Andric     setStr(Sym.IRName, "");
2780b57cec5SDimitry Andric     return Error::success();
2790b57cec5SDimitry Andric   }
2800b57cec5SDimitry Andric 
2810b57cec5SDimitry Andric   setStr(Sym.IRName, GV->getName());
2820b57cec5SDimitry Andric 
2835f757f3fSDimitry Andric   static const DenseSet<StringRef> PreservedSymbolsSet =
284*0fca6ea1SDimitry Andric       buildPreservedSymbolsSet(
285*0fca6ea1SDimitry Andric           llvm::Triple(GV->getParent()->getTargetTriple()));
2865f757f3fSDimitry Andric   bool IsPreservedSymbol = PreservedSymbolsSet.contains(GV->getName());
2870b57cec5SDimitry Andric 
288349cc55cSDimitry Andric   if (Used.count(GV) || IsPreservedSymbol)
2890b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_used;
2900b57cec5SDimitry Andric   if (GV->isThreadLocal())
2910b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_tls;
2920b57cec5SDimitry Andric   if (GV->hasGlobalUnnamedAddr())
2930b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_unnamed_addr;
2940b57cec5SDimitry Andric   if (GV->canBeOmittedFromSymbolTable())
2950b57cec5SDimitry Andric     Sym.Flags |= 1 << storage::Symbol::FB_may_omit;
2960b57cec5SDimitry Andric   Sym.Flags |= unsigned(GV->getVisibility()) << storage::Symbol::FB_visibility;
2970b57cec5SDimitry Andric 
2980b57cec5SDimitry Andric   if (Flags & object::BasicSymbolRef::SF_Common) {
2995ffd83dbSDimitry Andric     auto *GVar = dyn_cast<GlobalVariable>(GV);
3005ffd83dbSDimitry Andric     if (!GVar)
3015ffd83dbSDimitry Andric       return make_error<StringError>("Only variables can have common linkage!",
3025ffd83dbSDimitry Andric                                      inconvertibleErrorCode());
303fe6060f1SDimitry Andric     Uncommon().CommonSize =
304*0fca6ea1SDimitry Andric         GV->getDataLayout().getTypeAllocSize(GV->getValueType());
305bdd1243dSDimitry Andric     Uncommon().CommonAlign = GVar->getAlign() ? GVar->getAlign()->value() : 0;
3060b57cec5SDimitry Andric   }
3070b57cec5SDimitry Andric 
308349cc55cSDimitry Andric   const GlobalObject *GO = GV->getAliaseeObject();
309349cc55cSDimitry Andric   if (!GO) {
310349cc55cSDimitry Andric     if (isa<GlobalIFunc>(GV))
311349cc55cSDimitry Andric       GO = cast<GlobalIFunc>(GV)->getResolverFunction();
312349cc55cSDimitry Andric     if (!GO)
3130b57cec5SDimitry Andric       return make_error<StringError>("Unable to determine comdat of alias!",
3140b57cec5SDimitry Andric                                      inconvertibleErrorCode());
315349cc55cSDimitry Andric   }
316349cc55cSDimitry Andric   if (const Comdat *C = GO->getComdat()) {
3170b57cec5SDimitry Andric     Expected<int> ComdatIndexOrErr = getComdatIndex(C, GV->getParent());
3180b57cec5SDimitry Andric     if (!ComdatIndexOrErr)
3190b57cec5SDimitry Andric       return ComdatIndexOrErr.takeError();
3200b57cec5SDimitry Andric     Sym.ComdatIndex = *ComdatIndexOrErr;
3210b57cec5SDimitry Andric   }
3220b57cec5SDimitry Andric 
3230b57cec5SDimitry Andric   if (TT.isOSBinFormatCOFF()) {
3240b57cec5SDimitry Andric     emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);
3250b57cec5SDimitry Andric 
3260b57cec5SDimitry Andric     if ((Flags & object::BasicSymbolRef::SF_Weak) &&
3270b57cec5SDimitry Andric         (Flags & object::BasicSymbolRef::SF_Indirect)) {
3280b57cec5SDimitry Andric       auto *Fallback = dyn_cast<GlobalValue>(
3290b57cec5SDimitry Andric           cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts());
3300b57cec5SDimitry Andric       if (!Fallback)
3310b57cec5SDimitry Andric         return make_error<StringError>("Invalid weak external",
3320b57cec5SDimitry Andric                                        inconvertibleErrorCode());
3330b57cec5SDimitry Andric       std::string FallbackName;
3340b57cec5SDimitry Andric       raw_string_ostream OS(FallbackName);
3350b57cec5SDimitry Andric       Msymtab.printSymbolName(OS, Fallback);
3360b57cec5SDimitry Andric       OS.flush();
3370b57cec5SDimitry Andric       setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
3380b57cec5SDimitry Andric     }
3390b57cec5SDimitry Andric   }
3400b57cec5SDimitry Andric 
341349cc55cSDimitry Andric   if (!GO->getSection().empty())
342349cc55cSDimitry Andric     setStr(Uncommon().SectionName, Saver.save(GO->getSection()));
3430b57cec5SDimitry Andric 
3440b57cec5SDimitry Andric   return Error::success();
3450b57cec5SDimitry Andric }
3460b57cec5SDimitry Andric 
3470b57cec5SDimitry Andric Error Builder::build(ArrayRef<Module *> IRMods) {
3480b57cec5SDimitry Andric   storage::Header Hdr;
3490b57cec5SDimitry Andric 
3500b57cec5SDimitry Andric   assert(!IRMods.empty());
3510b57cec5SDimitry Andric   Hdr.Version = storage::Header::kCurrentVersion;
3520b57cec5SDimitry Andric   setStr(Hdr.Producer, kExpectedProducerName);
3530b57cec5SDimitry Andric   setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
3540b57cec5SDimitry Andric   setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
3550b57cec5SDimitry Andric   TT = Triple(IRMods[0]->getTargetTriple());
3560b57cec5SDimitry Andric 
3570b57cec5SDimitry Andric   for (auto *M : IRMods)
3580b57cec5SDimitry Andric     if (Error Err = addModule(M))
3590b57cec5SDimitry Andric       return Err;
3600b57cec5SDimitry Andric 
3610b57cec5SDimitry Andric   COFFLinkerOptsOS.flush();
3620b57cec5SDimitry Andric   setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));
3630b57cec5SDimitry Andric 
3640b57cec5SDimitry Andric   // We are about to fill in the header's range fields, so reserve space for it
3650b57cec5SDimitry Andric   // and copy it in afterwards.
3660b57cec5SDimitry Andric   Symtab.resize(sizeof(storage::Header));
3670b57cec5SDimitry Andric   writeRange(Hdr.Modules, Mods);
3680b57cec5SDimitry Andric   writeRange(Hdr.Comdats, Comdats);
3690b57cec5SDimitry Andric   writeRange(Hdr.Symbols, Syms);
3700b57cec5SDimitry Andric   writeRange(Hdr.Uncommons, Uncommons);
3710b57cec5SDimitry Andric   writeRange(Hdr.DependentLibraries, DependentLibraries);
3720b57cec5SDimitry Andric   *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
3730b57cec5SDimitry Andric   return Error::success();
3740b57cec5SDimitry Andric }
3750b57cec5SDimitry Andric 
3760b57cec5SDimitry Andric } // end anonymous namespace
3770b57cec5SDimitry Andric 
3780b57cec5SDimitry Andric Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
3790b57cec5SDimitry Andric                       StringTableBuilder &StrtabBuilder,
3800b57cec5SDimitry Andric                       BumpPtrAllocator &Alloc) {
3810b57cec5SDimitry Andric   return Builder(Symtab, StrtabBuilder, Alloc).build(Mods);
3820b57cec5SDimitry Andric }
3830b57cec5SDimitry Andric 
3840b57cec5SDimitry Andric // Upgrade a vector of bitcode modules created by an old version of LLVM by
3850b57cec5SDimitry Andric // creating an irsymtab for them in the current format.
3860b57cec5SDimitry Andric static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {
3870b57cec5SDimitry Andric   FileContents FC;
3880b57cec5SDimitry Andric 
3890b57cec5SDimitry Andric   LLVMContext Ctx;
3900b57cec5SDimitry Andric   std::vector<Module *> Mods;
3910b57cec5SDimitry Andric   std::vector<std::unique_ptr<Module>> OwnedMods;
3920b57cec5SDimitry Andric   for (auto BM : BMs) {
3930b57cec5SDimitry Andric     Expected<std::unique_ptr<Module>> MOrErr =
3940b57cec5SDimitry Andric         BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,
3950b57cec5SDimitry Andric                          /*IsImporting*/ false);
3960b57cec5SDimitry Andric     if (!MOrErr)
3970b57cec5SDimitry Andric       return MOrErr.takeError();
3980b57cec5SDimitry Andric 
3990b57cec5SDimitry Andric     Mods.push_back(MOrErr->get());
4000b57cec5SDimitry Andric     OwnedMods.push_back(std::move(*MOrErr));
4010b57cec5SDimitry Andric   }
4020b57cec5SDimitry Andric 
4030b57cec5SDimitry Andric   StringTableBuilder StrtabBuilder(StringTableBuilder::RAW);
4040b57cec5SDimitry Andric   BumpPtrAllocator Alloc;
4050b57cec5SDimitry Andric   if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))
4060b57cec5SDimitry Andric     return std::move(E);
4070b57cec5SDimitry Andric 
4080b57cec5SDimitry Andric   StrtabBuilder.finalizeInOrder();
4090b57cec5SDimitry Andric   FC.Strtab.resize(StrtabBuilder.getSize());
4100b57cec5SDimitry Andric   StrtabBuilder.write((uint8_t *)FC.Strtab.data());
4110b57cec5SDimitry Andric 
4120b57cec5SDimitry Andric   FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
4130b57cec5SDimitry Andric                   {FC.Strtab.data(), FC.Strtab.size()}};
4140b57cec5SDimitry Andric   return std::move(FC);
4150b57cec5SDimitry Andric }
4160b57cec5SDimitry Andric 
4170b57cec5SDimitry Andric Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
4180b57cec5SDimitry Andric   if (BFC.Mods.empty())
4190b57cec5SDimitry Andric     return make_error<StringError>("Bitcode file does not contain any modules",
4200b57cec5SDimitry Andric                                    inconvertibleErrorCode());
4210b57cec5SDimitry Andric 
42204eeddc0SDimitry Andric   if (!DisableBitcodeVersionUpgrade) {
4230b57cec5SDimitry Andric     if (BFC.StrtabForSymtab.empty() ||
4240b57cec5SDimitry Andric         BFC.Symtab.size() < sizeof(storage::Header))
4250b57cec5SDimitry Andric       return upgrade(BFC.Mods);
4260b57cec5SDimitry Andric 
42704eeddc0SDimitry Andric     // We cannot use the regular reader to read the version and producer,
42804eeddc0SDimitry Andric     // because it will expect the header to be in the current format. The only
42904eeddc0SDimitry Andric     // thing we can rely on is that the version and producer will be present as
43004eeddc0SDimitry Andric     // the first struct elements.
4310b57cec5SDimitry Andric     auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());
4320b57cec5SDimitry Andric     unsigned Version = Hdr->Version;
4330b57cec5SDimitry Andric     StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);
4340b57cec5SDimitry Andric     if (Version != storage::Header::kCurrentVersion ||
4350b57cec5SDimitry Andric         Producer != kExpectedProducerName)
4360b57cec5SDimitry Andric       return upgrade(BFC.Mods);
43704eeddc0SDimitry Andric   }
4380b57cec5SDimitry Andric 
4390b57cec5SDimitry Andric   FileContents FC;
4400b57cec5SDimitry Andric   FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
4410b57cec5SDimitry Andric                   {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
4420b57cec5SDimitry Andric 
4430b57cec5SDimitry Andric   // Finally, make sure that the number of modules in the symbol table matches
4440b57cec5SDimitry Andric   // the number of modules in the bitcode file. If they differ, it may mean that
4450b57cec5SDimitry Andric   // the bitcode file was created by binary concatenation, so we need to create
4460b57cec5SDimitry Andric   // a new symbol table from scratch.
4470b57cec5SDimitry Andric   if (FC.TheReader.getNumModules() != BFC.Mods.size())
4480b57cec5SDimitry Andric     return upgrade(std::move(BFC.Mods));
4490b57cec5SDimitry Andric 
4500b57cec5SDimitry Andric   return std::move(FC);
4510b57cec5SDimitry Andric }
452