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