contrib/llvm/lib/Object/IRObjectFile.cpp

   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,
  39                            std::vector<std::unique_ptr<Module>> Mods)
  40     : SymbolicFile(Binary::ID_IR, Object), Mods(std::move(Mods)) {
  41   for (auto &M : this->Mods)
  42     SymTab.addModule(M.get());
  43 }
  44
  45 IRObjectFile::~IRObjectFile() {}
  46
  47 static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
  48   return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
  49 }
  50
  51 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
  52   Symb.p += sizeof(ModuleSymbolTable::Symbol);
  53 }
  54
  55 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
  56                                               DataRefImpl Symb) const {
  57   SymTab.printSymbolName(OS, getSym(Symb));
  58   return std::error_code();
  59 }
  60
  61 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
  62   return SymTab.getSymbolFlags(getSym(Symb));
  63 }
  64
  65 basic_symbol_iterator IRObjectFile::symbol_begin() const {
  66   DataRefImpl Ret;
  67   Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
  68   return basic_symbol_iterator(BasicSymbolRef(Ret, this));
  69 }
  70
  71 basic_symbol_iterator IRObjectFile::symbol_end() const {
  72   DataRefImpl Ret;
  73   Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
  74                                       SymTab.symbols().size());
  75   return basic_symbol_iterator(BasicSymbolRef(Ret, this));
  76 }
  77
  78 StringRef IRObjectFile::getTargetTriple() const {
  79   // Each module must have the same target triple, so we arbitrarily access the
  80   // first one.
  81   return Mods[0]->getTargetTriple();
  82 }
  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 IRObjectFile::create(MemoryBufferRef Object, LLVMContext &Context) {
 118   ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
 119   if (!BCOrErr)
 120     return errorCodeToError(BCOrErr.getError());
 121
 122   Expected<std::vector<BitcodeModule>> BMsOrErr =
 123       getBitcodeModuleList(*BCOrErr);
 124   if (!BMsOrErr)
 125     return BMsOrErr.takeError();
 126
 127   std::vector<std::unique_ptr<Module>> Mods;
 128   for (auto BM : *BMsOrErr) {
 129     Expected<std::unique_ptr<Module>> MOrErr =
 130         BM.getLazyModule(Context, /*ShouldLazyLoadMetadata*/ true,
 131                          /*IsImporting*/ false);
 132     if (!MOrErr)
 133       return MOrErr.takeError();
 134
 135     Mods.push_back(std::move(*MOrErr));
 136   }
 137
 138   return std::unique_ptr<IRObjectFile>(
 139       new IRObjectFile(*BCOrErr, std::move(Mods)));
 140 }