LLVM  10.0.0svn
IRObjectFile.cpp
Go to the documentation of this file.
1 //===- IRObjectFile.cpp - IR object file implementation ---------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // Part of the IRObjectFile class implementation.
10 //
11 //===----------------------------------------------------------------------===//
12 
14 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/IR/GVMaterializer.h"
18 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/IR/Mangler.h"
20 #include "llvm/IR/Module.h"
21 #include "llvm/Object/ObjectFile.h"
25 using namespace llvm;
26 using namespace object;
27 
28 IRObjectFile::IRObjectFile(MemoryBufferRef Object,
29  std::vector<std::unique_ptr<Module>> Mods)
30  : SymbolicFile(Binary::ID_IR, Object), Mods(std::move(Mods)) {
31  for (auto &M : this->Mods)
32  SymTab.addModule(M.get());
33 }
34 
35 IRObjectFile::~IRObjectFile() {}
36 
37 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
38  return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
39 }
40 
41 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
42  Symb.p += sizeof(ModuleSymbolTable::Symbol);
43 }
44 
45 Error IRObjectFile::printSymbolName(raw_ostream &OS, DataRefImpl Symb) const {
46  SymTab.printSymbolName(OS, getSym(Symb));
47  return Error::success();
48 }
49 
50 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
51  return SymTab.getSymbolFlags(getSym(Symb));
52 }
53 
54 basic_symbol_iterator IRObjectFile::symbol_begin() const {
56  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
57  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
58 }
59 
60 basic_symbol_iterator IRObjectFile::symbol_end() const {
62  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
63  SymTab.symbols().size());
64  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
65 }
66 
67 StringRef IRObjectFile::getTargetTriple() const {
68  // Each module must have the same target triple, so we arbitrarily access the
69  // first one.
70  return Mods[0]->getTargetTriple();
71 }
72 
74 IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
75  for (const SectionRef &Sec : Obj.sections()) {
76  if (Sec.isBitcode()) {
77  Expected<StringRef> Contents = Sec.getContents();
78  if (!Contents)
79  return Contents.takeError();
80  if (Contents->size() <= 1)
81  return errorCodeToError(object_error::bitcode_section_not_found);
82  return MemoryBufferRef(*Contents, Obj.getFileName());
83  }
84  }
85 
86  return errorCodeToError(object_error::bitcode_section_not_found);
87 }
88 
90 IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
92  switch (Type) {
94  return Object;
95  case file_magic::elf_relocatable:
96  case file_magic::macho_object:
97  case file_magic::coff_object: {
99  ObjectFile::createObjectFile(Object, Type);
100  if (!ObjFile)
101  return ObjFile.takeError();
102  return findBitcodeInObject(*ObjFile->get());
103  }
104  default:
105  return errorCodeToError(object_error::invalid_file_type);
106  }
107 }
108 
110 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) {
111  Expected<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
112  if (!BCOrErr)
113  return BCOrErr.takeError();
114 
116  getBitcodeModuleList(*BCOrErr);
117  if (!BMsOrErr)
118  return BMsOrErr.takeError();
119 
120  std::vector<std::unique_ptr<Module>> Mods;
121  for (auto BM : *BMsOrErr) {
123  BM.getLazyModule(Context, /*ShouldLazyLoadMetadata*/ true,
124  /*IsImporting*/ false);
125  if (!MOrErr)
126  return MOrErr.takeError();
127 
128  Mods.push_back(std::move(*MOrErr));
129  }
130 
131  return std::unique_ptr<IRObjectFile>(
132  new IRObjectFile(*BCOrErr, std::move(Mods)));
133 }
134 
136  IRSymtabFile F;
137  Expected<MemoryBufferRef> BCOrErr =
138  IRObjectFile::findBitcodeInMemBuffer(MBRef);
139  if (!BCOrErr)
140  return BCOrErr.takeError();
141 
143  if (!BFCOrErr)
144  return BFCOrErr.takeError();
145 
147  if (!FCOrErr)
148  return FCOrErr.takeError();
149 
150  F.Mods = std::move(BFCOrErr->Mods);
151  F.Symtab = std::move(FCOrErr->Symtab);
152  F.Strtab = std::move(FCOrErr->Strtab);
153  F.TheReader = std::move(FCOrErr->TheReader);
154  return std::move(F);
155 }
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
StringRef getFileName() const
Definition: Binary.cpp:42
This class is the base class for all object file types.
Definition: ObjectFile.h:221
F(f)
irsymtab::Reader TheReader
Definition: IRObjectFile.h:81
Error takeError()
Take ownership of the stored error.
Definition: Error.h:552
static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb)
Definition: BitVector.h:937
Expected< std::vector< BitcodeModule > > getBitcodeModuleList(MemoryBufferRef Buffer)
Returns a list of modules in the specified bitcode buffer.
StringRef getBuffer() const
Definition: MemoryBuffer.h:272
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: yaml2obj.h:21
The contents of a bitcode file and its irsymtab.
Definition: IRObjectFile.h:78
section_iterator_range sections() const
Definition: ObjectFile.h:310
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:64
Error errorCodeToError(std::error_code EC)
Helper for converting an std::error_code to a Error.
Definition: Error.cpp:87
std::vector< BitcodeModule > Mods
Definition: IRObjectFile.h:79
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:80
reference get()
Returns a reference to the stored T value.
Definition: Error.h:532
Expected< FileContents > readBitcode(const BitcodeFileContents &BFC)
Reads the contents of a bitcode file, creating its irsymtab if necessary.
Definition: IRSymtab.cpp:377
content_iterator< BasicSymbolRef > basic_symbol_iterator
Definition: SymbolicFile.h:138
success
Parameters (see the expansion example below): (the builder, addr, loaded, new_val, ordering, /* OUT.
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: SymbolicFile.h:98
Lightweight error class with error context and mandatory checking.
Definition: Error.h:157
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:45
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:48
Expected< IRSymtabFile > readIRSymtab(MemoryBufferRef MBRef)
Reads a bitcode file, creating its irsymtab if necessary.
SmallVector< char, 0 > Symtab
Definition: IRObjectFile.h:80
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:81
A discriminated union of two or more pointer types, with the discriminator in the low bit of the poin...
Definition: PointerUnion.h:156
file_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file)...
Definition: Magic.h:20