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