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 "RecordStreamer.h" 17 #include "llvm/ADT/SmallString.h" 18 #include "llvm/ADT/STLExtras.h" 19 #include "llvm/ADT/StringMap.h" 20 #include "llvm/ADT/StringRef.h" 21 #include "llvm/ADT/Triple.h" 22 #include "llvm/IR/Function.h" 23 #include "llvm/IR/GlobalAlias.h" 24 #include "llvm/IR/GlobalValue.h" 25 #include "llvm/IR/GlobalVariable.h" 26 #include "llvm/IR/Mangler.h" 27 #include "llvm/IR/Module.h" 28 #include "llvm/MC/MCAsmInfo.h" 29 #include "llvm/MC/MCContext.h" 30 #include "llvm/MC/MCDirectives.h" 31 #include "llvm/MC/MCInstrInfo.h" 32 #include "llvm/MC/MCObjectFileInfo.h" 33 #include "llvm/MC/MCParser/MCAsmParser.h" 34 #include "llvm/MC/MCParser/MCTargetAsmParser.h" 35 #include "llvm/MC/MCRegisterInfo.h" 36 #include "llvm/MC/MCSubtargetInfo.h" 37 #include "llvm/MC/MCSymbol.h" 38 #include "llvm/MC/MCTargetOptions.h" 39 #include "llvm/Object/ModuleSymbolTable.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/raw_ostream.h" 46 #include "llvm/Support/SMLoc.h" 47 #include "llvm/Support/SourceMgr.h" 48 #include "llvm/Support/TargetRegistry.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, CodeModel::Default, 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 } 281