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   markDefined(*Symbol);
112 }
113 
114 void RecordStreamer::EmitCommonSymbol(MCSymbol *Symbol, uint64_t Size,
115                                       unsigned ByteAlignment) {
116   markDefined(*Symbol);
117 }
118 
119 RecordStreamer::State RecordStreamer::getSymbolState(const MCSymbol *Sym) {
120   auto SI = Symbols.find(Sym->getName());
121   if (SI == Symbols.end())
122     return NeverSeen;
123   return SI->second;
124 }
125 
126 void RecordStreamer::emitELFSymverDirective(StringRef AliasName,
127                                             const MCSymbol *Aliasee) {
128   SymverAliasMap[Aliasee].push_back(AliasName);
129 }
130 
131 iterator_range<RecordStreamer::const_symver_iterator>
132 RecordStreamer::symverAliases() {
133   return {SymverAliasMap.begin(), SymverAliasMap.end()};
134 }
135 
136 void RecordStreamer::flushSymverDirectives() {
137   // Mapping from mangled name to GV.
138   StringMap<const GlobalValue *> MangledNameMap;
139   // The name in the assembler will be mangled, but the name in the IR
140   // might not, so we first compute a mapping from mangled name to GV.
141   Mangler Mang;
142   SmallString<64> MangledName;
143   for (const GlobalValue &GV : M.global_values()) {
144     if (!GV.hasName())
145       continue;
146     MangledName.clear();
147     MangledName.reserve(GV.getName().size() + 1);
148     Mang.getNameWithPrefix(MangledName, &GV, /*CannotUsePrivateLabel=*/false);
149     MangledNameMap[MangledName] = &GV;
150   }
151 
152   // Walk all the recorded .symver aliases, and set up the binding
153   // for each alias.
154   for (auto &Symver : SymverAliasMap) {
155     const MCSymbol *Aliasee = Symver.first;
156     MCSymbolAttr Attr = MCSA_Invalid;
157     bool IsDefined = false;
158 
159     // First check if the aliasee binding was recorded in the asm.
160     RecordStreamer::State state = getSymbolState(Aliasee);
161     switch (state) {
162     case RecordStreamer::Global:
163     case RecordStreamer::DefinedGlobal:
164       Attr = MCSA_Global;
165       break;
166     case RecordStreamer::UndefinedWeak:
167     case RecordStreamer::DefinedWeak:
168       Attr = MCSA_Weak;
169       break;
170     default:
171       break;
172     }
173 
174     switch (state) {
175     case RecordStreamer::Defined:
176     case RecordStreamer::DefinedGlobal:
177     case RecordStreamer::DefinedWeak:
178       IsDefined = true;
179       break;
180     case RecordStreamer::NeverSeen:
181     case RecordStreamer::Global:
182     case RecordStreamer::Used:
183     case RecordStreamer::UndefinedWeak:
184       break;
185     }
186 
187     if (Attr == MCSA_Invalid || !IsDefined) {
188       const GlobalValue *GV = M.getNamedValue(Aliasee->getName());
189       if (!GV) {
190         auto MI = MangledNameMap.find(Aliasee->getName());
191         if (MI != MangledNameMap.end())
192           GV = MI->second;
193       }
194       if (GV) {
195         // If we don't have a symbol attribute from assembly, then check if
196         // the aliasee was defined in the IR.
197         if (Attr == MCSA_Invalid) {
198           if (GV->hasExternalLinkage())
199             Attr = MCSA_Global;
200           else if (GV->hasLocalLinkage())
201             Attr = MCSA_Local;
202           else if (GV->isWeakForLinker())
203             Attr = MCSA_Weak;
204         }
205         IsDefined = IsDefined || !GV->isDeclarationForLinker();
206       }
207     }
208 
209     // Set the detected binding on each alias with this aliasee.
210     for (auto AliasName : Symver.second) {
211       std::pair<StringRef, StringRef> Split = AliasName.split("@@@");
212       SmallString<128> NewName;
213       if (!Split.second.empty() && !Split.second.startswith("@")) {
214         // Special processing for "@@@" according
215         // https://sourceware.org/binutils/docs/as/Symver.html
216         const char *Separator = IsDefined ? "@@" : "@";
217         AliasName =
218             (Split.first + Separator + Split.second).toStringRef(NewName);
219       }
220       MCSymbol *Alias = getContext().getOrCreateSymbol(AliasName);
221       // TODO: Handle "@@@". Depending on SymbolAttribute value it needs to be
222       // converted into @ or @@.
223       const MCExpr *Value = MCSymbolRefExpr::create(Aliasee, getContext());
224       if (IsDefined)
225         markDefined(*Alias);
226       // Don't use EmitAssignment override as it always marks alias as defined.
227       MCStreamer::EmitAssignment(Alias, Value);
228       if (Attr != MCSA_Invalid)
229         EmitSymbolAttribute(Alias, Attr);
230     }
231   }
232 }
233