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/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/MC/MCAsmInfo.h" 23 #include "llvm/MC/MCContext.h" 24 #include "llvm/MC/MCInstrInfo.h" 25 #include "llvm/MC/MCObjectFileInfo.h" 26 #include "llvm/MC/MCParser/MCAsmParser.h" 27 #include "llvm/MC/MCParser/MCTargetAsmParser.h" 28 #include "llvm/MC/MCRegisterInfo.h" 29 #include "llvm/MC/MCSubtargetInfo.h" 30 #include "llvm/Object/ObjectFile.h" 31 #include "llvm/Support/MemoryBuffer.h" 32 #include "llvm/Support/SourceMgr.h" 33 #include "llvm/Support/TargetRegistry.h" 34 #include "llvm/Support/raw_ostream.h" 35 using namespace llvm; 36 using namespace object; 37 38 IRObjectFile::IRObjectFile(MemoryBufferRef Object, std::unique_ptr<Module> Mod) 39 : SymbolicFile(Binary::ID_IR, Object), M(std::move(Mod)) { 40 SymTab.addModule(M.get()); 41 } 42 43 IRObjectFile::~IRObjectFile() {} 44 45 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) { 46 return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p); 47 } 48 49 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 50 Symb.p += sizeof(ModuleSymbolTable::Symbol); 51 } 52 53 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS, 54 DataRefImpl Symb) const { 55 SymTab.printSymbolName(OS, getSym(Symb)); 56 return std::error_code(); 57 } 58 59 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const { 60 return SymTab.getSymbolFlags(getSym(Symb)); 61 } 62 63 GlobalValue *IRObjectFile::getSymbolGV(DataRefImpl Symb) { 64 return getSym(Symb).dyn_cast<GlobalValue *>(); 65 } 66 67 std::unique_ptr<Module> IRObjectFile::takeModule() { return std::move(M); } 68 69 basic_symbol_iterator IRObjectFile::symbol_begin() const { 70 DataRefImpl Ret; 71 Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data()); 72 return basic_symbol_iterator(BasicSymbolRef(Ret, this)); 73 } 74 75 basic_symbol_iterator IRObjectFile::symbol_end() const { 76 DataRefImpl Ret; 77 Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() + 78 SymTab.symbols().size()); 79 return basic_symbol_iterator(BasicSymbolRef(Ret, this)); 80 } 81 82 StringRef IRObjectFile::getTargetTriple() const { return M->getTargetTriple(); } 83 84 ErrorOr<MemoryBufferRef> IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) { 85 for (const SectionRef &Sec : Obj.sections()) { 86 if (Sec.isBitcode()) { 87 StringRef SecContents; 88 if (std::error_code EC = Sec.getContents(SecContents)) 89 return EC; 90 return MemoryBufferRef(SecContents, Obj.getFileName()); 91 } 92 } 93 94 return object_error::bitcode_section_not_found; 95 } 96 97 ErrorOr<MemoryBufferRef> IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) { 98 sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer()); 99 switch (Type) { 100 case sys::fs::file_magic::bitcode: 101 return Object; 102 case sys::fs::file_magic::elf_relocatable: 103 case sys::fs::file_magic::macho_object: 104 case sys::fs::file_magic::coff_object: { 105 Expected<std::unique_ptr<ObjectFile>> ObjFile = 106 ObjectFile::createObjectFile(Object, Type); 107 if (!ObjFile) 108 return errorToErrorCode(ObjFile.takeError()); 109 return findBitcodeInObject(*ObjFile->get()); 110 } 111 default: 112 return object_error::invalid_file_type; 113 } 114 } 115 116 Expected<std::unique_ptr<IRObjectFile>> 117 llvm::object::IRObjectFile::create(MemoryBufferRef Object, 118 LLVMContext &Context) { 119 ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object); 120 if (!BCOrErr) 121 return errorCodeToError(BCOrErr.getError()); 122 123 Expected<std::unique_ptr<Module>> MOrErr = 124 getLazyBitcodeModule(*BCOrErr, Context, 125 /*ShouldLazyLoadMetadata*/ true); 126 if (!MOrErr) 127 return MOrErr.takeError(); 128 129 std::unique_ptr<Module> &M = MOrErr.get(); 130 return llvm::make_unique<IRObjectFile>(BCOrErr.get(), std::move(M)); 131 } 132