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/Bitcode/ReaderWriter.h" 15 #include "llvm/IR/LLVMContext.h" 16 #include "llvm/IR/Mangler.h" 17 #include "llvm/IR/Module.h" 18 #include "llvm/Object/IRObjectFile.h" 19 #include "llvm/Support/raw_ostream.h" 20 using namespace llvm; 21 using namespace object; 22 23 IRObjectFile::IRObjectFile(MemoryBuffer *Object, std::error_code &EC, 24 LLVMContext &Context, bool BufferOwned) 25 : SymbolicFile(Binary::ID_IR, Object, BufferOwned) { 26 ErrorOr<Module*> MOrErr = parseBitcodeFile(Object, Context); 27 if ((EC = MOrErr.getError())) 28 return; 29 30 M.reset(MOrErr.get()); 31 32 // If we have a DataLayout, setup a mangler. 33 const DataLayout *DL = M->getDataLayout(); 34 if (!DL) 35 return; 36 37 Mang.reset(new Mangler(DL)); 38 } 39 40 static const GlobalValue &getGV(DataRefImpl &Symb) { 41 return *reinterpret_cast<GlobalValue*>(Symb.p & ~uintptr_t(3)); 42 } 43 44 static uintptr_t skipEmpty(Module::const_alias_iterator I, const Module &M) { 45 if (I == M.alias_end()) 46 return 3; 47 const GlobalValue *GV = &*I; 48 return reinterpret_cast<uintptr_t>(GV) | 2; 49 } 50 51 static uintptr_t skipEmpty(Module::const_global_iterator I, const Module &M) { 52 if (I == M.global_end()) 53 return skipEmpty(M.alias_begin(), M); 54 const GlobalValue *GV = &*I; 55 return reinterpret_cast<uintptr_t>(GV) | 1; 56 } 57 58 static uintptr_t skipEmpty(Module::const_iterator I, const Module &M) { 59 if (I == M.end()) 60 return skipEmpty(M.global_begin(), M); 61 const GlobalValue *GV = &*I; 62 return reinterpret_cast<uintptr_t>(GV) | 0; 63 } 64 65 void IRObjectFile::moveSymbolNext(DataRefImpl &Symb) const { 66 const GlobalValue *GV = &getGV(Symb); 67 const Module &M = *GV->getParent(); 68 uintptr_t Res; 69 switch (Symb.p & 3) { 70 case 0: { 71 Module::const_iterator Iter(static_cast<const Function*>(GV)); 72 ++Iter; 73 Res = skipEmpty(Iter, M); 74 break; 75 } 76 case 1: { 77 Module::const_global_iterator Iter(static_cast<const GlobalVariable*>(GV)); 78 ++Iter; 79 Res = skipEmpty(Iter, M); 80 break; 81 } 82 case 2: { 83 Module::const_alias_iterator Iter(static_cast<const GlobalAlias*>(GV)); 84 ++Iter; 85 Res = skipEmpty(Iter, M); 86 break; 87 } 88 case 3: 89 llvm_unreachable("Invalid symbol reference"); 90 } 91 92 Symb.p = Res; 93 } 94 95 std::error_code IRObjectFile::printSymbolName(raw_ostream &OS, 96 DataRefImpl Symb) const { 97 const GlobalValue &GV = getGV(Symb); 98 99 if (Mang) 100 Mang->getNameWithPrefix(OS, &GV, false); 101 else 102 OS << GV.getName(); 103 104 return object_error::success; 105 } 106 107 uint32_t IRObjectFile::getSymbolFlags(DataRefImpl Symb) const { 108 const GlobalValue &GV = getGV(Symb); 109 110 uint32_t Res = BasicSymbolRef::SF_None; 111 if (GV.isDeclaration() || GV.hasAvailableExternallyLinkage()) 112 Res |= BasicSymbolRef::SF_Undefined; 113 if (GV.hasPrivateLinkage()) 114 Res |= BasicSymbolRef::SF_FormatSpecific; 115 if (!GV.hasLocalLinkage()) 116 Res |= BasicSymbolRef::SF_Global; 117 if (GV.hasCommonLinkage()) 118 Res |= BasicSymbolRef::SF_Common; 119 if (GV.hasLinkOnceLinkage() || GV.hasWeakLinkage()) 120 Res |= BasicSymbolRef::SF_Weak; 121 122 return Res; 123 } 124 125 const GlobalValue &IRObjectFile::getSymbolGV(DataRefImpl Symb) const { 126 const GlobalValue &GV = getGV(Symb); 127 return GV; 128 } 129 130 basic_symbol_iterator IRObjectFile::symbol_begin_impl() const { 131 Module::const_iterator I = M->begin(); 132 DataRefImpl Ret; 133 Ret.p = skipEmpty(I, *M); 134 return basic_symbol_iterator(BasicSymbolRef(Ret, this)); 135 } 136 137 basic_symbol_iterator IRObjectFile::symbol_end_impl() const { 138 DataRefImpl Ret; 139 Ret.p = 3; 140 return basic_symbol_iterator(BasicSymbolRef(Ret, this)); 141 } 142 143 ErrorOr<SymbolicFile *> llvm::object::SymbolicFile::createIRObjectFile( 144 MemoryBuffer *Object, LLVMContext &Context, bool BufferOwned) { 145 std::error_code EC; 146 std::unique_ptr<IRObjectFile> Ret( 147 new IRObjectFile(Object, EC, Context, BufferOwned)); 148 if (EC) 149 return EC; 150 return Ret.release(); 151 } 152