blob: c4ed1881173e1d7d9fa4b6cf0b9b39522b48f1bd [file] [log] [blame]
Eugene Zelenko1df42fa2017-04-24 23:21:38 +00001//===- IRSymtab.cpp - implementation of IR symbol tables ------------------===//
Peter Collingbourne7b30f162017-03-31 04:47:07 +00002//
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
Chandler Carruth6bda14b2017-06-06 11:49:48 +000010#include "llvm/Object/IRSymtab.h"
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000011#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"
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000018#include "llvm/IR/Comdat.h"
19#include "llvm/IR/DataLayout.h"
20#include "llvm/IR/GlobalAlias.h"
21#include "llvm/IR/GlobalObject.h"
Peter Collingbourne7b30f162017-03-31 04:47:07 +000022#include "llvm/IR/Mangler.h"
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000023#include "llvm/IR/Metadata.h"
Peter Collingbourne7b30f162017-03-31 04:47:07 +000024#include "llvm/IR/Module.h"
Peter Collingbournec00c2b22017-06-08 01:26:14 +000025#include "llvm/Bitcode/BitcodeReader.h"
Peter Collingbourne7b30f162017-03-31 04:47:07 +000026#include "llvm/MC/StringTableBuilder.h"
Peter Collingbournec00c2b22017-06-08 01:26:14 +000027#include "llvm/Object/IRObjectFile.h"
Peter Collingbourne7b30f162017-03-31 04:47:07 +000028#include "llvm/Object/ModuleSymbolTable.h"
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000029#include "llvm/Object/SymbolicFile.h"
Peter Collingbourne7b30f162017-03-31 04:47:07 +000030#include "llvm/Support/Allocator.h"
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000031#include "llvm/Support/Casting.h"
32#include "llvm/Support/Error.h"
Peter Collingbourne7b30f162017-03-31 04:47:07 +000033#include "llvm/Support/StringSaver.h"
Peter Collingbourne53ed8672017-06-27 23:49:58 +000034#include "llvm/Support/VCSRevision.h"
Chandler Carruth6bda14b2017-06-06 11:49:48 +000035#include "llvm/Support/raw_ostream.h"
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000036#include <cassert>
37#include <string>
38#include <utility>
39#include <vector>
Peter Collingbourne7b30f162017-03-31 04:47:07 +000040
41using namespace llvm;
42using namespace irsymtab;
43
44namespace {
45
Peter Collingbourne53ed8672017-06-27 23:49:58 +000046const char *getExpectedProducerName() {
47 static char DefaultName[] = LLVM_VERSION_STRING
48#ifdef LLVM_REVISION
49 " " LLVM_REVISION
50#endif
51 ;
52 // Allows for testing of the irsymtab writer and upgrade mechanism. This
53 // environment variable should not be set by users.
54 if (char *OverrideName = getenv("LLVM_OVERRIDE_PRODUCER"))
55 return OverrideName;
56 return DefaultName;
57}
58
59const char *kExpectedProducerName = getExpectedProducerName();
60
Peter Collingbourne7b30f162017-03-31 04:47:07 +000061/// Stores the temporary state that is required to build an IR symbol table.
62struct Builder {
63 SmallVector<char, 0> &Symtab;
Peter Collingbourneafaeed52017-06-21 18:23:19 +000064 StringTableBuilder &StrtabBuilder;
65 StringSaver Saver;
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000066
Peter Collingbourneafaeed52017-06-21 18:23:19 +000067 // This ctor initializes a StringSaver using the passed in BumpPtrAllocator.
68 // The StringTableBuilder does not create a copy of any strings added to it,
69 // so this provides somewhere to store any strings that we create.
70 Builder(SmallVector<char, 0> &Symtab, StringTableBuilder &StrtabBuilder,
71 BumpPtrAllocator &Alloc)
72 : Symtab(Symtab), StrtabBuilder(StrtabBuilder), Saver(Alloc) {}
Peter Collingbourne7b30f162017-03-31 04:47:07 +000073
Peter Collingbourne6c484622017-11-21 22:06:20 +000074 DenseMap<const Comdat *, int> ComdatMap;
Peter Collingbourne7b30f162017-03-31 04:47:07 +000075 Mangler Mang;
76 Triple TT;
77
78 std::vector<storage::Comdat> Comdats;
79 std::vector<storage::Module> Mods;
80 std::vector<storage::Symbol> Syms;
81 std::vector<storage::Uncommon> Uncommons;
82
83 std::string COFFLinkerOpts;
84 raw_string_ostream COFFLinkerOptsOS{COFFLinkerOpts};
85
86 void setStr(storage::Str &S, StringRef Value) {
87 S.Offset = StrtabBuilder.add(Value);
Peter Collingbournec74cf062017-04-17 17:55:24 +000088 S.Size = Value.size();
Peter Collingbourne7b30f162017-03-31 04:47:07 +000089 }
Eugene Zelenko1df42fa2017-04-24 23:21:38 +000090
Peter Collingbourne7b30f162017-03-31 04:47:07 +000091 template <typename T>
92 void writeRange(storage::Range<T> &R, const std::vector<T> &Objs) {
93 R.Offset = Symtab.size();
94 R.Size = Objs.size();
95 Symtab.insert(Symtab.end(), reinterpret_cast<const char *>(Objs.data()),
96 reinterpret_cast<const char *>(Objs.data() + Objs.size()));
97 }
98
Peter Collingbourne6c484622017-11-21 22:06:20 +000099 Expected<int> getComdatIndex(const Comdat *C, const Module *M);
100
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000101 Error addModule(Module *M);
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000102 Error addSymbol(const ModuleSymbolTable &Msymtab,
103 const SmallPtrSet<GlobalValue *, 8> &Used,
104 ModuleSymbolTable::Symbol Sym);
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000105
106 Error build(ArrayRef<Module *> Mods);
107};
108
109Error Builder::addModule(Module *M) {
Peter Collingbournedc8c0182017-06-08 22:04:24 +0000110 if (M->getDataLayoutStr().empty())
111 return make_error<StringError>("input module has no datalayout",
112 inconvertibleErrorCode());
113
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000114 SmallPtrSet<GlobalValue *, 8> Used;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000115 collectUsedGlobalVariables(*M, Used, /*CompilerUsed*/ false);
116
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000117 ModuleSymbolTable Msymtab;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000118 Msymtab.addModule(M);
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000119
120 storage::Module Mod;
121 Mod.Begin = Syms.size();
122 Mod.End = Syms.size() + Msymtab.symbols().size();
123 Mod.UncBegin = Uncommons.size();
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000124 Mods.push_back(Mod);
125
126 if (TT.isOSBinFormatCOFF()) {
127 if (auto E = M->materializeMetadata())
128 return E;
Peter Collingbourne89061b22017-06-12 20:10:48 +0000129 if (NamedMDNode *LinkerOptions =
130 M->getNamedMetadata("llvm.linker.options")) {
131 for (MDNode *MDOptions : LinkerOptions->operands())
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000132 for (const MDOperand &MDOption : cast<MDNode>(MDOptions)->operands())
133 COFFLinkerOptsOS << " " << cast<MDString>(MDOption)->getString();
134 }
135 }
136
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000137 for (ModuleSymbolTable::Symbol Msym : Msymtab.symbols())
138 if (Error Err = addSymbol(Msymtab, Used, Msym))
139 return Err;
140
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000141 return Error::success();
142}
143
Peter Collingbourne6c484622017-11-21 22:06:20 +0000144Expected<int> Builder::getComdatIndex(const Comdat *C, const Module *M) {
145 auto P = ComdatMap.insert(std::make_pair(C, Comdats.size()));
146 if (P.second) {
147 std::string Name;
148 if (TT.isOSBinFormatCOFF()) {
149 const GlobalValue *GV = M->getNamedValue(C->getName());
150 if (!GV)
151 return make_error<StringError>("Could not find leader",
152 inconvertibleErrorCode());
153 // Internal leaders do not affect symbol resolution, therefore they do not
154 // appear in the symbol table.
155 if (GV->hasLocalLinkage()) {
156 P.first->second = -1;
157 return -1;
158 }
159 llvm::raw_string_ostream OS(Name);
160 Mang.getNameWithPrefix(OS, GV, false);
161 } else {
162 Name = C->getName();
163 }
164
165 storage::Comdat Comdat;
166 setStr(Comdat.Name, Saver.save(Name));
167 Comdats.push_back(Comdat);
168 }
169
170 return P.first->second;
171}
172
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000173Error Builder::addSymbol(const ModuleSymbolTable &Msymtab,
174 const SmallPtrSet<GlobalValue *, 8> &Used,
175 ModuleSymbolTable::Symbol Msym) {
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000176 Syms.emplace_back();
177 storage::Symbol &Sym = Syms.back();
178 Sym = {};
179
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000180 storage::Uncommon *Unc = nullptr;
181 auto Uncommon = [&]() -> storage::Uncommon & {
182 if (Unc)
183 return *Unc;
Peter Collingbourne76423dc2017-04-17 23:43:49 +0000184 Sym.Flags |= 1 << storage::Symbol::FB_has_uncommon;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000185 Uncommons.emplace_back();
186 Unc = &Uncommons.back();
187 *Unc = {};
188 setStr(Unc->COFFWeakExternFallbackName, "");
Teresa Johnsona83c3f72017-07-25 19:42:32 +0000189 setStr(Unc->SectionName, "");
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000190 return *Unc;
191 };
192
193 SmallString<64> Name;
194 {
195 raw_svector_ostream OS(Name);
196 Msymtab.printSymbolName(OS, Msym);
197 }
198 setStr(Sym.Name, Saver.save(StringRef(Name)));
199
200 auto Flags = Msymtab.getSymbolFlags(Msym);
201 if (Flags & object::BasicSymbolRef::SF_Undefined)
202 Sym.Flags |= 1 << storage::Symbol::FB_undefined;
203 if (Flags & object::BasicSymbolRef::SF_Weak)
204 Sym.Flags |= 1 << storage::Symbol::FB_weak;
205 if (Flags & object::BasicSymbolRef::SF_Common)
206 Sym.Flags |= 1 << storage::Symbol::FB_common;
207 if (Flags & object::BasicSymbolRef::SF_Indirect)
208 Sym.Flags |= 1 << storage::Symbol::FB_indirect;
209 if (Flags & object::BasicSymbolRef::SF_Global)
210 Sym.Flags |= 1 << storage::Symbol::FB_global;
211 if (Flags & object::BasicSymbolRef::SF_FormatSpecific)
212 Sym.Flags |= 1 << storage::Symbol::FB_format_specific;
Tobias Edler von Koch90df1f482017-04-13 16:24:14 +0000213 if (Flags & object::BasicSymbolRef::SF_Executable)
214 Sym.Flags |= 1 << storage::Symbol::FB_executable;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000215
216 Sym.ComdatIndex = -1;
217 auto *GV = Msym.dyn_cast<GlobalValue *>();
218 if (!GV) {
Peter Collingbournefa58f752017-04-26 17:53:39 +0000219 // Undefined module asm symbols act as GC roots and are implicitly used.
220 if (Flags & object::BasicSymbolRef::SF_Undefined)
221 Sym.Flags |= 1 << storage::Symbol::FB_used;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000222 setStr(Sym.IRName, "");
223 return Error::success();
224 }
225
226 setStr(Sym.IRName, GV->getName());
227
228 if (Used.count(GV))
229 Sym.Flags |= 1 << storage::Symbol::FB_used;
230 if (GV->isThreadLocal())
231 Sym.Flags |= 1 << storage::Symbol::FB_tls;
232 if (GV->hasGlobalUnnamedAddr())
233 Sym.Flags |= 1 << storage::Symbol::FB_unnamed_addr;
David Blaikie88209292018-03-21 19:23:45 +0000234 if (GV->canBeOmittedFromSymbolTable())
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000235 Sym.Flags |= 1 << storage::Symbol::FB_may_omit;
236 Sym.Flags |= unsigned(GV->getVisibility()) << storage::Symbol::FB_visibility;
237
238 if (Flags & object::BasicSymbolRef::SF_Common) {
239 Uncommon().CommonSize = GV->getParent()->getDataLayout().getTypeAllocSize(
240 GV->getType()->getElementType());
241 Uncommon().CommonAlign = GV->getAlignment();
242 }
243
244 const GlobalObject *Base = GV->getBaseObject();
245 if (!Base)
246 return make_error<StringError>("Unable to determine comdat of alias!",
247 inconvertibleErrorCode());
248 if (const Comdat *C = Base->getComdat()) {
Peter Collingbourne6c484622017-11-21 22:06:20 +0000249 Expected<int> ComdatIndexOrErr = getComdatIndex(C, GV->getParent());
250 if (!ComdatIndexOrErr)
251 return ComdatIndexOrErr.takeError();
252 Sym.ComdatIndex = *ComdatIndexOrErr;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000253 }
254
255 if (TT.isOSBinFormatCOFF()) {
256 emitLinkerFlagsForGlobalCOFF(COFFLinkerOptsOS, GV, TT, Mang);
257
258 if ((Flags & object::BasicSymbolRef::SF_Weak) &&
259 (Flags & object::BasicSymbolRef::SF_Indirect)) {
Peter Collingbourne4899a922017-09-07 01:33:52 +0000260 auto *Fallback = dyn_cast<GlobalValue>(
261 cast<GlobalAlias>(GV)->getAliasee()->stripPointerCasts());
262 if (!Fallback)
263 return make_error<StringError>("Invalid weak external",
264 inconvertibleErrorCode());
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000265 std::string FallbackName;
266 raw_string_ostream OS(FallbackName);
Peter Collingbourne4899a922017-09-07 01:33:52 +0000267 Msymtab.printSymbolName(OS, Fallback);
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000268 OS.flush();
269 setStr(Uncommon().COFFWeakExternFallbackName, Saver.save(FallbackName));
270 }
271 }
272
Teresa Johnsona83c3f72017-07-25 19:42:32 +0000273 if (!Base->getSection().empty())
274 setStr(Uncommon().SectionName, Saver.save(Base->getSection()));
275
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000276 return Error::success();
277}
278
279Error Builder::build(ArrayRef<Module *> IRMods) {
280 storage::Header Hdr;
281
282 assert(!IRMods.empty());
Peter Collingbourne53ed8672017-06-27 23:49:58 +0000283 Hdr.Version = storage::Header::kCurrentVersion;
284 setStr(Hdr.Producer, kExpectedProducerName);
Peter Collingbourne8446f1f2017-04-14 02:55:06 +0000285 setStr(Hdr.TargetTriple, IRMods[0]->getTargetTriple());
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000286 setStr(Hdr.SourceFileName, IRMods[0]->getSourceFileName());
287 TT = Triple(IRMods[0]->getTargetTriple());
288
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000289 for (auto *M : IRMods)
290 if (Error Err = addModule(M))
291 return Err;
292
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000293 COFFLinkerOptsOS.flush();
Peter Collingbourneafaeed52017-06-21 18:23:19 +0000294 setStr(Hdr.COFFLinkerOpts, Saver.save(COFFLinkerOpts));
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000295
296 // We are about to fill in the header's range fields, so reserve space for it
297 // and copy it in afterwards.
298 Symtab.resize(sizeof(storage::Header));
299 writeRange(Hdr.Modules, Mods);
300 writeRange(Hdr.Comdats, Comdats);
301 writeRange(Hdr.Symbols, Syms);
302 writeRange(Hdr.Uncommons, Uncommons);
303
304 *reinterpret_cast<storage::Header *>(Symtab.data()) = Hdr;
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000305 return Error::success();
306}
307
Eugene Zelenko1df42fa2017-04-24 23:21:38 +0000308} // end anonymous namespace
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000309
310Error irsymtab::build(ArrayRef<Module *> Mods, SmallVector<char, 0> &Symtab,
Peter Collingbourneafaeed52017-06-21 18:23:19 +0000311 StringTableBuilder &StrtabBuilder,
312 BumpPtrAllocator &Alloc) {
313 return Builder(Symtab, StrtabBuilder, Alloc).build(Mods);
Peter Collingbourne7b30f162017-03-31 04:47:07 +0000314}
Peter Collingbournec00c2b22017-06-08 01:26:14 +0000315
Peter Collingbourne8dde4cb2017-06-08 22:00:24 +0000316// Upgrade a vector of bitcode modules created by an old version of LLVM by
317// creating an irsymtab for them in the current format.
318static Expected<FileContents> upgrade(ArrayRef<BitcodeModule> BMs) {
Peter Collingbournec00c2b22017-06-08 01:26:14 +0000319 FileContents FC;
Peter Collingbournec00c2b22017-06-08 01:26:14 +0000320
321 LLVMContext Ctx;
322 std::vector<Module *> Mods;
323 std::vector<std::unique_ptr<Module>> OwnedMods;
324 for (auto BM : BMs) {
325 Expected<std::unique_ptr<Module>> MOrErr =
326 BM.getLazyModule(Ctx, /*ShouldLazyLoadMetadata*/ true,
327 /*IsImporting*/ false);
328 if (!MOrErr)
329 return MOrErr.takeError();
330
Peter Collingbournec00c2b22017-06-08 01:26:14 +0000331 Mods.push_back(MOrErr->get());
332 OwnedMods.push_back(std::move(*MOrErr));
333 }
334
Peter Collingbourneafaeed52017-06-21 18:23:19 +0000335 StringTableBuilder StrtabBuilder(StringTableBuilder::RAW);
336 BumpPtrAllocator Alloc;
337 if (Error E = build(Mods, FC.Symtab, StrtabBuilder, Alloc))
Peter Collingbournec00c2b22017-06-08 01:26:14 +0000338 return std::move(E);
339
Peter Collingbourneafaeed52017-06-21 18:23:19 +0000340 StrtabBuilder.finalizeInOrder();
341 FC.Strtab.resize(StrtabBuilder.getSize());
342 StrtabBuilder.write((uint8_t *)FC.Strtab.data());
343
Peter Collingbournec00c2b22017-06-08 01:26:14 +0000344 FC.TheReader = {{FC.Symtab.data(), FC.Symtab.size()},
345 {FC.Strtab.data(), FC.Strtab.size()}};
346 return std::move(FC);
347}
Peter Collingbourne8dde4cb2017-06-08 22:00:24 +0000348
349Expected<FileContents> irsymtab::readBitcode(const BitcodeFileContents &BFC) {
350 if (BFC.Mods.empty())
351 return make_error<StringError>("Bitcode file does not contain any modules",
352 inconvertibleErrorCode());
353
Peter Collingbourne99b98c22017-06-27 23:50:24 +0000354 if (BFC.StrtabForSymtab.empty() ||
355 BFC.Symtab.size() < sizeof(storage::Header))
356 return upgrade(BFC.Mods);
357
358 // We cannot use the regular reader to read the version and producer, because
359 // it will expect the header to be in the current format. The only thing we
360 // can rely on is that the version and producer will be present as the first
361 // struct elements.
362 auto *Hdr = reinterpret_cast<const storage::Header *>(BFC.Symtab.data());
363 unsigned Version = Hdr->Version;
364 StringRef Producer = Hdr->Producer.get(BFC.StrtabForSymtab);
365 if (Version != storage::Header::kCurrentVersion ||
366 Producer != kExpectedProducerName)
367 return upgrade(BFC.Mods);
368
369 FileContents FC;
370 FC.TheReader = {{BFC.Symtab.data(), BFC.Symtab.size()},
371 {BFC.StrtabForSymtab.data(), BFC.StrtabForSymtab.size()}};
372
373 // Finally, make sure that the number of modules in the symbol table matches
374 // the number of modules in the bitcode file. If they differ, it may mean that
375 // the bitcode file was created by binary concatenation, so we need to create
376 // a new symbol table from scratch.
377 if (FC.TheReader.getNumModules() != BFC.Mods.size())
378 return upgrade(std::move(BFC.Mods));
379
380 return std::move(FC);
Peter Collingbourne8dde4cb2017-06-08 22:00:24 +0000381}