1 //===- IRObjectFile.cpp - IR object file implementation ---------*- C++ -*-===//
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
7 //===----------------------------------------------------------------------===//
9 // Part of the IRObjectFile class implementation.
11 //===----------------------------------------------------------------------===//
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"
26 using namespace object;
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());
35 IRObjectFile::~IRObjectFile() {}
37 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
38 return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
41 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
42 Symb.p += sizeof(ModuleSymbolTable::Symbol);
45 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
46 DataRefImpl Symb) const {
47 SymTab.printSymbolName(OS, getSym(Symb));
48 return std::error_code();
51 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
52 return SymTab.getSymbolFlags(getSym(Symb));
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));
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));
68 StringRef IRObjectFile::getTargetTriple() const {
69 // Each module must have the same target triple, so we arbitrarily access the
71 return Mods[0]->getTargetTriple();
74 Expected<MemoryBufferRef>
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());
87 return errorCodeToError(object_error::bitcode_section_not_found);
90 Expected<MemoryBufferRef>
91 IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
92 file_magic Type = identify_magic(Object.getBuffer());
94 case file_magic::bitcode:
96 case file_magic::elf_relocatable:
97 case file_magic::macho_object:
98 case file_magic::coff_object: {
99 Expected<std::unique_ptr<ObjectFile>> ObjFile =
100 ObjectFile::createObjectFile(Object, Type);
102 return ObjFile.takeError();
103 return findBitcodeInObject(*ObjFile->get());
106 return errorCodeToError(object_error::invalid_file_type);
110 Expected<std::unique_ptr<IRObjectFile>>
111 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) {
112 Expected<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
114 return BCOrErr.takeError();
116 Expected<std::vector<BitcodeModule>> BMsOrErr =
117 getBitcodeModuleList(*BCOrErr);
119 return BMsOrErr.takeError();
121 std::vector<std::unique_ptr<Module>> Mods;
122 for (auto BM : *BMsOrErr) {
123 Expected<std::unique_ptr<Module>> MOrErr =
124 BM.getLazyModule(Context, /*ShouldLazyLoadMetadata*/ true,
125 /*IsImporting*/ false);
127 return MOrErr.takeError();
129 Mods.push_back(std::move(*MOrErr));
132 return std::unique_ptr<IRObjectFile>(
133 new IRObjectFile(*BCOrErr, std::move(Mods)));
136 Expected<IRSymtabFile> object::readIRSymtab(MemoryBufferRef MBRef) {
138 Expected<MemoryBufferRef> BCOrErr =
139 IRObjectFile::findBitcodeInMemBuffer(MBRef);
141 return BCOrErr.takeError();
143 Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr);
145 return BFCOrErr.takeError();
147 Expected<irsymtab::FileContents> FCOrErr = irsymtab::readBitcode(*BFCOrErr);
149 return FCOrErr.takeError();
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);