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 
13 #include "llvm/Object/IRObjectFile.h"
14 #include "llvm/ADT/STLExtras.h"
15 #include "llvm/BinaryFormat/Magic.h"
16 #include "llvm/Bitcode/BitcodeReader.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"
22 #include "llvm/Support/MemoryBuffer.h"
23 #include "llvm/Support/TargetRegistry.h"
24 #include "llvm/Support/raw_ostream.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 {
55   DataRefImpl Ret;
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 {
61   DataRefImpl Ret;
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 
73 Expected<MemoryBufferRef>
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 
89 Expected<MemoryBufferRef>
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>>
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 
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