lib/Object/RecordStreamer.cpp

   1 //===-- RecordStreamer.cpp - Record asm defined and used symbols ----------===//
   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 "RecordStreamer.h"
  11 #include "llvm/IR/Mangler.h"
  12 #include "llvm/IR/Module.h"
  13 #include "llvm/MC/MCContext.h"
  14 #include "llvm/MC/MCSymbol.h"
  15
  16 using namespace llvm;
  17
  18 void RecordStreamer::markDefined(const MCSymbol &Symbol) {
  19   State &S = Symbols[Symbol.getName()];
  20   switch (S) {
  21   case DefinedGlobal:
  22   case Global:
  23     S = DefinedGlobal;
  24     break;
  25   case NeverSeen:
  26   case Defined:
  27   case Used:
  28     S = Defined;
  29     break;
  30   case DefinedWeak:
  31     break;
  32   case UndefinedWeak:
  33     S = DefinedWeak;
  34   }
  35 }
  36
  37 void RecordStreamer::markGlobal(const MCSymbol &Symbol,
  38                                 MCSymbolAttr Attribute) {
  39   State &S = Symbols[Symbol.getName()];
  40   switch (S) {
  41   case DefinedGlobal:
  42   case Defined:
  43     S = (Attribute == MCSA_Weak) ? DefinedWeak : DefinedGlobal;
  44     break;
  45
  46   case NeverSeen:
  47   case Global:
  48   case Used:
  49     S = (Attribute == MCSA_Weak) ? UndefinedWeak : Global;
  50     break;
  51   case UndefinedWeak:
  52   case DefinedWeak:
  53     break;
  54   }
  55 }
  56
  57 void RecordStreamer::markUsed(const MCSymbol &Symbol) {
  58   State &S = Symbols[Symbol.getName()];
  59   switch (S) {
  60   case DefinedGlobal:
  61   case Defined:
  62   case Global:
  63   case DefinedWeak:
  64   case UndefinedWeak:
  65     break;
  66
  67   case NeverSeen:
  68   case Used:
  69     S = Used;
  70     break;
  71   }
  72 }
  73
  74 void RecordStreamer::visitUsedSymbol(const MCSymbol &Sym) { markUsed(Sym); }
  75
  76 RecordStreamer::RecordStreamer(MCContext &Context, const Module &M)
  77     : MCStreamer(Context), M(M) {}
  78
  79 RecordStreamer::const_iterator RecordStreamer::begin() {
  80   return Symbols.begin();
  81 }
  82
  83 RecordStreamer::const_iterator RecordStreamer::end() { return Symbols.end(); }
  84
  85 void RecordStreamer::EmitInstruction(const MCInst &Inst,
  86                                      const MCSubtargetInfo &STI, bool) {
  87   MCStreamer::EmitInstruction(Inst, STI);
  88 }
  89
  90 void RecordStreamer::EmitLabel(MCSymbol *Symbol, SMLoc Loc) {
  91   MCStreamer::EmitLabel(Symbol);
  92   markDefined(*Symbol);
  93 }
  94
  95 void RecordStreamer::EmitAssignment(MCSymbol *Symbol, const MCExpr *Value) {
  96   markDefined(*Symbol);
  97   MCStreamer::EmitAssignment(Symbol, Value);
  98 }
  99
 100 bool RecordStreamer::EmitSymbolAttribute(MCSymbol *Symbol,
 101                                          MCSymbolAttr Attribute) {
 102   if (Attribute == MCSA_Global || Attribute == MCSA_Weak)
 103     markGlobal(*Symbol, Attribute);
 104   if (Attribute == MCSA_LazyReference)
 105     markUsed(*Symbol);
 106   return true;
 107 }
 108
 109 void RecordStreamer::EmitZerofill(MCSection *Section, MCSymbol *Symbol,
 110                                   uint64_t Size, unsigned ByteAlignment,
 111                                   SMLoc Loc) {
 112   markDefined(*Symbol);
 113 }
 114
 115 void RecordStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
 116                                       unsigned ByteAlignment) {
 117   markDefined(*Symbol);
 118 }
 119
 120 RecordStreamer::State RecordStreamer::getSymbolState(const MCSymbol *Sym) {
 121   auto SI = Symbols.find(Sym->getName());
 122   if (SI == Symbols.end())
 123     return NeverSeen;
 124   return SI->second;
 125 }
 126
 127 void RecordStreamer::emitELFSymverDirective(StringRef AliasName,
 128                                             const MCSymbol *Aliasee) {
 129   SymverAliasMap[Aliasee].push_back(AliasName);
 130 }
 131
 132 iterator_range<RecordStreamer::const_symver_iterator>
 133 RecordStreamer::symverAliases() {
 134   return {SymverAliasMap.begin(), SymverAliasMap.end()};
 135 }
 136
 137 void RecordStreamer::flushSymverDirectives() {
 138   // Mapping from mangled name to GV.
 139   StringMap<const GlobalValue *> MangledNameMap;
 140   // The name in the assembler will be mangled, but the name in the IR
 141   // might not, so we first compute a mapping from mangled name to GV.
 142   Mangler Mang;
 143   SmallString<64> MangledName;
 144   for (const GlobalValue &GV : M.global_values()) {
 145     if (!GV.hasName())
 146       continue;
 147     MangledName.clear();
 148     MangledName.reserve(GV.getName().size() + 1);
 149     Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
 150     MangledNameMap[MangledName] = &GV;
 151   }
 152
 153   // Walk all the recorded .symver aliases, and set up the binding
 154   // for each alias.
 155   for (auto &Symver : SymverAliasMap) {
 156     const MCSymbol *Aliasee = Symver.first;
 157     MCSymbolAttr Attr = MCSA_Invalid;
 158     bool IsDefined = false;
 159
 160     // First check if the aliasee binding was recorded in the asm.
 161     RecordStreamer::State state = getSymbolState(Aliasee);
 162     switch (state) {
 163     case RecordStreamer::Global:
 164     case RecordStreamer::DefinedGlobal:
 165       Attr = MCSA_Global;
 166       break;
 167     case RecordStreamer::UndefinedWeak:
 168     case RecordStreamer::DefinedWeak:
 169       Attr = MCSA_Weak;
 170       break;
 171     default:
 172       break;
 173     }
 174
 175     switch (state) {
 176     case RecordStreamer::Defined:
 177     case RecordStreamer::DefinedGlobal:
 178     case RecordStreamer::DefinedWeak:
 179       IsDefined = true;
 180       break;
 181     case RecordStreamer::NeverSeen:
 182     case RecordStreamer::Global:
 183     case RecordStreamer::Used:
 184     case RecordStreamer::UndefinedWeak:
 185       break;
 186     }
 187
 188     if (Attr == MCSA_Invalid || !IsDefined) {
 189       const GlobalValue *GV = M.getNamedValue(Aliasee->getName());
 190       if (!GV) {
 191         auto MI = MangledNameMap.find(Aliasee->getName());
 192         if (MI != MangledNameMap.end())
 193           GV = MI->second;
 194       }
 195       if (GV) {
 196         // If we don't have a symbol attribute from assembly, then check if
 197         // the aliasee was defined in the IR.
 198         if (Attr == MCSA_Invalid) {
 199           if (GV->hasExternalLinkage())
 200             Attr = MCSA_Global;
 201           else if (GV->hasLocalLinkage())
 202             Attr = MCSA_Local;
 203           else if (GV->isWeakForLinker())
 204             Attr = MCSA_Weak;
 205         }
 206         IsDefined = IsDefined || !GV->isDeclarationForLinker();
 207       }
 208     }
 209
 210     // Set the detected binding on each alias with this aliasee.
 211     for (auto AliasName : Symver.second) {
 212       std::pair<StringRef, StringRef> Split = AliasName.split("@@@");
 213       SmallString<128> NewName;
 214       if (!Split.second.empty() && !Split.second.startswith("@")) {
 215         // Special processing for "@@@" according
 216         // https://sourceware.org/binutils/docs/as/Symver.html
 217         const char *Separator = IsDefined ? "@@" : "@";
 218         AliasName =
 219             (Split.first + Separator + Split.second).toStringRef(NewName);
 220       }
 221       MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
 222       // TODO: Handle "@@@". Depending on SymbolAttribute value it needs to be
 223       // converted into @ or @@.
 224       const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
 225       if (IsDefined)
 226         markDefined(*Alias);
 227       // Don't use EmitAssignment override as it always marks alias as defined.
 228       MCStreamer::EmitAssignment(Alias, Value);
 229       if (Attr != MCSA_Invalid)
 230         EmitSymbolAttribute(Alias, Attr);
 231     }
 232   }
 233 }