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 Expected<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::wasm_object: 98 case file_magic::coff_object: { 99 Expected<std::unique_ptr<ObjectFile>> ObjFile = 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 110 Expected<std::unique_ptr<IRObjectFile>> 111 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) { 112 Expected<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); 113 if (!BCOrErr) 114 return BCOrErr.takeError(); 115 116 Expected<std::vector<BitcodeModule>> BMsOrErr = 117 getBitcodeModuleList(*BCOrErr); 118 if (!BMsOrErr) 119 return BMsOrErr.takeError(); 120 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); 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 136 Expected<IRSymtabFile> object::readIRSymtab(MemoryBufferRef MBRef) { 137 IRSymtabFile F; 138 Expected<MemoryBufferRef> BCOrErr = 139 IRObjectFile::findBitcodeInMemBuffer(MBRef); 140 if (!BCOrErr) 141 return BCOrErr.takeError(); 142 143 Expected<BitcodeFileContents> BFCOrErr = getBitcodeFileContents(*BCOrErr); 144 if (!BFCOrErr) 145 return BFCOrErr.takeError(); 146 147 Expected<irsymtab::FileContents> FCOrErr = irsymtab::readBitcode(*BFCOrErr); 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 } 157