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