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
14 #include "llvm/Object/IRObjectFile.h"
15 #include "llvm/ADT/STLExtras.h"
16 #include "llvm/BinaryFormat/Magic.h"
17 #include "llvm/Bitcode/BitcodeReader.h"
18 #include "llvm/IR/GVMaterializer.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/IR/Mangler.h"
21 #include "llvm/IR/Module.h"
22 #include "llvm/Object/ObjectFile.h"
23 #include "llvm/Support/MemoryBuffer.h"
24 #include "llvm/Support/TargetRegistry.h"
25 #include "llvm/Support/raw_ostream.h"
26 using namespace llvm;
27 using namespace object;
28
IRObjectFile(MemoryBufferRef Object,std::vector<std::unique_ptr<Module>> Mods)29 IRObjectFile::IRObjectFile(MemoryBufferRef Object,
30 std::vector<std::unique_ptr<Module>> Mods)
31 : SymbolicFile(Binary::ID_IR, Object), Mods(std::move(Mods)) {
32 for (auto &M : this->Mods)
33 SymTab.addModule(M.get());
34 }
35
~IRObjectFile()36 IRObjectFile::~IRObjectFile() {}
37
getSym(DataRefImpl & Symb)38 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
39 return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
40 }
41
moveSymbolNext(DataRefImpl & Symb) const42 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
43 Symb.p += sizeof(ModuleSymbolTable::Symbol);
44 }
45
printSymbolName(raw_ostream & OS,DataRefImpl Symb) const46 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
47 DataRefImpl Symb) const {
48 SymTab.printSymbolName(OS, getSym(Symb));
49 return std::error_code();
50 }
51
getSymbolFlags(DataRefImpl Symb) const52 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
53 return SymTab.getSymbolFlags(getSym(Symb));
54 }
55
symbol_begin() const56 basic_symbol_iterator IRObjectFile::symbol_begin() const {
57 DataRefImpl Ret;
58 Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
59 return basic_symbol_iterator(BasicSymbolRef(Ret, this));
60 }
61
symbol_end() const62 basic_symbol_iterator IRObjectFile::symbol_end() const {
63 DataRefImpl Ret;
64 Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
65 SymTab.symbols().size());
66 return basic_symbol_iterator(BasicSymbolRef(Ret, this));
67 }
68
getTargetTriple() const69 StringRef IRObjectFile::getTargetTriple() const {
70 // Each module must have the same target triple, so we arbitrarily access the
71 // first one.
72 return Mods[0]->getTargetTriple();
73 }
74
75 Expected<MemoryBufferRef>
findBitcodeInObject(const ObjectFile & Obj)76 IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
77 for (const SectionRef &Sec : Obj.sections()) {
78 if (Sec.isBitcode()) {
79 StringRef SecContents;
80 if (std::error_code EC = Sec.getContents(SecContents))
81 return errorCodeToError(EC);
82 return MemoryBufferRef(SecContents, Obj.getFileName());
83 }
84 }
85
86 return errorCodeToError(object_error::bitcode_section_not_found);
87 }
88
89 Expected<MemoryBufferRef>
findBitcodeInMemBuffer(MemoryBufferRef Object)90 IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
91 file_magic Type = identify_magic(Object.getBuffer());
92 switch (Type) {
93 case file_magic::bitcode:
94 return Object;
95 case file_magic::elf_relocatable:
96 case file_magic::macho_object:
97 case file_magic::coff_object: {
98 Expected<std::unique_ptr<ObjectFile>> ObjFile =
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
109 Expected<std::unique_ptr<IRObjectFile>>
create(MemoryBufferRef Object,LLVMContext & Context)110 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) {
111 Expected<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
112 if (!BCOrErr)
113 return BCOrErr.takeError();
114
115 Expected<std::vector<BitcodeModule>> BMsOrErr =
116 getBitcodeModuleList(*BCOrErr);
117 if (!BMsOrErr)
118 return BMsOrErr.takeError();
119
120 std::vector<std::unique_ptr<Module>> Mods;
121 for (auto BM : *BMsOrErr) {
122 Expected<std::unique_ptr<Module>> MOrErr =
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
readIRSymtab(MemoryBufferRef MBRef)135 Expected<IRSymtabFile> object::readIRSymtab(MemoryBufferRef MBRef) {
136 IRSymtabFile F;
137 Expected<MemoryBufferRef> BCOrErr =
138 IRObjectFile::findBitcodeInMemBuffer(MBRef);
139 if (!BCOrErr)
140 return BCOrErr.takeError();
141
142 Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr);
143 if (!BFCOrErr)
144 return BFCOrErr.takeError();
145
146 Expected<irsymtab::FileContents> FCOrErr = irsymtab::readBitcode(*BFCOrErr);
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 }
156