436 lines · cpp
1//===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//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-exception6//7//===----------------------------------------------------------------------===//8 9#include "llvm/Object/IRSymtab.h"10#include "llvm/ADT/ArrayRef.h"11#include "llvm/ADT/SmallPtrSet.h"12#include "llvm/ADT/SmallString.h"13#include "llvm/ADT/SmallVector.h"14#include "llvm/ADT/StringRef.h"15#include "llvm/ADT/StringSet.h"16#include "llvm/Bitcode/BitcodeReader.h"17#include "llvm/Config/llvm-config.h"18#include "llvm/IR/Comdat.h"19#include "llvm/IR/DataLayout.h"20#include "llvm/IR/GlobalAlias.h"21#include "llvm/IR/GlobalObject.h"22#include "llvm/IR/Mangler.h"23#include "llvm/IR/Metadata.h"24#include "llvm/IR/Module.h"25#include "llvm/IR/RuntimeLibcalls.h"26#include "llvm/MC/StringTableBuilder.h"27#include "llvm/Object/ModuleSymbolTable.h"28#include "llvm/Object/SymbolicFile.h"29#include "llvm/Support/Allocator.h"30#include "llvm/Support/Casting.h"31#include "llvm/Support/CommandLine.h"32#include "llvm/Support/Error.h"33#include "llvm/Support/StringSaver.h"34#include "llvm/Support/VCSRevision.h"35#include "llvm/Support/raw_ostream.h"36#include "llvm/TargetParser/Triple.h"37#include <cassert>38#include <string>39#include <utility>40#include <vector>41 42using namespace llvm;43using namespace irsymtab;44 45static cl::opt<bool> DisableBitcodeVersionUpgrade(46 "disable-bitcode-version-upgrade", cl::Hidden,47 cl::desc("Disable automatic bitcode upgrade for version mismatch"));48 49namespace {50 51const char *getExpectedProducerName() {52 static char DefaultName[] = LLVM_VERSION_STRING53#ifdef LLVM_REVISION54 " " LLVM_REVISION55#endif56 ;57 // Allows for testing of the irsymtab writer and upgrade mechanism. This58 // environment variable should not be set by users.59 if (char *OverrideName = getenv("LLVM_OVERRIDE_PRODUCER"))60 return OverrideName;61 return DefaultName;62}63 64const char *kExpectedProducerName = getExpectedProducerName();65 66/// Stores the temporary state that is required to build an IR symbol table.67struct Builder {68 SmallVector<char, 0> &Symtab;69 StringTableBuilder &StrtabBuilder;70 StringSaver Saver;71 72 // This ctor initializes a StringSaver using the passed in BumpPtrAllocator.73 // The StringTableBuilder does not create a copy of any strings added to it,74 // so this provides somewhere to store any strings that we create.75 Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,76 BumpPtrAllocator &Alloc, const Triple &TT)77 : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc), TT(TT),78 Libcalls(TT) {}79 80 DenseMap<const Comdat *, int> ComdatMap;81 Mangler Mang;82 const Triple &TT;83 84 // FIXME: This shouldn't be here.85 RTLIB::RuntimeLibcallsInfo Libcalls;86 87 std::vector<storage::Comdat> Comdats;88 std::vector<storage::Module> Mods;89 std::vector<storage::Symbol> Syms;90 std::vector<storage::Uncommon> Uncommons;91 92 std::string COFFLinkerOpts;93 raw_string_ostream COFFLinkerOptsOS{COFFLinkerOpts};94 95 std::vector<storage::Str> DependentLibraries;96 97 bool isPreservedName(StringRef Name) {98 return Libcalls.getSupportedLibcallImpl(Name) != RTLIB::Unsupported;99 }100 101 void setStr(storage::Str &S, StringRef Value) {102 S.Offset = StrtabBuilder.add(Value);103 S.Size = Value.size();104 }105 106 template <typename T>107 void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {108 R.Offset = Symtab.size();109 R.Size = Objs.size();110 Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),111 reinterpret_cast<const char *>(Objs.data() + Objs.size()));112 }113 114 Expected<int> getComdatIndex(const Comdat *C, const Module *M);115 116 Error addModule(Module *M);117 Error addSymbol(const ModuleSymbolTable &Msymtab,118 const SmallPtrSet<GlobalValue *, 4> &Used,119 ModuleSymbolTable::Symbol Sym);120 121 Error build(ArrayRef<Module *> Mods);122};123 124Error Builder::addModule(Module *M) {125 if (M->getDataLayoutStr().empty())126 return make_error<StringError>("input module has no datalayout",127 inconvertibleErrorCode());128 129 // Symbols in the llvm.used list will get the FB_Used bit and will not be130 // internalized. We do this for llvm.compiler.used as well:131 //132 // IR symbol table tracks module-level asm symbol references but not inline133 // asm. A symbol only referenced by inline asm is not in the IR symbol table,134 // so we may not know that the definition (in another translation unit) is135 // referenced. That definition may have __attribute__((used)) (which lowers to136 // llvm.compiler.used on ELF targets) to communicate to the compiler that it137 // may be used by inline asm. The usage is perfectly fine, so we treat138 // llvm.compiler.used conservatively as llvm.used to work around our own139 // limitation.140 SmallVector<GlobalValue *, 4> UsedV;141 collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/false);142 collectUsedGlobalVariables(*M, UsedV, /*CompilerUsed=*/true);143 SmallPtrSet<GlobalValue *, 4> Used(llvm::from_range, UsedV);144 145 ModuleSymbolTable Msymtab;146 Msymtab.addModule(M);147 148 storage::Module Mod;149 Mod.Begin = Syms.size();150 Mod.End = Syms.size() + Msymtab.symbols().size();151 Mod.UncBegin = Uncommons.size();152 Mods.push_back(Mod);153 154 if (TT.isOSBinFormatCOFF()) {155 if (auto E = M->materializeMetadata())156 return E;157 if (NamedMDNode *LinkerOptions =158 M->getNamedMetadata("llvm.linker.options")) {159 for (MDNode *MDOptions : LinkerOptions->operands())160 for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())161 COFFLinkerOptsOS << " " << cast<MDString>(MDOption)->getString();162 }163 }164 165 if (TT.isOSBinFormatELF()) {166 if (auto E = M->materializeMetadata())167 return E;168 if (NamedMDNode *N = M->getNamedMetadata("llvm.dependent-libraries")) {169 for (MDNode *MDOptions : N->operands()) {170 const auto OperandStr =171 cast<MDString>(cast<MDNode>(MDOptions)->getOperand(0))->getString();172 storage::Str Specifier;173 setStr(Specifier, OperandStr);174 DependentLibraries.emplace_back(Specifier);175 }176 }177 }178 179 for (ModuleSymbolTable::Symbol Msym : Msymtab.symbols())180 if (Error Err = addSymbol(Msymtab, Used, Msym))181 return Err;182 183 return Error::success();184}185 186Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {187 auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));188 if (P.second) {189 std::string Name;190 if (TT.isOSBinFormatCOFF()) {191 const GlobalValue *GV = M->getNamedValue(C->getName());192 if (!GV)193 return make_error<StringError>("Could not find leader",194 inconvertibleErrorCode());195 // Internal leaders do not affect symbol resolution, therefore they do not196 // appear in the symbol table.197 if (GV->hasLocalLinkage()) {198 P.first->second = -1;199 return -1;200 }201 llvm::raw_string_ostream OS(Name);202 Mang.getNameWithPrefix(OS, GV, false);203 } else {204 Name = std::string(C->getName());205 }206 207 storage::Comdat Comdat;208 setStr(Comdat.Name, Saver.save(Name));209 Comdat.SelectionKind = C->getSelectionKind();210 Comdats.push_back(Comdat);211 }212 213 return P.first->second;214}215 216Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,217 const SmallPtrSet<GlobalValue *, 4> &Used,218 ModuleSymbolTable::Symbol Msym) {219 Syms.emplace_back();220 storage::Symbol &Sym = Syms.back();221 Sym = {};222 223 storage::Uncommon *Unc = nullptr;224 auto Uncommon = [&]() -> storage::Uncommon & {225 if (Unc)226 return *Unc;227 Sym.Flags |= 1 << storage::Symbol::FB_has_uncommon;228 Uncommons.emplace_back();229 Unc = &Uncommons.back();230 *Unc = {};231 setStr(Unc->COFFWeakExternFallbackName, "");232 setStr(Unc->SectionName, "");233 return *Unc;234 };235 236 SmallString<64> Name;237 {238 raw_svector_ostream OS(Name);239 Msymtab.printSymbolName(OS, Msym);240 }241 setStr(Sym.Name, Saver.save(Name.str()));242 243 auto Flags = Msymtab.getSymbolFlags(Msym);244 if (Flags & object::BasicSymbolRef::SF_Undefined)245 Sym.Flags |= 1 << storage::Symbol::FB_undefined;246 if (Flags & object::BasicSymbolRef::SF_Weak)247 Sym.Flags |= 1 << storage::Symbol::FB_weak;248 if (Flags & object::BasicSymbolRef::SF_Common)249 Sym.Flags |= 1 << storage::Symbol::FB_common;250 if (Flags & object::BasicSymbolRef::SF_Indirect)251 Sym.Flags |= 1 << storage::Symbol::FB_indirect;252 if (Flags & object::BasicSymbolRef::SF_Global)253 Sym.Flags |= 1 << storage::Symbol::FB_global;254 if (Flags & object::BasicSymbolRef::SF_FormatSpecific)255 Sym.Flags |= 1 << storage::Symbol::FB_format_specific;256 if (Flags & object::BasicSymbolRef::SF_Executable)257 Sym.Flags |= 1 << storage::Symbol::FB_executable;258 259 Sym.ComdatIndex = -1;260 auto *GV = dyn_cast_if_present<GlobalValue *>(Msym);261 if (!GV) {262 // Undefined module asm symbols act as GC roots and are implicitly used.263 if (Flags & object::BasicSymbolRef::SF_Undefined)264 Sym.Flags |= 1 << storage::Symbol::FB_used;265 setStr(Sym.IRName, "");266 return Error::success();267 }268 269 StringRef GVName = GV->getName();270 setStr(Sym.IRName, GVName);271 272 if (Used.count(GV) || isPreservedName(GVName))273 Sym.Flags |= 1 << storage::Symbol::FB_used;274 if (GV->isThreadLocal())275 Sym.Flags |= 1 << storage::Symbol::FB_tls;276 if (GV->hasGlobalUnnamedAddr())277 Sym.Flags |= 1 << storage::Symbol::FB_unnamed_addr;278 if (GV->canBeOmittedFromSymbolTable())279 Sym.Flags |= 1 << storage::Symbol::FB_may_omit;280 Sym.Flags |= unsigned(GV->getVisibility()) << storage::Symbol::FB_visibility;281 282 if (Flags & object::BasicSymbolRef::SF_Common) {283 auto *GVar = dyn_cast<GlobalVariable>(GV);284 if (!GVar)285 return make_error<StringError>("Only variables can have common linkage!",286 inconvertibleErrorCode());287 Uncommon().CommonSize =288 GV->getDataLayout().getTypeAllocSize(GV->getValueType());289 Uncommon().CommonAlign = GVar->getAlign() ? GVar->getAlign()->value() : 0;290 }291 292 const GlobalObject *GO = GV->getAliaseeObject();293 if (!GO) {294 if (isa<GlobalIFunc>(GV))295 GO = cast<GlobalIFunc>(GV)->getResolverFunction();296 if (!GO)297 return make_error<StringError>("Unable to determine comdat of alias!",298 inconvertibleErrorCode());299 }300 if (const Comdat *C = GO->getComdat()) {301 Expected<int> ComdatIndexOrErr = getComdatIndex(C, GV->getParent());302 if (!ComdatIndexOrErr)303 return ComdatIndexOrErr.takeError();304 Sym.ComdatIndex = *ComdatIndexOrErr;305 }306 307 if (TT.isOSBinFormatCOFF()) {308 emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);309 310 if ((Flags & object::BasicSymbolRef::SF_Weak) &&311 (Flags & object::BasicSymbolRef::SF_Indirect)) {312 auto *Fallback = dyn_cast<GlobalValue>(313 cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts());314 if (!Fallback)315 return make_error<StringError>("Invalid weak external",316 inconvertibleErrorCode());317 std::string FallbackName;318 raw_string_ostream OS(FallbackName);319 Msymtab.printSymbolName(OS, Fallback);320 OS.flush();321 setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));322 }323 }324 325 if (!GO->getSection().empty())326 setStr(Uncommon().SectionName, Saver.save(GO->getSection()));327 328 return Error::success();329}330 331Error Builder::build(ArrayRef<Module *> IRMods) {332 storage::Header Hdr;333 334 assert(!IRMods.empty());335 Hdr.Version = storage::Header::kCurrentVersion;336 setStr(Hdr.Producer, kExpectedProducerName);337 setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple().str());338 setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());339 340 for (auto *M : IRMods)341 if (Error Err = addModule(M))342 return Err;343 344 COFFLinkerOptsOS.flush();345 setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));346 347 // We are about to fill in the header's range fields, so reserve space for it348 // and copy it in afterwards.349 Symtab.resize(sizeof(storage::Header));350 writeRange(Hdr.Modules, Mods);351 writeRange(Hdr.Comdats, Comdats);352 writeRange(Hdr.Symbols, Syms);353 writeRange(Hdr.Uncommons, Uncommons);354 writeRange(Hdr.DependentLibraries, DependentLibraries);355 *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;356 return Error::success();357}358 359} // end anonymous namespace360 361Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,362 StringTableBuilder &StrtabBuilder,363 BumpPtrAllocator &Alloc) {364 const Triple &TT = Mods[0]->getTargetTriple();365 return Builder(Symtab, StrtabBuilder, Alloc, TT).build(Mods);366}367 368// Upgrade a vector of bitcode modules created by an old version of LLVM by369// creating an irsymtab for them in the current format.370static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {371 FileContents FC;372 373 LLVMContext Ctx;374 std::vector<Module *> Mods;375 std::vector<std::unique_ptr<Module>> OwnedMods;376 for (auto BM : BMs) {377 Expected<std::unique_ptr<Module>> MOrErr =378 BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,379 /*IsImporting*/ false);380 if (!MOrErr)381 return MOrErr.takeError();382 383 Mods.push_back(MOrErr->get());384 OwnedMods.push_back(std::move(*MOrErr));385 }386 387 StringTableBuilder StrtabBuilder(StringTableBuilder::RAW);388 BumpPtrAllocator Alloc;389 if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))390 return std::move(E);391 392 StrtabBuilder.finalizeInOrder();393 FC.Strtab.resize(StrtabBuilder.getSize());394 StrtabBuilder.write((uint8_t *)FC.Strtab.data());395 396 FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},397 {FC.Strtab.data(), FC.Strtab.size()}};398 return std::move(FC);399}400 401Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {402 if (BFC.Mods.empty())403 return make_error<StringError>("Bitcode file does not contain any modules",404 inconvertibleErrorCode());405 406 if (!DisableBitcodeVersionUpgrade) {407 if (BFC.StrtabForSymtab.empty() ||408 BFC.Symtab.size() < sizeof(storage::Header))409 return upgrade(BFC.Mods);410 411 // We cannot use the regular reader to read the version and producer,412 // because it will expect the header to be in the current format. The only413 // thing we can rely on is that the version and producer will be present as414 // the first struct elements.415 auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());416 unsigned Version = Hdr->Version;417 StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);418 if (Version != storage::Header::kCurrentVersion ||419 Producer != kExpectedProducerName)420 return upgrade(BFC.Mods);421 }422 423 FileContents FC;424 FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},425 {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};426 427 // Finally, make sure that the number of modules in the symbol table matches428 // the number of modules in the bitcode file. If they differ, it may mean that429 // the bitcode file was created by binary concatenation, so we need to create430 // a new symbol table from scratch.431 if (FC.TheReader.getNumModules() != BFC.Mods.size())432 return upgrade(std::move(BFC.Mods));433 434 return std::move(FC);435}436