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/ReaderWriter.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   Mang.reset(new Mangler());
  41   CollectAsmUndefinedRefs(Triple(M->getTargetTriple()), M->getModuleInlineAsm(),
  42                           [this](StringRef Name, BasicSymbolRef::Flags Flags) {
  43                             AsmSymbols.emplace_back(Name, std::move(Flags));
  44                           });
  45 }
  46
  47 // Parse inline ASM and collect the list of symbols that are not defined in
  48 // the current module. This is inspired from IRObjectFile.
  49 void IRObjectFile::CollectAsmUndefinedRefs(
  50     const Triple &TT, StringRef InlineAsm,
  51     function_ref<void(StringRef, BasicSymbolRef::Flags)> AsmUndefinedRefs) {
  52   if (InlineAsm.empty())
  53     return;
  54
  55   std::string Err;
  56   const Target *T = TargetRegistry::lookupTarget(TT.str(), Err);
  57   if (!T)
  58     return;
  59
  60   std::unique_ptr<MCRegisterInfo> MRI(T->createMCRegInfo(TT.str()));
  61   if (!MRI)
  62     return;
  63
  64   std::unique_ptr<MCAsmInfo> MAI(T->createMCAsmInfo(*MRI, TT.str()));
  65   if (!MAI)
  66     return;
  67
  68   std::unique_ptr<MCSubtargetInfo> STI(
  69       T->createMCSubtargetInfo(TT.str(), "", ""));
  70   if (!STI)
  71     return;
  72
  73   std::unique_ptr<MCInstrInfo> MCII(T->createMCInstrInfo());
  74   if (!MCII)
  75     return;
  76
  77   MCObjectFileInfo MOFI;
  78   MCContext MCCtx(MAI.get(), MRI.get(), &MOFI);
  79   MOFI.InitMCObjectFileInfo(TT, /*PIC*/ false, CodeModel::Default, MCCtx);
  80   std::unique_ptr<RecordStreamer> Streamer(new RecordStreamer(MCCtx));
  81   T->createNullTargetStreamer(*Streamer);
  82
  83   std::unique_ptr<MemoryBuffer> Buffer(MemoryBuffer::getMemBuffer(InlineAsm));
  84   SourceMgr SrcMgr;
  85   SrcMgr.AddNewSourceBuffer(std::move(Buffer), SMLoc());
  86   std::unique_ptr<MCAsmParser> Parser(
  87       createMCAsmParser(SrcMgr, MCCtx, *Streamer, *MAI));
  88
  89   MCTargetOptions MCOptions;
  90   std::unique_ptr<MCTargetAsmParser> TAP(
  91       T->createMCAsmParser(*STI, *Parser, *MCII, MCOptions));
  92   if (!TAP)
  93     return;
  94
  95   Parser->setTargetParser(*TAP);
  96   if (Parser->Run(false))
  97     return;
  98
  99   for (auto &KV : *Streamer) {
 100     StringRef Key = KV.first();
 101     RecordStreamer::State Value = KV.second;
 102     uint32_t Res = BasicSymbolRef::SF_None;
 103     switch (Value) {
 104     case RecordStreamer::NeverSeen:
 105       llvm_unreachable("foo");
 106     case RecordStreamer::DefinedGlobal:
 107       Res |= BasicSymbolRef::SF_Global;
 108       break;
 109     case RecordStreamer::Defined:
 110       break;
 111     case RecordStreamer::Global:
 112     case RecordStreamer::Used:
 113       Res |= BasicSymbolRef::SF_Undefined;
 114       Res |= BasicSymbolRef::SF_Global;
 115       break;
 116     case RecordStreamer::GlobalWeak:
 117       Res |= BasicSymbolRef::SF_Weak;
 118       Res |= BasicSymbolRef::SF_Global;
 119       break;
 120     }
 121     AsmUndefinedRefs(Key, BasicSymbolRef::Flags(Res));
 122   }
 123 }
 124
 125 IRObjectFile::~IRObjectFile() {
 126  }
 127
 128 static GlobalValue *getGV(DataRefImpl &Symb) {
 129   if ((Symb.p & 3) == 3)
 130     return nullptr;
 131
 132   return reinterpret_cast<GlobalValue*>(Symb.p & ~uintptr_t(3));
 133 }
 134
 135 static uintptr_t skipEmpty(Module::const_alias_iterator I, const Module &M) {
 136   if (I == M.alias_end())
 137     return 3;
 138   const GlobalValue *GV = &*I;
 139   return reinterpret_cast<uintptr_t>(GV) | 2;
 140 }
 141
 142 static uintptr_t skipEmpty(Module::const_global_iterator I, const Module &M) {
 143   if (I == M.global_end())
 144     return skipEmpty(M.alias_begin(), M);
 145   const GlobalValue *GV = &*I;
 146   return reinterpret_cast<uintptr_t>(GV) | 1;
 147 }
 148
 149 static uintptr_t skipEmpty(Module::const_iterator I, const Module &M) {
 150   if (I == M.end())
 151     return skipEmpty(M.global_begin(), M);
 152   const GlobalValue *GV = &*I;
 153   return reinterpret_cast<uintptr_t>(GV) | 0;
 154 }
 155
 156 static unsigned getAsmSymIndex(DataRefImpl Symb) {
 157   assert((Symb.p & uintptr_t(3)) == 3);
 158   uintptr_t Index = Symb.p & ~uintptr_t(3);
 159   Index >>= 2;
 160   return Index;
 161 }
 162
 163 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const {
 164   const GlobalValue *GV = getGV(Symb);
 165   uintptr_t Res;
 166
 167   switch (Symb.p & 3) {
 168   case 0: {
 169     Module::const_iterator Iter(static_cast<const Function*>(GV));
 170     ++Iter;
 171     Res = skipEmpty(Iter, *M);
 172     break;
 173   }
 174   case 1: {
 175     Module::const_global_iterator Iter(static_cast<const GlobalVariable*>(GV));
 176     ++Iter;
 177     Res = skipEmpty(Iter, *M);
 178     break;
 179   }
 180   case 2: {
 181     Module::const_alias_iterator Iter(static_cast<const GlobalAlias*>(GV));
 182     ++Iter;
 183     Res = skipEmpty(Iter, *M);
 184     break;
 185   }
 186   case 3: {
 187     unsigned Index = getAsmSymIndex(Symb);
 188     assert(Index < AsmSymbols.size());
 189     ++Index;
 190     Res = (Index << 2) | 3;
 191     break;
 192   }
 193   default:
 194     llvm_unreachable("unreachable case");
 195   }
 196
 197   Symb.p = Res;
 198 }
 199
 200 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS,
 201                                               DataRefImpl Symb) const {
 202   const GlobalValue *GV = getGV(Symb);
 203   if (!GV) {
 204     unsigned Index = getAsmSymIndex(Symb);
 205     assert(Index <= AsmSymbols.size());
 206     OS << AsmSymbols[Index].first;
 207     return std::error_code();
 208   }
 209
 210   if (GV->hasDLLImportStorageClass())
 211     OS << "__imp_";
 212
 213   if (Mang)
 214     Mang->getNameWithPrefix(OS, GV, false);
 215   else
 216     OS << GV->getName();
 217
 218   return std::error_code();
 219 }
 220
 221 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const {
 222   const GlobalValue *GV = getGV(Symb);
 223
 224   if (!GV) {
 225     unsigned Index = getAsmSymIndex(Symb);
 226     assert(Index <= AsmSymbols.size());
 227     return AsmSymbols[Index].second;
 228   }
 229
 230   uint32_t Res = BasicSymbolRef::SF_None;
 231   if (GV->isDeclarationForLinker())
 232     Res |= BasicSymbolRef::SF_Undefined;
 233   else if (GV->hasHiddenVisibility() && !GV->hasLocalLinkage())
 234     Res |= BasicSymbolRef::SF_Hidden;
 235   if (const GlobalVariable *GVar = dyn_cast<GlobalVariable>(GV)) {
 236     if (GVar->isConstant())
 237       Res |= BasicSymbolRef::SF_Const;
 238   }
 239   if (GV->hasPrivateLinkage())
 240     Res |= BasicSymbolRef::SF_FormatSpecific;
 241   if (!GV->hasLocalLinkage())
 242     Res |= BasicSymbolRef::SF_Global;
 243   if (GV->hasCommonLinkage())
 244     Res |= BasicSymbolRef::SF_Common;
 245   if (GV->hasLinkOnceLinkage() || GV->hasWeakLinkage() ||
 246       GV->hasExternalWeakLinkage())
 247     Res |= BasicSymbolRef::SF_Weak;
 248
 249   if (GV->getName().startswith("llvm."))
 250     Res |= BasicSymbolRef::SF_FormatSpecific;
 251   else if (auto *Var = dyn_cast<GlobalVariable>(GV)) {
 252     if (Var->getSection() == "llvm.metadata")
 253       Res |= BasicSymbolRef::SF_FormatSpecific;
 254   }
 255
 256   return Res;
 257 }
 258
 259 GlobalValue *IRObjectFile::getSymbolGV(DataRefImpl Symb) { return getGV(Symb); }
 260
 261 std::unique_ptr<Module> IRObjectFile::takeModule() { return std::move(M); }
 262
 263 basic_symbol_iterator IRObjectFile::symbol_begin_impl() const {
 264   Module::const_iterator I = M->begin();
 265   DataRefImpl Ret;
 266   Ret.p = skipEmpty(I, *M);
 267   return basic_symbol_iterator(BasicSymbolRef(Ret, this));
 268 }
 269
 270 basic_symbol_iterator IRObjectFile::symbol_end_impl() const {
 271   DataRefImpl Ret;
 272   uint64_t NumAsm = AsmSymbols.size();
 273   NumAsm <<= 2;
 274   Ret.p = 3 | NumAsm;
 275   return basic_symbol_iterator(BasicSymbolRef(Ret, this));
 276 }
 277
 278 ErrorOr<MemoryBufferRef> IRObjectFile::findBitcodeInObject(const ObjectFile &Obj) {
 279   for (const SectionRef &Sec : Obj.sections()) {
 280     if (Sec.isBitcode()) {
 281       StringRef SecContents;
 282       if (std::error_code EC = Sec.getContents(SecContents))
 283         return EC;
 284       return MemoryBufferRef(SecContents, Obj.getFileName());
 285     }
 286   }
 287
 288   return object_error::bitcode_section_not_found;
 289 }
 290
 291 ErrorOr<MemoryBufferRef> IRObjectFile::findBitcodeInMemBuffer(MemoryBufferRef Object) {
 292   sys::fs::file_magic Type = sys::fs::identify_magic(Object.getBuffer());
 293   switch (Type) {
 294   case sys::fs::file_magic::bitcode:
 295     return Object;
 296   case sys::fs::file_magic::elf_relocatable:
 297   case sys::fs::file_magic::macho_object:
 298   case sys::fs::file_magic::coff_object: {
 299     Expected<std::unique_ptr<ObjectFile>> ObjFile =
 300         ObjectFile::createObjectFile(Object, Type);
 301     if (!ObjFile)
 302       return errorToErrorCode(ObjFile.takeError());
 303     return findBitcodeInObject(*ObjFile->get());
 304   }
 305   default:
 306     return object_error::invalid_file_type;
 307   }
 308 }
 309
 310 ErrorOr<std::unique_ptr<IRObjectFile>>
 311 llvm::object::IRObjectFile::create(MemoryBufferRef Object,
 312                                    LLVMContext &Context) {
 313   ErrorOr<MemoryBufferRef> BCOrErr = findBitcodeInMemBuffer(Object);
 314   if (!BCOrErr)
 315     return BCOrErr.getError();
 316
 317   std::unique_ptr<MemoryBuffer> Buff =
 318       MemoryBuffer::getMemBuffer(BCOrErr.get(), false);
 319
 320   ErrorOr<std::unique_ptr<Module>> MOrErr =
 321       getLazyBitcodeModule(std::move(Buff), Context,
 322                            /*ShouldLazyLoadMetadata*/ true);
 323   if (std::error_code EC = MOrErr.getError())
 324     return EC;
 325
 326   std::unique_ptr<Module> &M = MOrErr.get();
 327   return llvm::make_unique<IRObjectFile>(Object, std::move(M));
 328 }