LLVM  9.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 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
46  DataRefImpl Symb) const {
47  SymTab.printSymbolName(OS, getSym(Symb));
48  return std::error_code();
49 }
50 
51 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
52  return SymTab.getSymbolFlags(getSym(Symb));
53 }
54 
55 basic_symbol_iterator IRObjectFile::symbol_begin() const {
57  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
58  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
59 }
60 
61 basic_symbol_iterator IRObjectFile::symbol_end() const {
63  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
64  SymTab.symbols().size());
65  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
66 }
67 
68 StringRef IRObjectFile::getTargetTriple() const {
69  // Each module must have the same target triple, so we arbitrarily access the
70  // first one.
71  return Mods[0]->getTargetTriple();
72 }
73 
75 IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
76  for (const SectionRef &Sec : Obj.sections()) {
77  if (Sec.isBitcode()) {
78  StringRef SecContents;
79  if (std::error_code EC = Sec.getContents(SecContents))
80  return errorCodeToError(EC);
81  if (SecContents.size() <= 1)
82  return errorCodeToError(object_error::bitcode_section_not_found);
83  return MemoryBufferRef(SecContents, Obj.getFileName());
84  }
85  }
86 
87  return errorCodeToError(object_error::bitcode_section_not_found);
88 }
89 
91 IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
93  switch (Type) {
95  return Object;
96  case file_magic::elf_relocatable:
97  case file_magic::macho_object:
98  case file_magic::coff_object: {
100  ObjectFile::createObjectFile(Object, Type);
101  if (!ObjFile)
102  return ObjFile.takeError();
103  return findBitcodeInObject(*ObjFile->get());
104  }
105  default:
106  return errorCodeToError(object_error::invalid_file_type);
107  }
108 }
109 
111 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) {
112  Expected<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
113  if (!BCOrErr)
114  return BCOrErr.takeError();
115 
117  getBitcodeModuleList(*BCOrErr);
118  if (!BMsOrErr)
119  return BMsOrErr.takeError();
120 
121  std::vector<std::unique_ptr<Module>> Mods;
122  for (auto BM : *BMsOrErr) {
124  BM.getLazyModule(Context, /*ShouldLazyLoadMetadata*/ true,
125  /*IsImporting*/ false);
126  if (!MOrErr)
127  return MOrErr.takeError();
128 
129  Mods.push_back(std::move(*MOrErr));
130  }
131 
132  return std::unique_ptr<IRObjectFile>(
133  new IRObjectFile(*BCOrErr, std::move(Mods)));
134 }
135 
137  IRSymtabFile F;
138  Expected<MemoryBufferRef> BCOrErr =
139  IRObjectFile::findBitcodeInMemBuffer(MBRef);
140  if (!BCOrErr)
141  return BCOrErr.takeError();
142 
144  if (!BFCOrErr)
145  return BFCOrErr.takeError();
146 
148  if (!FCOrErr)
149  return FCOrErr.takeError();
150 
151  F.Mods = std::move(BFCOrErr->Mods);
152  F.Symtab = std::move(FCOrErr->Symtab);
153  F.Strtab = std::move(FCOrErr->Strtab);
154  F.TheReader = std::move(FCOrErr->TheReader);
155  return std::move(F);
156 }
LLVMContext & Context
This class represents lattice values for constants.
Definition: AllocatorList.h:23
StringRef getFileName() const
Definition: Binary.cpp:41
This class is the base class for all object file types.
Definition: ObjectFile.h:225
F(f)
irsymtab::Reader TheReader
Definition: IRObjectFile.h:82
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: CachePruning.h:22
The contents of a bitcode file and its irsymtab.
Definition: IRObjectFile.h:79
LLVM_NODISCARD size_t size() const
size - Get the string size.
Definition: StringRef.h:130
section_iterator_range sections() const
Definition: ObjectFile.h:315
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:80
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:81
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:361
content_iterator< BasicSymbolRef > basic_symbol_iterator
Definition: SymbolicFile.h:138
This is a value type class that represents a single symbol in the list of symbols in the object file...
Definition: SymbolicFile.h:98
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:81
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:86
file_magic - An "enum class" enumeration of file types based on magic (the first N bytes of the file)...
Definition: Magic.h:20