lib/Object/ModuleSymbolTable.cpp

   1 //===- ModuleSymbolTable.cpp - symbol table for in-memory IR --------------===//
   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 // This class represents a symbol table built from in-memory IR. It provides
  11 // access to GlobalValues and should only be used if such access is required
  12 // (e.g. in the LTO implementation).
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "llvm/Object/ModuleSymbolTable.h"
  17 #include "RecordStreamer.h"
  18 #include "llvm/ADT/STLExtras.h"
  19 #include "llvm/ADT/SmallString.h"
  20 #include "llvm/ADT/StringMap.h"
  21 #include "llvm/ADT/StringRef.h"
  22 #include "llvm/ADT/Triple.h"
  23 #include "llvm/IR/Function.h"
  24 #include "llvm/IR/GlobalAlias.h"
  25 #include "llvm/IR/GlobalValue.h"
  26 #include "llvm/IR/GlobalVariable.h"
  27 #include "llvm/IR/Mangler.h"
  28 #include "llvm/IR/Module.h"
  29 #include "llvm/MC/MCAsmInfo.h"
  30 #include "llvm/MC/MCContext.h"
  31 #include "llvm/MC/MCDirectives.h"
  32 #include "llvm/MC/MCInstrInfo.h"
  33 #include "llvm/MC/MCObjectFileInfo.h"
  34 #include "llvm/MC/MCParser/MCAsmParser.h"
  35 #include "llvm/MC/MCParser/MCTargetAsmParser.h"
  36 #include "llvm/MC/MCRegisterInfo.h"
  37 #include "llvm/MC/MCSubtargetInfo.h"
  38 #include "llvm/MC/MCSymbol.h"
  39 #include "llvm/MC/MCTargetOptions.h"
  40 #include "llvm/Object/SymbolicFile.h"
  41 #include "llvm/Support/Casting.h"
  42 #include "llvm/Support/CodeGen.h"
  43 #include "llvm/Support/ErrorHandling.h"
  44 #include "llvm/Support/MemoryBuffer.h"
  45 #include "llvm/Support/SMLoc.h"
  46 #include "llvm/Support/SourceMgr.h"
  47 #include "llvm/Support/TargetRegistry.h"
  48 #include "llvm/Support/raw_ostream.h"
  49 #include <algorithm>
  50 #include <cassert>
  51 #include <cstdint>
  52 #include <memory>
  53 #include <string>
  54
  55 using namespace llvm;
  56 using namespace object;
  57
  58 void ModuleSymbolTable::addModule(Module *M) {
  59   if (FirstMod)
  60     assert(FirstMod->getTargetTriple() == M->getTargetTriple());
  61   else
  62     FirstMod = M;
  63
  64   for (GlobalValue &GV : M->global_values())
  65     SymTab.push_back(&GV);
  66
  67   CollectAsmSymbols(*M, [this](StringRef Name, BasicSymbolRef::Flags Flags) {
  68     SymTab.push_back(new (AsmSymbols.Allocate()) AsmSymbol(Name, Flags));
  69   });
  70 }
  71
  72 // Ensure ELF .symver aliases get the same binding as the defined symbol
  73 // they alias with.
  74 static void handleSymverAliases(const Module &M, RecordStreamer &Streamer) {
  75   if (Streamer.symverAliases().empty())
  76     return;
  77
  78   // The name in the assembler will be mangled, but the name in the IR
  79   // might not, so we first compute a mapping from mangled name to GV.
  80   Mangler Mang;
  81   SmallString<64> MangledName;
  82   StringMap<const GlobalValue *> MangledNameMap;
  83   auto GetMangledName = [&](const GlobalValue &GV) {
  84     if (!GV.hasName())
  85       return;
  86
  87     MangledName.clear();
  88     MangledName.reserve(GV.getName().size() + 1);
  89     Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
  90     MangledNameMap[MangledName] = &GV;
  91   };
  92   for (const Function &F : M)
  93     GetMangledName(F);
  94   for (const GlobalVariable &GV : M.globals())
  95     GetMangledName(GV);
  96   for (const GlobalAlias &GA : M.aliases())
  97     GetMangledName(GA);
  98
  99   // Walk all the recorded .symver aliases, and set up the binding
 100   // for each alias.
 101   for (auto &Symver : Streamer.symverAliases()) {
 102     const MCSymbol *Aliasee = Symver.first;
 103     MCSymbolAttr Attr = MCSA_Invalid;
 104
 105     // First check if the aliasee binding was recorded in the asm.
 106     RecordStreamer::State state = Streamer.getSymbolState(Aliasee);
 107     switch (state) {
 108     case RecordStreamer::Global:
 109     case RecordStreamer::DefinedGlobal:
 110       Attr = MCSA_Global;
 111       break;
 112     case RecordStreamer::UndefinedWeak:
 113     case RecordStreamer::DefinedWeak:
 114       Attr = MCSA_Weak;
 115       break;
 116     default:
 117       break;
 118     }
 119
 120     // If we don't have a symbol attribute from assembly, then check if
 121     // the aliasee was defined in the IR.
 122     if (Attr == MCSA_Invalid) {
 123       const auto *GV = M.getNamedValue(Aliasee->getName());
 124       if (!GV) {
 125         auto MI = MangledNameMap.find(Aliasee->getName());
 126         if (MI != MangledNameMap.end())
 127           GV = MI->second;
 128         else
 129           continue;
 130       }
 131       if (GV->hasExternalLinkage())
 132         Attr = MCSA_Global;
 133       else if (GV->hasLocalLinkage())
 134         Attr = MCSA_Local;
 135       else if (GV->isWeakForLinker())
 136         Attr = MCSA_Weak;
 137     }
 138     if (Attr == MCSA_Invalid)
 139       continue;
 140
 141     // Set the detected binding on each alias with this aliasee.
 142     for (auto &Alias : Symver.second)
 143       Streamer.EmitSymbolAttribute(Alias, Attr);
 144   }
 145 }
 146
 147 void ModuleSymbolTable::CollectAsmSymbols(
 148     const Module &M,
 149     function_ref<void(StringRef, BasicSymbolRef::Flags)> AsmSymbol) {
 150   StringRef InlineAsm = M.getModuleInlineAsm();
 151   if (InlineAsm.empty())
 152     return;
 153
 154   std::string Err;
 155   const Triple TT(M.getTargetTriple());
 156   const Target *T = TargetRegistry::lookupTarget(TT.str(), Err);
 157   assert(T && T->hasMCAsmParser());
 158
 159   std::unique_ptr<MCRegisterInfo> MRI(T->createMCRegInfo(TT.str()));
 160   if (!MRI)
 161     return;
 162
 163   std::unique_ptr<MCAsmInfo> MAI(T->createMCAsmInfo(*MRI, TT.str()));
 164   if (!MAI)
 165     return;
 166
 167   std::unique_ptr<MCSubtargetInfo> STI(
 168       T->createMCSubtargetInfo(TT.str(), "", ""));
 169   if (!STI)
 170     return;
 171
 172   std::unique_ptr<MCInstrInfo> MCII(T->createMCInstrInfo());
 173   if (!MCII)
 174     return;
 175
 176   MCObjectFileInfo MOFI;
 177   MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
 178   MOFI.InitMCObjectFileInfo(TT, /*PIC*/ false, MCCtx);
 179   RecordStreamer Streamer(MCCtx);
 180   T->createNullTargetStreamer(Streamer);
 181
 182   std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));
 183   SourceMgr SrcMgr;
 184   SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
 185   std::unique_ptr<MCAsmParser> Parser(
 186       createMCAsmParser(SrcMgr, MCCtx, Streamer, *MAI));
 187
 188   MCTargetOptions MCOptions;
 189   std::unique_ptr<MCTargetAsmParser> TAP(
 190       T->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
 191   if (!TAP)
 192     return;
 193
 194   Parser->setTargetParser(*TAP);
 195   if (Parser->Run(false))
 196     return;
 197
 198   handleSymverAliases(M, Streamer);
 199
 200   for (auto &KV : Streamer) {
 201     StringRef Key = KV.first();
 202     RecordStreamer::State Value = KV.second;
 203     // FIXME: For now we just assume that all asm symbols are executable.
 204     uint32_t Res = BasicSymbolRef::SF_Executable;
 205     switch (Value) {
 206     case RecordStreamer::NeverSeen:
 207       llvm_unreachable("NeverSeen should have been replaced earlier");
 208     case RecordStreamer::DefinedGlobal:
 209       Res |= BasicSymbolRef::SF_Global;
 210       break;
 211     case RecordStreamer::Defined:
 212       break;
 213     case RecordStreamer::Global:
 214     case RecordStreamer::Used:
 215       Res |= BasicSymbolRef::SF_Undefined;
 216       Res |= BasicSymbolRef::SF_Global;
 217       break;
 218     case RecordStreamer::DefinedWeak:
 219       Res |= BasicSymbolRef::SF_Weak;
 220       Res |= BasicSymbolRef::SF_Global;
 221       break;
 222     case RecordStreamer::UndefinedWeak:
 223       Res |= BasicSymbolRef::SF_Weak;
 224       Res |= BasicSymbolRef::SF_Undefined;
 225     }
 226     AsmSymbol(Key, BasicSymbolRef::Flags(Res));
 227   }
 228 }
 229
 230 void ModuleSymbolTable::printSymbolName(raw_ostream &OS, Symbol S) const {
 231   if (S.is<AsmSymbol *>()) {
 232     OS << S.get<AsmSymbol *>()->first;
 233     return;
 234   }
 235
 236   auto *GV = S.get<GlobalValue *>();
 237   if (GV->hasDLLImportStorageClass())
 238     OS << "__imp_";
 239
 240   Mang.getNameWithPrefix(OS, GV, false);
 241 }
 242
 243 uint32_t ModuleSymbolTable::getSymbolFlags(Symbol S) const {
 244   if (S.is<AsmSymbol *>())
 245     return S.get<AsmSymbol *>()->second;
 246
 247   auto *GV = S.get<GlobalValue *>();
 248
 249   uint32_t Res = BasicSymbolRef::SF_None;
 250   if (GV->isDeclarationForLinker())
 251     Res |= BasicSymbolRef::SF_Undefined;
 252   else if (GV->hasHiddenVisibility() && !GV->hasLocalLinkage())
 253     Res |= BasicSymbolRef::SF_Hidden;
 254   if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
 255     if (GVar->isConstant())
 256       Res |= BasicSymbolRef::SF_Const;
 257   }
 258   if (dyn_cast_or_null<Function>(GV->getBaseObject()))
 259     Res |= BasicSymbolRef::SF_Executable;
 260   if (isa<GlobalAlias>(GV))
 261     Res |= BasicSymbolRef::SF_Indirect;
 262   if (GV->hasPrivateLinkage())
 263     Res |= BasicSymbolRef::SF_FormatSpecific;
 264   if (!GV->hasLocalLinkage())
 265     Res |= BasicSymbolRef::SF_Global;
 266   if (GV->hasCommonLinkage())
 267     Res |= BasicSymbolRef::SF_Common;
 268   if (GV->hasLinkOnceLinkage() || GV->hasWeakLinkage() ||
 269       GV->hasExternalWeakLinkage())
 270     Res |= BasicSymbolRef::SF_Weak;
 271
 272   if (GV->getName().startswith("llvm."))
 273     Res |= BasicSymbolRef::SF_FormatSpecific;
 274   else if (auto *Var = dyn_cast<GlobalVariable>(GV)) {
 275     if (Var->getSection() == "llvm.metadata")
 276       Res |= BasicSymbolRef::SF_FormatSpecific;
 277   }
 278
 279   return Res;
 280 }