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"
25using namespace llvm;
26using namespace object;
27
28IRObjectFile::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
35IRObjectFile::~IRObjectFile() {}
36
37static ModuleSymbolTable::Symbol getSym(DataRefImpl &Symb) {
38  return *reinterpret_cast<ModuleSymbolTable::Symbol *>(Symb.p);
39}
40
41void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
42  Symb.p += sizeof(ModuleSymbolTable::Symbol);
43}
44
45Error IRObjectFile::printSymbolName(raw_ostream &OS, DataRefImpl Symb) const {
46  SymTab.printSymbolName(OS, getSym(Symb));
47  return Error::success();
48}
49
50uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
51  return SymTab.getSymbolFlags(getSym(Symb));
52}
53
54basic_symbol_iterator IRObjectFile::symbol_begin() const {
55  DataRefImpl Ret;
56  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data());
57  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
58}
59
60basic_symbol_iterator IRObjectFile::symbol_end() const {
61  DataRefImpl Ret;
62  Ret.p = reinterpret_cast<uintptr_t>(SymTab.symbols().data() +
63                                      SymTab.symbols().size());
64  return basic_symbol_iterator(BasicSymbolRef(Ret, this));
65}
66
67StringRef IRObjectFile::getTargetTriple() const {
68  // Each module must have the same target triple, so we arbitrarily access the
69  // first one.
70  return Mods[0]->getTargetTriple();
71}
72
73Expected<MemoryBufferRef>
74IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
75  for (const SectionRef &Sec : Obj.sections()) {
76    if (Sec.isBitcode()) {
77      Expected<StringRef> Contents = Sec.getContents();
78      if (!Contents)
79        return Contents.takeError();
80      if (Contents->size() <= 1)
81        return errorCodeToError(object_error::bitcode_section_not_found);
82      return MemoryBufferRef(*Contents, Obj.getFileName());
83    }
84  }
85
86  return errorCodeToError(object_error::bitcode_section_not_found);
87}
88
89Expected<MemoryBufferRef>
90IRObjectFile::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
109Expected<std::unique_ptr<IRObjectFile>>
110IRObjectFile::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
135Expected<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