LLVM  6.0.0svn
IRObjectFile.cpp
Go to the documentation of this file.
1 //===- IRObjectFile.cpp - IR object file implementation ---------*- C++ -*-===//
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 // Part of the IRObjectFile class implementation.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "RecordStreamer.h"
16 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/IR/GVMaterializer.h"
20 #include "llvm/IR/LLVMContext.h"
21 #include "llvm/IR/Mangler.h"
22 #include "llvm/IR/Module.h"
23 #include "llvm/MC/MCAsmInfo.h"
24 #include "llvm/MC/MCContext.h"
25 #include "llvm/MC/MCInstrInfo.h"
29 #include "llvm/MC/MCRegisterInfo.h"
31 #include "llvm/Object/ObjectFile.h"
33 #include "llvm/Support/SourceMgr.h"
36 using namespace llvm;
37 using namespace object;
38 
39 IRObjectFile::IRObjectFile(MemoryBufferRef Object,
40  std::vector<std::unique_ptr<Module>> Mods)
41  : SymbolicFile(Binary::ID_IR, Object), Mods(std::move(Mods)) {
42  for (auto &M : this->Mods)
43  SymTab.addModule(M.get());
44 }
45 
46 IRObjectFile::~IRObjectFile() {}
47 
48 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
49  return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
50 }
51 
52 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
53  Symb.p += sizeof(ModuleSymbolTable::Symbol);
54 }
55 
56 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
57  DataRefImpl Symb) const {
58  SymTab.printSymbolName(OS, getSym(Symb));
59  return std::error_code();
60 }
61 
62 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
63  return SymTab.getSymbolFlags(getSym(Symb));
64 }
65 
66 basic_symbol_iterator IRObjectFile::symbol_begin() const {
68  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
69  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
70 }
71 
72 basic_symbol_iterator IRObjectFile::symbol_end() const {
74  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
75  SymTab.symbols().size());
76  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
77 }
78 
79 StringRef IRObjectFile::getTargetTriple() const {
80  // Each module must have the same target triple, so we arbitrarily access the
81  // first one.
82  return Mods[0]->getTargetTriple();
83 }
84 
86 IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
87  for (const SectionRef &Sec : Obj.sections()) {
88  if (Sec.isBitcode()) {
89  StringRef SecContents;
90  if (std::error_code EC = Sec.getContents(SecContents))
91  return errorCodeToError(EC);
92  return MemoryBufferRef(SecContents, Obj.getFileName());
93  }
94  }
95 
96  return errorCodeToError(object_error::bitcode_section_not_found);
97 }
98 
100 IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
102  switch (Type) {
103  case file_magic::bitcode:
104  return Object;
105  case file_magic::elf_relocatable:
106  case file_magic::macho_object:
107  case file_magic::coff_object: {
109  ObjectFile::createObjectFile(Object, Type);
110  if (!ObjFile)
111  return ObjFile.takeError();
112  return findBitcodeInObject(*ObjFile->get());
113  }
114  default:
115  return errorCodeToError(object_error::invalid_file_type);
116  }
117 }
118 
120 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) {
121  Expected<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
122  if (!BCOrErr)
123  return BCOrErr.takeError();
124 
126  getBitcodeModuleList(*BCOrErr);
127  if (!BMsOrErr)
128  return BMsOrErr.takeError();
129 
130  std::vector<std::unique_ptr<Module>> Mods;
131  for (auto BM : *BMsOrErr) {
133  BM.getLazyModule(Context, /*ShouldLazyLoadMetadata*/ true,
134  /*IsImporting*/ false);
135  if (!MOrErr)
136  return MOrErr.takeError();
137 
138  Mods.push_back(std::move(*MOrErr));
139  }
140 
141  return std::unique_ptr<IRObjectFile>(
142  new IRObjectFile(*BCOrErr, std::move(Mods)));
143 }
144 
146  IRSymtabFile F;
147  Expected<MemoryBufferRef> BCOrErr =
148  IRObjectFile::findBitcodeInMemBuffer(MBRef);
149  if (!BCOrErr)
150  return BCOrErr.takeError();
151 
153  if (!BFCOrErr)
154  return BFCOrErr.takeError();
155 
157  if (!FCOrErr)
158  return FCOrErr.takeError();
159 
160  F.Mods = std::move(BFCOrErr->Mods);
161  F.Symtab = std::move(FCOrErr->Symtab);
162  F.Strtab = std::move(FCOrErr->Strtab);
163  F.TheReader = std::move(FCOrErr->TheReader);
164  return std::move(F);
165 }
LLVMContext & Context
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
StringRef getFileName() const
Definition: Binary.cpp:41
This class is the base class for all object file types.
Definition: ObjectFile.h:189
F(f)
irsymtab::Reader TheReader
Definition: IRObjectFile.h:72
Error takeError()
Take ownership of the stored error.
Definition: Error.h:537
static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb)
Definition: BitVector.h:920
Expected< std::vector< BitcodeModule > > getBitcodeModuleList(MemoryBufferRef Buffer)
Returns a list of modules in the specified bitcode buffer.
StringRef getBuffer() const
Definition: MemoryBuffer.h:170
file_magic identify_magic(StringRef magic)
Identify the type of a binary file based on how magical it is.
Definition: Magic.cpp:34
write bitcode
Tagged union holding either a T or a Error.
Definition: CachePruning.h:23
The contents of a bitcode file and its irsymtab.
Definition: IRObjectFile.h:69
section_iterator_range sections() const
Definition: ObjectFile.h:273
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:69
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:78
std::vector< BitcodeModule > Mods
Definition: IRObjectFile.h:70
Expected< BitcodeFileContents > getBitcodeFileContents(MemoryBufferRef Buffer)
Returns the contents of a bitcode file.
Module.h This file contains the declarations for the Module class.
SmallVector< char, 0 > Strtab
Definition: IRObjectFile.h:71
reference get()
Returns a reference to the stored T value.
Definition: Error.h:517
Expected< FileContents > readBitcode(const BitcodeFileContents &BFC)
Reads the contents of a bitcode file, creating its irsymtab if necessary.
Definition: IRSymtab.cpp:323
content_iterator< BasicSymbolRef > basic_symbol_iterator
Definition: SymbolicFile.h:139
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: SymbolicFile.h:99
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:44
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
Expected< IRSymtabFile > readIRSymtab(MemoryBufferRef MBRef)
Reads a bitcode file, creating its irsymtab if necessary.
SmallVector< char, 0 > Symtab
Definition: IRObjectFile.h:71
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:80
A discriminated union of two pointer types, with the discriminator in the low bit of the pointer...
Definition: PointerUnion.h:87
file_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file)...
Definition: Magic.h:21