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 "RecordStreamer.h" 16 #include "llvm/ADT/STLExtras.h" 17 #include "llvm/BinaryFormat/Magic.h" 18 #include "llvm/Bitcode/BitcodeReader.h" 19 #include "llvm/IR/GVMaterializer.h" 20 #include "llvm/IR/LLVMContext.h" 21 #include "llvm/IR/Mangler.h" 22 #include "llvm/IR/Module.h" 23 #include "llvm/MC/MCAsmInfo.h" 24 #include "llvm/MC/MCContext.h" 25 #include "llvm/MC/MCInstrInfo.h" 26 #include "llvm/MC/MCObjectFileInfo.h" 27 #include "llvm/MC/MCParser/MCAsmParser.h" 28 #include "llvm/MC/MCParser/MCTargetAsmParser.h" 29 #include "llvm/MC/MCRegisterInfo.h" 30 #include "llvm/MC/MCSubtargetInfo.h" 31 #include "llvm/Object/ObjectFile.h" 32 #include "llvm/Support/MemoryBuffer.h" 33 #include "llvm/Support/SourceMgr.h" 34 #include "llvm/Support/TargetRegistry.h" 35 #include "llvm/Support/raw_ostream.h" 36 using namespace llvm; 37 using namespace object; 38 39 IRObjectFile::IRObjectFile(MemoryBufferRef Object, 40 std::vector<std::unique_ptr<Module>> Mods) 41 : SymbolicFile(Binary::ID_IR, Object), Mods(std::move(Mods)) { 42 for (auto &M : this->Mods) 43 SymTab.addModule(M.get()); 44 } 45 46 IRObjectFile::~IRObjectFile() {} 47 48 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) { 49 return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p); 50 } 51 52 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 53 Symb.p += sizeof(ModuleSymbolTable::Symbol); 54 } 55 56 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS, 57 DataRefImpl Symb) const { 58 SymTab.printSymbolName(OS, getSym(Symb)); 59 return std::error_code(); 60 } 61 62 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const { 63 return SymTab.getSymbolFlags(getSym(Symb)); 64 } 65 66 basic_symbol_iterator IRObjectFile::symbol_begin() const { 67 DataRefImpl Ret; 68 Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data()); 69 return basic_symbol_iterator(BasicSymbolRef(Ret, this)); 70 } 71 72 basic_symbol_iterator IRObjectFile::symbol_end() const { 73 DataRefImpl Ret; 74 Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() + 75 SymTab.symbols().size()); 76 return basic_symbol_iterator(BasicSymbolRef(Ret, this)); 77 } 78 79 StringRef IRObjectFile::getTargetTriple() const { 80 // Each module must have the same target triple, so we arbitrarily access the 81 // first one. 82 return Mods[0]->getTargetTriple(); 83 } 84 85 ErrorOr<MemoryBufferRef> IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) { 86 for (const SectionRef &Sec : Obj.sections()) { 87 if (Sec.isBitcode()) { 88 StringRef SecContents; 89 if (std::error_code EC = Sec.getContents(SecContents)) 90 return EC; 91 return MemoryBufferRef(SecContents, Obj.getFileName()); 92 } 93 } 94 95 return object_error::bitcode_section_not_found; 96 } 97 98 ErrorOr<MemoryBufferRef> IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) { 99 file_magic Type = identify_magic(Object.getBuffer()); 100 switch (Type) { 101 case file_magic::bitcode: 102 return Object; 103 case file_magic::elf_relocatable: 104 case file_magic::macho_object: 105 case file_magic::coff_object: { 106 Expected<std::unique_ptr<ObjectFile>> ObjFile = 107 ObjectFile::createObjectFile(Object, Type); 108 if (!ObjFile) 109 return errorToErrorCode(ObjFile.takeError()); 110 return findBitcodeInObject(*ObjFile->get()); 111 } 112 default: 113 return object_error::invalid_file_type; 114 } 115 } 116 117 Expected<std::unique_ptr<IRObjectFile>> 118 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) { 119 ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); 120 if (!BCOrErr) 121 return errorCodeToError(BCOrErr.getError()); 122 123 Expected<std::vector<BitcodeModule>> BMsOrErr = 124 getBitcodeModuleList(*BCOrErr); 125 if (!BMsOrErr) 126 return BMsOrErr.takeError(); 127 128 std::vector<std::unique_ptr<Module>> Mods; 129 for (auto BM : *BMsOrErr) { 130 Expected<std::unique_ptr<Module>> MOrErr = 131 BM.getLazyModule(Context, /*ShouldLazyLoadMetadata*/ true, 132 /*IsImporting*/ false); 133 if (!MOrErr) 134 return MOrErr.takeError(); 135 136 Mods.push_back(std::move(*MOrErr)); 137 } 138 139 return std::unique_ptr<IRObjectFile>( 140 new IRObjectFile(*BCOrErr, std::move(Mods))); 141 } 142 143 Expected<IRSymtabFile> object::readIRSymtab(MemoryBufferRef MBRef) { 144 IRSymtabFile F; 145 ErrorOr<MemoryBufferRef> BCOrErr = 146 IRObjectFile::findBitcodeInMemBuffer(MBRef); 147 if (!BCOrErr) 148 return errorCodeToError(BCOrErr.getError()); 149 150 Expected<std::vector<BitcodeModule>> BMsOrErr = 151 getBitcodeModuleList(*BCOrErr); 152 if (!BMsOrErr) 153 return BMsOrErr.takeError(); 154 155 Expected<irsymtab::FileContents> FCOrErr = irsymtab::readBitcode(*BMsOrErr); 156 if (!FCOrErr) 157 return FCOrErr.takeError(); 158 159 F.Mods = std::move(*BMsOrErr); 160 F.Symtab = std::move(FCOrErr->Symtab); 161 F.Strtab = std::move(FCOrErr->Strtab); 162 F.TheReader = std::move(FCOrErr->TheReader); 163 return std::move(F); 164 } 165