contrib/llvm/lib/Object/IRSymtab.cpp

   1 //===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "llvm/Object/IRSymtab.h"
  11 #include "llvm/ADT/ArrayRef.h"
  12 #include "llvm/ADT/DenseMap.h"
  13 #include "llvm/ADT/SmallPtrSet.h"
  14 #include "llvm/ADT/SmallString.h"
  15 #include "llvm/ADT/SmallVector.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/Triple.h"
  18 #include "llvm/Analysis/ObjectUtils.h"
  19 #include "llvm/IR/Comdat.h"
  20 #include "llvm/IR/DataLayout.h"
  21 #include "llvm/IR/GlobalAlias.h"
  22 #include "llvm/IR/GlobalObject.h"
  23 #include "llvm/IR/Mangler.h"
  24 #include "llvm/IR/Metadata.h"
  25 #include "llvm/IR/Module.h"
  26 #include "llvm/Bitcode/BitcodeReader.h"
  27 #include "llvm/MC/StringTableBuilder.h"
  28 #include "llvm/Object/IRObjectFile.h"
  29 #include "llvm/Object/ModuleSymbolTable.h"
  30 #include "llvm/Object/SymbolicFile.h"
  31 #include "llvm/Support/Allocator.h"
  32 #include "llvm/Support/Casting.h"
  33 #include "llvm/Support/Error.h"
  34 #include "llvm/Support/StringSaver.h"
  35 #include "llvm/Support/raw_ostream.h"
  36 #include <cassert>
  37 #include <string>
  38 #include <utility>
  39 #include <vector>
  40
  41 using namespace llvm;
  42 using namespace irsymtab;
  43
  44 namespace {
  45
  46 /// Stores the temporary state that is required to build an IR symbol table.
  47 struct Builder {
  48   SmallVector<char, 0> &Symtab;
  49   SmallVector<char, 0> &Strtab;
  50
  51   Builder(SmallVector<char, 0> &Symtab, SmallVector<char, 0> &Strtab)
  52       : Symtab(Symtab), Strtab(Strtab) {}
  53
  54   StringTableBuilder StrtabBuilder{StringTableBuilder::RAW};
  55
  56   BumpPtrAllocator Alloc;
  57   StringSaver Saver{Alloc};
  58
  59   DenseMap<const Comdat *, unsigned> ComdatMap;
  60   Mangler Mang;
  61   Triple TT;
  62
  63   std::vector<storage::Comdat> Comdats;
  64   std::vector<storage::Module> Mods;
  65   std::vector<storage::Symbol> Syms;
  66   std::vector<storage::Uncommon> Uncommons;
  67
  68   std::string COFFLinkerOpts;
  69   raw_string_ostream COFFLinkerOptsOS{COFFLinkerOpts};
  70
  71   void setStr(storage::Str &S, StringRef Value) {
  72     S.Offset = StrtabBuilder.add(Value);
  73     S.Size = Value.size();
  74   }
  75
  76   template <typename T>
  77   void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
  78     R.Offset = Symtab.size();
  79     R.Size = Objs.size();
  80     Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
  81                   reinterpret_cast<const char *>(Objs.data() + Objs.size()));
  82   }
  83
  84   Error addModule(Module *M);
  85   Error addSymbol(const ModuleSymbolTable &Msymtab,
  86                   const SmallPtrSet<GlobalValue *, 8> &Used,
  87                   ModuleSymbolTable::Symbol Sym);
  88
  89   Error build(ArrayRef<Module *> Mods);
  90 };
  91
  92 Error Builder::addModule(Module *M) {
  93   if (M->getDataLayoutStr().empty())
  94     return make_error<StringError>("input module has no datalayout",
  95                                    inconvertibleErrorCode());
  96
  97   SmallPtrSet<GlobalValue *, 8> Used;
  98   collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false);
  99
 100   ModuleSymbolTable Msymtab;
 101   Msymtab.addModule(M);
 102
 103   storage::Module Mod;
 104   Mod.Begin = Syms.size();
 105   Mod.End = Syms.size() + Msymtab.symbols().size();
 106   Mod.UncBegin = Uncommons.size();
 107   Mods.push_back(Mod);
 108
 109   if (TT.isOSBinFormatCOFF()) {
 110     if (auto E = M->materializeMetadata())
 111       return E;
 112     if (Metadata *Val = M->getModuleFlag("Linker Options")) {
 113       MDNode *LinkerOptions = cast<MDNode>(Val);
 114       for (const MDOperand &MDOptions : LinkerOptions->operands())
 115         for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())
 116           COFFLinkerOptsOS << " " << cast<MDString>(MDOption)->getString();
 117     }
 118   }
 119
 120   for (ModuleSymbolTable::Symbol Msym : Msymtab.symbols())
 121     if (Error Err = addSymbol(Msymtab, Used, Msym))
 122       return Err;
 123
 124   return Error::success();
 125 }
 126
 127 Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
 128                          const SmallPtrSet<GlobalValue *, 8> &Used,
 129                          ModuleSymbolTable::Symbol Msym) {
 130   Syms.emplace_back();
 131   storage::Symbol &Sym = Syms.back();
 132   Sym = {};
 133
 134   storage::Uncommon *Unc = nullptr;
 135   auto Uncommon = [&]() -> storage::Uncommon & {
 136     if (Unc)
 137       return *Unc;
 138     Sym.Flags |= 1 << storage::Symbol::FB_has_uncommon;
 139     Uncommons.emplace_back();
 140     Unc = &Uncommons.back();
 141     *Unc = {};
 142     setStr(Unc->COFFWeakExternFallbackName, "");
 143     return *Unc;
 144   };
 145
 146   SmallString<64> Name;
 147   {
 148     raw_svector_ostream OS(Name);
 149     Msymtab.printSymbolName(OS, Msym);
 150   }
 151   setStr(Sym.Name, Saver.save(StringRef(Name)));
 152
 153   auto Flags = Msymtab.getSymbolFlags(Msym);
 154   if (Flags & object::BasicSymbolRef::SF_Undefined)
 155     Sym.Flags |= 1 << storage::Symbol::FB_undefined;
 156   if (Flags & object::BasicSymbolRef::SF_Weak)
 157     Sym.Flags |= 1 << storage::Symbol::FB_weak;
 158   if (Flags & object::BasicSymbolRef::SF_Common)
 159     Sym.Flags |= 1 << storage::Symbol::FB_common;
 160   if (Flags & object::BasicSymbolRef::SF_Indirect)
 161     Sym.Flags |= 1 << storage::Symbol::FB_indirect;
 162   if (Flags & object::BasicSymbolRef::SF_Global)
 163     Sym.Flags |= 1 << storage::Symbol::FB_global;
 164   if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
 165     Sym.Flags |= 1 << storage::Symbol::FB_format_specific;
 166   if (Flags & object::BasicSymbolRef::SF_Executable)
 167     Sym.Flags |= 1 << storage::Symbol::FB_executable;
 168
 169   Sym.ComdatIndex = -1;
 170   auto *GV = Msym.dyn_cast<GlobalValue *>();
 171   if (!GV) {
 172     // Undefined module asm symbols act as GC roots and are implicitly used.
 173     if (Flags & object::BasicSymbolRef::SF_Undefined)
 174       Sym.Flags |= 1 << storage::Symbol::FB_used;
 175     setStr(Sym.IRName, "");
 176     return Error::success();
 177   }
 178
 179   setStr(Sym.IRName, GV->getName());
 180
 181   if (Used.count(GV))
 182     Sym.Flags |= 1 << storage::Symbol::FB_used;
 183   if (GV->isThreadLocal())
 184     Sym.Flags |= 1 << storage::Symbol::FB_tls;
 185   if (GV->hasGlobalUnnamedAddr())
 186     Sym.Flags |= 1 << storage::Symbol::FB_unnamed_addr;
 187   if (canBeOmittedFromSymbolTable(GV))
 188     Sym.Flags |= 1 << storage::Symbol::FB_may_omit;
 189   Sym.Flags |= unsigned(GV->getVisibility()) << storage::Symbol::FB_visibility;
 190
 191   if (Flags & object::BasicSymbolRef::SF_Common) {
 192     Uncommon().CommonSize = GV->getParent()->getDataLayout().getTypeAllocSize(
 193         GV->getType()->getElementType());
 194     Uncommon().CommonAlign = GV->getAlignment();
 195   }
 196
 197   const GlobalObject *Base = GV->getBaseObject();
 198   if (!Base)
 199     return make_error<StringError>("Unable to determine comdat of alias!",
 200                                    inconvertibleErrorCode());
 201   if (const Comdat *C = Base->getComdat()) {
 202     auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));
 203     Sym.ComdatIndex = P.first->second;
 204
 205     if (P.second) {
 206       storage::Comdat Comdat;
 207       setStr(Comdat.Name, C->getName());
 208       Comdats.push_back(Comdat);
 209     }
 210   }
 211
 212   if (TT.isOSBinFormatCOFF()) {
 213     emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);
 214
 215     if ((Flags & object::BasicSymbolRef::SF_Weak) &&
 216         (Flags & object::BasicSymbolRef::SF_Indirect)) {
 217       std::string FallbackName;
 218       raw_string_ostream OS(FallbackName);
 219       Msymtab.printSymbolName(
 220           OS, cast<GlobalValue>(
 221                   cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts()));
 222       OS.flush();
 223       setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
 224     }
 225   }
 226
 227   return Error::success();
 228 }
 229
 230 Error Builder::build(ArrayRef<Module *> IRMods) {
 231   storage::Header Hdr;
 232
 233   assert(!IRMods.empty());
 234   setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
 235   setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
 236   TT = Triple(IRMods[0]->getTargetTriple());
 237
 238   for (auto *M : IRMods)
 239     if (Error Err = addModule(M))
 240       return Err;
 241
 242   COFFLinkerOptsOS.flush();
 243   setStr(Hdr.COFFLinkerOpts, COFFLinkerOpts);
 244
 245   // We are about to fill in the header's range fields, so reserve space for it
 246   // and copy it in afterwards.
 247   Symtab.resize(sizeof(storage::Header));
 248   writeRange(Hdr.Modules, Mods);
 249   writeRange(Hdr.Comdats, Comdats);
 250   writeRange(Hdr.Symbols, Syms);
 251   writeRange(Hdr.Uncommons, Uncommons);
 252
 253   *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
 254
 255   raw_svector_ostream OS(Strtab);
 256   StrtabBuilder.finalizeInOrder();
 257   StrtabBuilder.write(OS);
 258
 259   return Error::success();
 260 }
 261
 262 } // end anonymous namespace
 263
 264 Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
 265                       SmallVector<char, 0> &Strtab) {
 266   return Builder(Symtab, Strtab).build(Mods);
 267 }
 268
 269 // Upgrade a vector of bitcode modules created by an old version of LLVM by
 270 // creating an irsymtab for them in the current format.
 271 static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {
 272   FileContents FC;
 273
 274   LLVMContext Ctx;
 275   std::vector<Module *> Mods;
 276   std::vector<std::unique_ptr<Module>> OwnedMods;
 277   for (auto BM : BMs) {
 278     Expected<std::unique_ptr<Module>> MOrErr =
 279         BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,
 280                          /*IsImporting*/ false);
 281     if (!MOrErr)
 282       return MOrErr.takeError();
 283
 284     Mods.push_back(MOrErr->get());
 285     OwnedMods.push_back(std::move(*MOrErr));
 286   }
 287
 288   if (Error E = build(Mods, FC.Symtab, FC.Strtab))
 289     return std::move(E);
 290
 291   FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
 292                   {FC.Strtab.data(), FC.Strtab.size()}};
 293   return std::move(FC);
 294 }
 295
 296 Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
 297   if (BFC.Mods.empty())
 298     return make_error<StringError>("Bitcode file does not contain any modules",
 299                                    inconvertibleErrorCode());
 300
 301   // Right now we have no on-disk representation of symbol tables, so we always
 302   // upgrade.
 303   return upgrade(BFC.Mods);
 304 }