lib/Object/IRObjectFile.cpp

   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 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
  46                                               DataRefImpl Symb) const {
  47   SymTab.printSymbolName(OS, getSym(Symb));
  48   return std::error_code();
  49 }
  50
  51 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
  52   return SymTab.getSymbolFlags(getSym(Symb));
  53 }
  54
  55 basic_symbol_iterator IRObjectFile::symbol_begin() const {
  56   DataRefImpl Ret;
  57   Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
  58   return basic_symbol_iterator(BasicSymbolRef(Ret, this));
  59 }
  60
  61 basic_symbol_iterator IRObjectFile::symbol_end() const {
  62   DataRefImpl Ret;
  63   Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
  64                                       SymTab.symbols().size());
  65   return basic_symbol_iterator(BasicSymbolRef(Ret, this));
  66 }
  67
  68 StringRef IRObjectFile::getTargetTriple() const {
  69   // Each module must have the same target triple, so we arbitrarily access the
  70   // first one.
  71   return Mods[0]->getTargetTriple();
  72 }
  73
  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());
  84     }
  85   }
  86
  87   return errorCodeToError(object_error::bitcode_section_not_found);
  88 }
  89
  90 Expected<MemoryBufferRef>
  91 IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
  92   file_magic Type = identify_magic(Object.getBuffer());
  93   switch (Type) {
  94   case file_magic::bitcode:
  95     return Object;
  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);
 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 }