static void PrintDILineInfo(DILineInfo dli) { if (PrintFunctions) outs() << (dli.getFunctionName() ? dli.getFunctionName() : "<unknown>") << "\n"; outs() << (dli.getFileName() ? dli.getFileName() : "<unknown>") << ':' << dli.getLine() << ':' << dli.getColumn() << '\n'; }
static void DumpInput(const StringRef &Filename) { OwningPtr<MemoryBuffer> Buff; if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buff)) { errs() << Filename << ": " << ec.message() << "\n"; return; } OwningPtr<ObjectFile> Obj(ObjectFile::createObjectFile(Buff.take())); StringRef DebugInfoSection; StringRef DebugAbbrevSection; StringRef DebugLineSection; StringRef DebugArangesSection; StringRef DebugStringSection; error_code ec; for (ObjectFile::section_iterator i = Obj->begin_sections(), e = Obj->end_sections(); i != e; i.increment(ec)) { StringRef name; i->getName(name); StringRef data; i->getContents(data); if (name.startswith("__DWARF,")) name = name.substr(8); // Skip "__DWARF," prefix. name = name.substr(name.find_first_not_of("._")); // Skip . and _ prefixes. if (name == "debug_info") DebugInfoSection = data; else if (name == "debug_abbrev") DebugAbbrevSection = data; else if (name == "debug_line") DebugLineSection = data; else if (name == "debug_aranges") DebugArangesSection = data; else if (name == "debug_str") DebugStringSection = data; } OwningPtr<DIContext> dictx(DIContext::getDWARFContext(/*FIXME*/true, DebugInfoSection, DebugAbbrevSection, DebugArangesSection, DebugLineSection, DebugStringSection)); if (Address == -1ULL) { outs() << Filename << ":\tfile format " << Obj->getFileFormatName() << "\n\n"; // Dump the complete DWARF structure. dictx->dump(outs()); } else { // Print line info for the specified address. DILineInfo dli = dictx->getLineInfoForAddress(Address); outs() << (dli.getFileName() ? dli.getFileName() : "<unknown>") << ':' << dli.getLine() << ':' << dli.getColumn() << '\n'; } }
void lookup_pointer(DIContext *context, const char **name, size_t *line, const char **filename, size_t pointer, int demangle, int *fromC) { DILineInfo info; if (demangle && *name != NULL) *name = jl_demangle(*name); #ifdef LLVM35 DILineInfoSpecifier infoSpec(DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, DILineInfoSpecifier::FunctionNameKind::ShortName); #else int infoSpec = DILineInfoSpecifier::FileLineInfo | DILineInfoSpecifier::AbsoluteFilePath | DILineInfoSpecifier::FunctionName; #endif if (context == NULL) goto done; info = context->getLineInfoForAddress(pointer, infoSpec); #ifndef LLVM35 // LLVM <= 3.4 if (strcmp(info.getFunctionName(), "<invalid>") == 0) goto done; if (demangle) *name = jl_demangle(info.getFunctionName()); else *name = strdup(info.getFunctionName()); *line = info.getLine(); *filename = strdup(info.getFileName()); #else if (strcmp(info.FunctionName.c_str(), "<invalid>") == 0) goto done; *name = strdup(info.FunctionName.c_str()); *line = info.Line; *filename = strdup(info.FileName.c_str()); #endif done: // If this is a jlcall wrapper, set fromC to match JIT behavior if (*name == NULL || memcmp(*name,"jlcall_",7) == 0) *fromC = true; }
void lookup_pointer(DIContext *context, const char **name, int *line, const char **filename, size_t pointer, int demangle) { if (context == NULL) return; #ifdef LLVM35 DILineInfoSpecifier infoSpec(DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, DILineInfoSpecifier::FunctionNameKind::ShortName); #else int infoSpec = DILineInfoSpecifier::FileLineInfo | DILineInfoSpecifier::AbsoluteFilePath | DILineInfoSpecifier::FunctionName; #endif DILineInfo info = context->getLineInfoForAddress(pointer, infoSpec); #ifndef LLVM35 // LLVM <= 3.4 if (strcmp(info.getFunctionName(), "<invalid>") == 0) return; if (demangle) *name = jl_demangle(info.getFunctionName()); else *name = strdup(info.getFunctionName()); *line = info.getLine(); *filename = strdup(info.getFileName()); #else if (strcmp(info.FunctionName.c_str(), "<invalid>") == 0) return; *name = strdup(info.FunctionName.c_str()); *line = info.Line; *filename = strdup(info.FileName.c_str()); #endif }
std::string LLVMSymbolizer::printDILineInfo(DILineInfo LineInfo) const { // By default, DILineInfo contains "<invalid>" for function/filename it // cannot fetch. We replace it to "??" to make our output closer to addr2line. static const std::string kDILineInfoBadString = "<invalid>"; std::stringstream Result; if (Opts.PrintFunctions) { std::string FunctionName = LineInfo.getFunctionName(); if (FunctionName == kDILineInfoBadString) FunctionName = kBadString; DemangleName(FunctionName); Result << FunctionName << "\n"; } std::string Filename = LineInfo.getFileName(); if (Filename == kDILineInfoBadString) Filename = kBadString; Result << Filename << ":" << LineInfo.getLine() << ":" << LineInfo.getColumn() << "\n"; return Result.str(); }
static void patchFunctionNameInDILineInfo(const std::string &NewFunctionName, DILineInfo &LineInfo) { std::string FileName = LineInfo.getFileName(); LineInfo = DILineInfo(StringRef(FileName), StringRef(NewFunctionName), LineInfo.getLine(), LineInfo.getColumn()); }
void llvm::DisassembleInputMachO(StringRef Filename) { OwningPtr<MemoryBuffer> Buff; if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buff)) { errs() << "llvm-objdump: " << Filename << ": " << ec.message() << "\n"; return; } OwningPtr<MachOObjectFile> MachOOF(static_cast<MachOObjectFile*>( ObjectFile::createMachOObjectFile(Buff.take()))); MachOObject *MachOObj = MachOOF->getObject(); const Target *TheTarget = GetTarget(MachOObj); if (!TheTarget) { // GetTarget prints out stuff. return; } OwningPtr<const MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo()); OwningPtr<MCInstrAnalysis> InstrAnalysis(TheTarget->createMCInstrAnalysis(InstrInfo.get())); // Set up disassembler. OwningPtr<const MCAsmInfo> AsmInfo(TheTarget->createMCAsmInfo(TripleName)); OwningPtr<const MCSubtargetInfo> STI(TheTarget->createMCSubtargetInfo(TripleName, "", "")); OwningPtr<const MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI)); OwningPtr<const MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName)); int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); OwningPtr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI, *STI)); if (!InstrAnalysis || !AsmInfo || !STI || !DisAsm || !IP) { errs() << "error: couldn't initialize disassembler for target " << TripleName << '\n'; return; } outs() << '\n' << Filename << ":\n\n"; const macho::Header &Header = MachOObj->getHeader(); const MachOObject::LoadCommandInfo *SymtabLCI = 0; // First, find the symbol table segment. for (unsigned i = 0; i != Header.NumLoadCommands; ++i) { const MachOObject::LoadCommandInfo &LCI = MachOObj->getLoadCommandInfo(i); if (LCI.Command.Type == macho::LCT_Symtab) { SymtabLCI = &LCI; break; } } // Read and register the symbol table data. InMemoryStruct<macho::SymtabLoadCommand> SymtabLC; if (SymtabLCI) { MachOObj->ReadSymtabLoadCommand(*SymtabLCI, SymtabLC); MachOObj->RegisterStringTable(*SymtabLC); } std::vector<SectionRef> Sections; std::vector<SymbolRef> Symbols; SmallVector<uint64_t, 8> FoundFns; getSectionsAndSymbols(Header, MachOOF.get(), &SymtabLC, Sections, Symbols, FoundFns); // Make a copy of the unsorted symbol list. FIXME: duplication std::vector<SymbolRef> UnsortedSymbols(Symbols); // Sort the symbols by address, just in case they didn't come in that way. std::sort(Symbols.begin(), Symbols.end(), SymbolSorter()); #ifndef NDEBUG raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls(); #else raw_ostream &DebugOut = nulls(); #endif StringRef DebugAbbrevSection, DebugInfoSection, DebugArangesSection, DebugLineSection, DebugStrSection; OwningPtr<DIContext> diContext; OwningPtr<MachOObjectFile> DSYMObj; MachOObject *DbgInfoObj = MachOObj; // Try to find debug info and set up the DIContext for it. if (UseDbg) { ArrayRef<SectionRef> DebugSections = Sections; std::vector<SectionRef> DSYMSections; // A separate DSym file path was specified, parse it as a macho file, // get the sections and supply it to the section name parsing machinery. if (!DSYMFile.empty()) { OwningPtr<MemoryBuffer> Buf; if (error_code ec = MemoryBuffer::getFileOrSTDIN(DSYMFile.c_str(), Buf)) { errs() << "llvm-objdump: " << Filename << ": " << ec.message() << '\n'; return; } DSYMObj.reset(static_cast<MachOObjectFile*>( ObjectFile::createMachOObjectFile(Buf.take()))); const macho::Header &Header = DSYMObj->getObject()->getHeader(); std::vector<SymbolRef> Symbols; SmallVector<uint64_t, 8> FoundFns; getSectionsAndSymbols(Header, DSYMObj.get(), 0, DSYMSections, Symbols, FoundFns); DebugSections = DSYMSections; DbgInfoObj = DSYMObj.get()->getObject(); } // Find the named debug info sections. for (unsigned SectIdx = 0; SectIdx != DebugSections.size(); SectIdx++) { StringRef SectName; if (!DebugSections[SectIdx].getName(SectName)) { if (SectName.equals("__DWARF,__debug_abbrev")) DebugSections[SectIdx].getContents(DebugAbbrevSection); else if (SectName.equals("__DWARF,__debug_info")) DebugSections[SectIdx].getContents(DebugInfoSection); else if (SectName.equals("__DWARF,__debug_aranges")) DebugSections[SectIdx].getContents(DebugArangesSection); else if (SectName.equals("__DWARF,__debug_line")) DebugSections[SectIdx].getContents(DebugLineSection); else if (SectName.equals("__DWARF,__debug_str")) DebugSections[SectIdx].getContents(DebugStrSection); } } // Setup the DIContext. diContext.reset(DIContext::getDWARFContext(DbgInfoObj->isLittleEndian(), DebugInfoSection, DebugAbbrevSection, DebugArangesSection, DebugLineSection, DebugStrSection)); } FunctionMapTy FunctionMap; FunctionListTy Functions; for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) { StringRef SectName; if (Sections[SectIdx].getName(SectName) || SectName.compare("__TEXT,__text")) continue; // Skip non-text sections // Insert the functions from the function starts segment into our map. uint64_t VMAddr; Sections[SectIdx].getAddress(VMAddr); for (unsigned i = 0, e = FoundFns.size(); i != e; ++i) { StringRef SectBegin; Sections[SectIdx].getContents(SectBegin); uint64_t Offset = (uint64_t)SectBegin.data(); FunctionMap.insert(std::make_pair(VMAddr + FoundFns[i]-Offset, (MCFunction*)0)); } StringRef Bytes; Sections[SectIdx].getContents(Bytes); StringRefMemoryObject memoryObject(Bytes); bool symbolTableWorked = false; // Parse relocations. std::vector<std::pair<uint64_t, SymbolRef> > Relocs; error_code ec; for (relocation_iterator RI = Sections[SectIdx].begin_relocations(), RE = Sections[SectIdx].end_relocations(); RI != RE; RI.increment(ec)) { uint64_t RelocOffset, SectionAddress; RI->getAddress(RelocOffset); Sections[SectIdx].getAddress(SectionAddress); RelocOffset -= SectionAddress; SymbolRef RelocSym; RI->getSymbol(RelocSym); Relocs.push_back(std::make_pair(RelocOffset, RelocSym)); } array_pod_sort(Relocs.begin(), Relocs.end()); // Disassemble symbol by symbol. for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) { StringRef SymName; Symbols[SymIdx].getName(SymName); SymbolRef::Type ST; Symbols[SymIdx].getType(ST); if (ST != SymbolRef::ST_Function) continue; // Make sure the symbol is defined in this section. bool containsSym = false; Sections[SectIdx].containsSymbol(Symbols[SymIdx], containsSym); if (!containsSym) continue; // Start at the address of the symbol relative to the section's address. uint64_t SectionAddress = 0; uint64_t Start = 0; Sections[SectIdx].getAddress(SectionAddress); Symbols[SymIdx].getAddress(Start); Start -= SectionAddress; // Stop disassembling either at the beginning of the next symbol or at // the end of the section. bool containsNextSym = false; uint64_t NextSym = 0; uint64_t NextSymIdx = SymIdx+1; while (Symbols.size() > NextSymIdx) { SymbolRef::Type NextSymType; Symbols[NextSymIdx].getType(NextSymType); if (NextSymType == SymbolRef::ST_Function) { Sections[SectIdx].containsSymbol(Symbols[NextSymIdx], containsNextSym); Symbols[NextSymIdx].getAddress(NextSym); NextSym -= SectionAddress; break; } ++NextSymIdx; } uint64_t SectSize; Sections[SectIdx].getSize(SectSize); uint64_t End = containsNextSym ? NextSym : SectSize; uint64_t Size; symbolTableWorked = true; if (!CFG) { // Normal disassembly, print addresses, bytes and mnemonic form. StringRef SymName; Symbols[SymIdx].getName(SymName); outs() << SymName << ":\n"; DILineInfo lastLine; for (uint64_t Index = Start; Index < End; Index += Size) { MCInst Inst; if (DisAsm->getInstruction(Inst, Size, memoryObject, Index, DebugOut, nulls())) { uint64_t SectAddress = 0; Sections[SectIdx].getAddress(SectAddress); outs() << format("%8" PRIx64 ":\t", SectAddress + Index); DumpBytes(StringRef(Bytes.data() + Index, Size)); IP->printInst(&Inst, outs(), ""); // Print debug info. if (diContext) { DILineInfo dli = diContext->getLineInfoForAddress(SectAddress + Index); // Print valid line info if it changed. if (dli != lastLine && dli.getLine() != 0) outs() << "\t## " << dli.getFileName() << ':' << dli.getLine() << ':' << dli.getColumn(); lastLine = dli; } outs() << "\n"; } else { errs() << "llvm-objdump: warning: invalid instruction encoding\n"; if (Size == 0) Size = 1; // skip illegible bytes } } } else { // Create CFG and use it for disassembly. StringRef SymName; Symbols[SymIdx].getName(SymName); createMCFunctionAndSaveCalls( SymName, DisAsm.get(), memoryObject, Start, End, InstrAnalysis.get(), Start, DebugOut, FunctionMap, Functions); } } if (!CFG && !symbolTableWorked) { // Reading the symbol table didn't work, disassemble the whole section. uint64_t SectAddress; Sections[SectIdx].getAddress(SectAddress); uint64_t SectSize; Sections[SectIdx].getSize(SectSize); uint64_t InstSize; for (uint64_t Index = 0; Index < SectSize; Index += InstSize) { MCInst Inst; if (DisAsm->getInstruction(Inst, InstSize, memoryObject, Index, DebugOut, nulls())) { outs() << format("%8" PRIx64 ":\t", SectAddress + Index); DumpBytes(StringRef(Bytes.data() + Index, InstSize)); IP->printInst(&Inst, outs(), ""); outs() << "\n"; } else { errs() << "llvm-objdump: warning: invalid instruction encoding\n"; if (InstSize == 0) InstSize = 1; // skip illegible bytes } } } if (CFG) { if (!symbolTableWorked) { // Reading the symbol table didn't work, create a big __TEXT symbol. uint64_t SectSize = 0, SectAddress = 0; Sections[SectIdx].getSize(SectSize); Sections[SectIdx].getAddress(SectAddress); createMCFunctionAndSaveCalls("__TEXT", DisAsm.get(), memoryObject, 0, SectSize, InstrAnalysis.get(), SectAddress, DebugOut, FunctionMap, Functions); } for (std::map<uint64_t, MCFunction*>::iterator mi = FunctionMap.begin(), me = FunctionMap.end(); mi != me; ++mi) if (mi->second == 0) { // Create functions for the remaining callees we have gathered, // but we didn't find a name for them. uint64_t SectSize = 0; Sections[SectIdx].getSize(SectSize); SmallVector<uint64_t, 16> Calls; MCFunction f = MCFunction::createFunctionFromMC("unknown", DisAsm.get(), memoryObject, mi->first, SectSize, InstrAnalysis.get(), DebugOut, Calls); Functions.push_back(f); mi->second = &Functions.back(); for (unsigned i = 0, e = Calls.size(); i != e; ++i) { std::pair<uint64_t, MCFunction*> p(Calls[i], (MCFunction*)0); if (FunctionMap.insert(p).second) mi = FunctionMap.begin(); } } DenseSet<uint64_t> PrintedBlocks; for (unsigned ffi = 0, ffe = Functions.size(); ffi != ffe; ++ffi) { MCFunction &f = Functions[ffi]; for (MCFunction::iterator fi = f.begin(), fe = f.end(); fi != fe; ++fi){ if (!PrintedBlocks.insert(fi->first).second) continue; // We already printed this block. // We assume a block has predecessors when it's the first block after // a symbol. bool hasPreds = FunctionMap.find(fi->first) != FunctionMap.end(); // See if this block has predecessors. // FIXME: Slow. for (MCFunction::iterator pi = f.begin(), pe = f.end(); pi != pe; ++pi) if (pi->second.contains(fi->first)) { hasPreds = true; break; } uint64_t SectSize = 0, SectAddress; Sections[SectIdx].getSize(SectSize); Sections[SectIdx].getAddress(SectAddress); // No predecessors, this is a data block. Print as .byte directives. if (!hasPreds) { uint64_t End = llvm::next(fi) == fe ? SectSize : llvm::next(fi)->first; outs() << "# " << End-fi->first << " bytes of data:\n"; for (unsigned pos = fi->first; pos != End; ++pos) { outs() << format("%8x:\t", SectAddress + pos); DumpBytes(StringRef(Bytes.data() + pos, 1)); outs() << format("\t.byte 0x%02x\n", (uint8_t)Bytes[pos]); } continue; } if (fi->second.contains(fi->first)) // Print a header for simple loops outs() << "# Loop begin:\n"; DILineInfo lastLine; // Walk over the instructions and print them. for (unsigned ii = 0, ie = fi->second.getInsts().size(); ii != ie; ++ii) { const MCDecodedInst &Inst = fi->second.getInsts()[ii]; // If there's a symbol at this address, print its name. if (FunctionMap.find(SectAddress + Inst.Address) != FunctionMap.end()) outs() << FunctionMap[SectAddress + Inst.Address]-> getName() << ":\n"; outs() << format("%8" PRIx64 ":\t", SectAddress + Inst.Address); DumpBytes(StringRef(Bytes.data() + Inst.Address, Inst.Size)); if (fi->second.contains(fi->first)) // Indent simple loops. outs() << '\t'; IP->printInst(&Inst.Inst, outs(), ""); // Look for relocations inside this instructions, if there is one // print its target and additional information if available. for (unsigned j = 0; j != Relocs.size(); ++j) if (Relocs[j].first >= SectAddress + Inst.Address && Relocs[j].first < SectAddress + Inst.Address + Inst.Size) { StringRef SymName; uint64_t Addr; Relocs[j].second.getAddress(Addr); Relocs[j].second.getName(SymName); outs() << "\t# " << SymName << ' '; DumpAddress(Addr, Sections, MachOObj, outs()); } // If this instructions contains an address, see if we can evaluate // it and print additional information. uint64_t targ = InstrAnalysis->evaluateBranch(Inst.Inst, Inst.Address, Inst.Size); if (targ != -1ULL) DumpAddress(targ, Sections, MachOObj, outs()); // Print debug info. if (diContext) { DILineInfo dli = diContext->getLineInfoForAddress(SectAddress + Inst.Address); // Print valid line info if it changed. if (dli != lastLine && dli.getLine() != 0) outs() << "\t## " << dli.getFileName() << ':' << dli.getLine() << ':' << dli.getColumn(); lastLine = dli; } outs() << '\n'; } } emitDOTFile((f.getName().str() + ".dot").c_str(), f, IP.get()); } } } }
static void DisassembleInputMachO2(StringRef Filename, MachOObjectFile *MachOOF) { const Target *TheTarget = GetTarget(MachOOF); if (!TheTarget) { // GetTarget prints out stuff. return; } OwningPtr<const MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo()); OwningPtr<MCInstrAnalysis> InstrAnalysis(TheTarget->createMCInstrAnalysis(InstrInfo.get())); // Set up disassembler. OwningPtr<const MCRegisterInfo> MRI(TheTarget->createMCRegInfo(TripleName)); OwningPtr<const MCAsmInfo> AsmInfo( TheTarget->createMCAsmInfo(*MRI, TripleName)); OwningPtr<const MCSubtargetInfo> STI(TheTarget->createMCSubtargetInfo(TripleName, "", "")); OwningPtr<const MCDisassembler> DisAsm(TheTarget->createMCDisassembler(*STI)); int AsmPrinterVariant = AsmInfo->getAssemblerDialect(); OwningPtr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI, *STI)); if (!InstrAnalysis || !AsmInfo || !STI || !DisAsm || !IP) { errs() << "error: couldn't initialize disassembler for target " << TripleName << '\n'; return; } outs() << '\n' << Filename << ":\n\n"; macho::Header Header = MachOOF->getHeader(); // FIXME: FoundFns isn't used anymore. Using symbols/LC_FUNCTION_STARTS to // determine function locations will eventually go in MCObjectDisassembler. // FIXME: Using the -cfg command line option, this code used to be able to // annotate relocations with the referenced symbol's name, and if this was // inside a __[cf]string section, the data it points to. This is now replaced // by the upcoming MCSymbolizer, which needs the appropriate setup done above. std::vector<SectionRef> Sections; std::vector<SymbolRef> Symbols; SmallVector<uint64_t, 8> FoundFns; getSectionsAndSymbols(Header, MachOOF, Sections, Symbols, FoundFns); // Make a copy of the unsorted symbol list. FIXME: duplication std::vector<SymbolRef> UnsortedSymbols(Symbols); // Sort the symbols by address, just in case they didn't come in that way. std::sort(Symbols.begin(), Symbols.end(), SymbolSorter()); #ifndef NDEBUG raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls(); #else raw_ostream &DebugOut = nulls(); #endif OwningPtr<DIContext> diContext; ObjectFile *DbgObj = MachOOF; // Try to find debug info and set up the DIContext for it. if (UseDbg) { // A separate DSym file path was specified, parse it as a macho file, // get the sections and supply it to the section name parsing machinery. if (!DSYMFile.empty()) { OwningPtr<MemoryBuffer> Buf; if (error_code ec = MemoryBuffer::getFileOrSTDIN(DSYMFile.c_str(), Buf)) { errs() << "llvm-objdump: " << Filename << ": " << ec.message() << '\n'; return; } DbgObj = ObjectFile::createMachOObjectFile(Buf.take()); } // Setup the DIContext diContext.reset(DIContext::getDWARFContext(DbgObj)); } for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) { bool SectIsText = false; Sections[SectIdx].isText(SectIsText); if (SectIsText == false) continue; StringRef SectName; if (Sections[SectIdx].getName(SectName) || SectName != "__text") continue; // Skip non-text sections DataRefImpl DR = Sections[SectIdx].getRawDataRefImpl(); StringRef SegmentName = MachOOF->getSectionFinalSegmentName(DR); if (SegmentName != "__TEXT") continue; StringRef Bytes; Sections[SectIdx].getContents(Bytes); StringRefMemoryObject memoryObject(Bytes); bool symbolTableWorked = false; // Parse relocations. std::vector<std::pair<uint64_t, SymbolRef> > Relocs; error_code ec; for (relocation_iterator RI = Sections[SectIdx].begin_relocations(), RE = Sections[SectIdx].end_relocations(); RI != RE; RI.increment(ec)) { uint64_t RelocOffset, SectionAddress; RI->getOffset(RelocOffset); Sections[SectIdx].getAddress(SectionAddress); RelocOffset -= SectionAddress; SymbolRef RelocSym; RI->getSymbol(RelocSym); Relocs.push_back(std::make_pair(RelocOffset, RelocSym)); } array_pod_sort(Relocs.begin(), Relocs.end()); // Disassemble symbol by symbol. for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) { StringRef SymName; Symbols[SymIdx].getName(SymName); SymbolRef::Type ST; Symbols[SymIdx].getType(ST); if (ST != SymbolRef::ST_Function) continue; // Make sure the symbol is defined in this section. bool containsSym = false; Sections[SectIdx].containsSymbol(Symbols[SymIdx], containsSym); if (!containsSym) continue; // Start at the address of the symbol relative to the section's address. uint64_t SectionAddress = 0; uint64_t Start = 0; Sections[SectIdx].getAddress(SectionAddress); Symbols[SymIdx].getAddress(Start); Start -= SectionAddress; // Stop disassembling either at the beginning of the next symbol or at // the end of the section. bool containsNextSym = false; uint64_t NextSym = 0; uint64_t NextSymIdx = SymIdx+1; while (Symbols.size() > NextSymIdx) { SymbolRef::Type NextSymType; Symbols[NextSymIdx].getType(NextSymType); if (NextSymType == SymbolRef::ST_Function) { Sections[SectIdx].containsSymbol(Symbols[NextSymIdx], containsNextSym); Symbols[NextSymIdx].getAddress(NextSym); NextSym -= SectionAddress; break; } ++NextSymIdx; } uint64_t SectSize; Sections[SectIdx].getSize(SectSize); uint64_t End = containsNextSym ? NextSym : SectSize; uint64_t Size; symbolTableWorked = true; outs() << SymName << ":\n"; DILineInfo lastLine; for (uint64_t Index = Start; Index < End; Index += Size) { MCInst Inst; if (DisAsm->getInstruction(Inst, Size, memoryObject, Index, DebugOut, nulls())) { uint64_t SectAddress = 0; Sections[SectIdx].getAddress(SectAddress); outs() << format("%8" PRIx64 ":\t", SectAddress + Index); DumpBytes(StringRef(Bytes.data() + Index, Size)); IP->printInst(&Inst, outs(), ""); // Print debug info. if (diContext) { DILineInfo dli = diContext->getLineInfoForAddress(SectAddress + Index); // Print valid line info if it changed. if (dli != lastLine && dli.getLine() != 0) outs() << "\t## " << dli.getFileName() << ':' << dli.getLine() << ':' << dli.getColumn(); lastLine = dli; } outs() << "\n"; } else { errs() << "llvm-objdump: warning: invalid instruction encoding\n"; if (Size == 0) Size = 1; // skip illegible bytes } } } if (!symbolTableWorked) { // Reading the symbol table didn't work, disassemble the whole section. uint64_t SectAddress; Sections[SectIdx].getAddress(SectAddress); uint64_t SectSize; Sections[SectIdx].getSize(SectSize); uint64_t InstSize; for (uint64_t Index = 0; Index < SectSize; Index += InstSize) { MCInst Inst; if (DisAsm->getInstruction(Inst, InstSize, memoryObject, Index, DebugOut, nulls())) { outs() << format("%8" PRIx64 ":\t", SectAddress + Index); DumpBytes(StringRef(Bytes.data() + Index, InstSize)); IP->printInst(&Inst, outs(), ""); outs() << "\n"; } else { errs() << "llvm-objdump: warning: invalid instruction encoding\n"; if (InstSize == 0) InstSize = 1; // skip illegible bytes } } } } }