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 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 36 IRObjectFile::~IRObjectFile() {} 37 38 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) { 39 return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p); 40 } 41 42 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 43 Symb.p += sizeof(ModuleSymbolTable::Symbol); 44 } 45 46 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 52 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const { 53 return SymTab.getSymbolFlags(getSym(Symb)); 54 } 55 56 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 62 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 69 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> 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> 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