diff --git a/llvm/docs/CommandGuide/llvm-objdump.rst b/llvm/docs/CommandGuide/llvm-objdump.rst --- a/llvm/docs/CommandGuide/llvm-objdump.rst +++ b/llvm/docs/CommandGuide/llvm-objdump.rst @@ -332,6 +332,10 @@ Add symbol description to disassembly output. +.. option:: --traceback-table + + Decode traceback table for disassembly output. + BUGS ---- diff --git a/llvm/include/llvm/BinaryFormat/XCOFF.h b/llvm/include/llvm/BinaryFormat/XCOFF.h --- a/llvm/include/llvm/BinaryFormat/XCOFF.h +++ b/llvm/include/llvm/BinaryFormat/XCOFF.h @@ -284,6 +284,81 @@ StringRef getMappingClassString(XCOFF::StorageMappingClass SMC); StringRef getRelocationTypeString(XCOFF::RelocationType Type); +struct Traceback_Table { + // Byte 1 + uint8_t Version; ///< Traceback format version + + // Byte 2 + uint8_t LanguageId; ///< source language Identifier + + // Byte 3 + unsigned GlobaLinkage : 1; ///< Set if this routine is GLobal Linkage. + ///< specified, and the FP_PRESET bit is on. + unsigned Is_Eprol : 1; ///< Set if this is an out of line Prol/Epil. + unsigned Has_CodeLen : 1; ///< Set if CODELEN is present below. + unsigned Int_Proc : 1; ///< Set for internal procedures. + unsigned Has_Ctl : 1; ///< Set if rtn has controlled Automatic Strogare. + unsigned TOCLess : 1; ///< Set if this routine is TOC-less. + unsigned FP_Present : 1; ///< Set to 1 if the function uses floating-point + ///< processor instructions + unsigned Log_Abort : 1; ///< Set if the log/abort compiler option was + + static constexpr uint8_t GlobaLinkage_Mask = 0x80; + static constexpr uint8_t Is_Eprol_Mask = 0x40; + static constexpr uint8_t Has_CodeLen_Mask = 0x20; + static constexpr uint8_t Int_Proc_Mask = 0x10; + static constexpr uint8_t Has_Ctl_Mask = 0x08; + static constexpr uint8_t TOCLess_Mask = 0x04; + static constexpr uint8_t FP_Present_Mask = 0x02; + static constexpr uint8_t Log_Abort_Mask = 0x01; + + // Byte 4 + unsigned Int_Handler : 1; ///< Set if routine is interrupt handler + unsigned Name_Present : 1; ///< Set if name is present in proc table. + unsigned Used_Alloca : 1; ///< Set if alloca used to allocate storage. + unsigned Cl_Dis_Inv : 3; ///< Only 000 seem to be used at this time. + unsigned Saves_CR : 1; ///< Set if procedure saves the condition reg. + unsigned Saves_LR : 1; ///< Set if procedure saves the link reg. + + static constexpr uint8_t Int_Handler_Mask = 0x80; + static constexpr uint8_t Name_Present_Mask = 0x40; + static constexpr uint8_t Used_Alloca_Mask = 0x20; + static constexpr uint8_t Cl_Dis_Inv_Mask = 0x1C; + static constexpr uint8_t Saves_CR_Mask = 0x02; + static constexpr uint8_t Saves_LR_Mask = 0x01; + + static constexpr uint8_t Cl_Dis_Inv_Shift = 0x02; + + // Byte 5 + unsigned Stores_BC : 1; ///< Set if procedure stores the backchain. + unsigned Fixup : 1; ///< Set if code is generated fixup code. + unsigned FP_Saved : 6; ///< umber of FPRs saved, max of 32. + static constexpr uint8_t Stores_BC_Mask = 0x80; + static constexpr uint8_t Fixup_Mask = 0x40; + static constexpr uint8_t FP_Saved_Mask = 0x3F; + + // Byte 6 + unsigned Has_Vec_Info : 1; ///< This field is set to 1 if the procedure saves + ///< nonvolatile vector registers in the Vector + ///< Register Save Area, specifies the number of + ///< vector parameters, or uses VMX instructions. + unsigned Spare4 : 1; + unsigned GP_SAVED : 6; ///< Number of GPRs saved, max of 32 + static constexpr uint8_t Has_Vec_Info_Mask = 0x80; + static constexpr uint8_t Spare4_Mask = 0x40; + static constexpr uint8_t GP_SAVED_Mask = 0x3F; + + // Byte 7 + uint8_t NumberOfFixedPara; + + // Byte 8 + unsigned NumberOfFPPara : 7; ///< NUmber of float point parameter. + unsigned ParmsOnStack : 1; ///< Set if all parameters placed on stack. + static constexpr uint8_t NumberOfFPPara_Mask = 0xFE; + static constexpr uint8_t ParmsOnStack_Mask = 0x01; + static constexpr uint8_t NumberOfFPPara_Shift = 0x01; +}; + } // end namespace XCOFF } // end namespace llvm diff --git a/llvm/test/tools/llvm-objdump/XCOFF/Inputs/xcoff-func-tracebacktable.o b/llvm/test/tools/llvm-objdump/XCOFF/Inputs/xcoff-func-tracebacktable.o new file mode 100755 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 GIT binary patch literal 0 Hc$@ cat test.c +## double add_all(int value,float fvalue, double dvalue) { +## return dvalue+fvalue+value; +## } +## +## int main() { +## return add_all(1,2.0,3.0)+1.0; +## } + +CHECK: 00000000 (idx: 12) .add_all: +CHECK-NEXT: 0: 94 21 ff b0 stwu 1, -80(1) +CHECK-NEXT: 4: 90 61 00 68 stw 3, 104(1) +CHECK-NEXT: 8: d0 21 00 6c stfs 1, 108(1) +CHECK-NEXT: c: d8 41 00 70 stfd 2, 112(1) +CHECK-NEXT: 10: c8 21 00 70 lfd 1, 112(1) +CHECK-NEXT: 14: c0 41 00 6c lfs 2, 108(1) +CHECK-NEXT: 18: fc 21 10 2a fadd 1, 1, 2 +CHECK-NEXT: 1c: 80 61 00 68 lwz 3, 104(1) +CHECK-NEXT: 20: 7c 64 fe 70 srawi 4, 3, 31 +CHECK-NEXT: 24: 90 81 00 40 stw 4, 64(1) +CHECK-NEXT: 28: 90 61 00 44 stw 3, 68(1) +CHECK-NEXT: 2c: c8 41 00 40 lfd 2, 64(1) +CHECK-NEXT: 30: fc 40 16 9c fcfid 2, 2 +CHECK-NEXT: 34: fc 21 10 2a fadd 1, 1, 2 +CHECK-NEXT: 38: 38 21 00 50 addi 1, 1, 80 +CHECK-NEXT: 3c: 4e 80 00 20 blr +CHECK-NEXT: 40: 00 00 00 00 # Traceback table begin +CHECK-NEXT: 44: 00 # Version = 0 +CHECK-NEXT: 45: 00 # Language = C +CHECK-NEXT: 46: 22 # GlobaLinkage=0, Is_Eprol=0, Has_CodeLen=1 +CHECK-NEXT: , Int_Proc=0, Has_Ctl=0, TOCLess=0 +CHECK-NEXT: , FP_Present=1, Log_Abort=0 +CHECK-NEXT: 47: 40 # Int_Handler=0, Name_Present=1, Used_Alloca=0 +CHECK-NEXT: , Cl_Dis_Inv=0, Saves_CR=0, Saves_LR=0 +CHECK-NEXT: 48: 80 # Stores_BC=1, Fixup=0, FP_Saved=0 +CHECK-NEXT: 49: 00 # Has_Vec_Info=0, GP_SAVED=0 +CHECK-NEXT: 4a: 01 # FixedParms = 1 +CHECK-NEXT: 4b: 05 # NumberOfFPPara=2, ParmsOnStack=1 +CHECK-NEXT: 4c: 58 00 00 00 # Parameter Type +CHECK-NEXT: 50: 00 00 00 40 # Code Len = 64 +CHECK-NEXT: 54: 00 07 # Length of function name = 7 +CHECK-NEXT: 56: 61 64 64 5f # Function Name: add_ +CHECK-NEXT: 5a: 61 6c 6c all +CHECK-NEXT: 5d: 00 00 00 # Padding + +CHECK: 00000060 (idx: 14) .main: +CHECK-NEXT: 60: 7c 08 02 a6 mflr 0 +CHECK-NEXT: 64: 93 e1 ff fc stw 31, -4(1) +CHECK-NEXT: 68: 90 01 00 08 stw 0, 8(1) +CHECK-NEXT: 6c: 94 21 ff a0 stwu 1, -96(1) +CHECK-NEXT: 70: 83 e2 00 08 lwz 31, 8(2) +CHECK-NEXT: 74: c0 3f 00 00 lfs 1, 0(31) +CHECK-NEXT: 78: c0 5f 00 04 lfs 2, 4(31) +CHECK-NEXT: 7c: 38 60 00 01 li 3, 1 +CHECK-NEXT: 80: 4b ff ff 81 bl 0x0 +CHECK-NEXT: 84: c0 5f 00 08 lfs 2, 8(31) +CHECK-NEXT: 88: fc 21 10 2a fadd 1, 1, 2 +CHECK-NEXT: 8c: fc 20 08 1e fctiwz 1, 1 +CHECK-NEXT: 90: d8 21 00 40 stfd 1, 64(1) +CHECK-NEXT: 94: 80 61 00 44 lwz 3, 68(1) +CHECK-NEXT: 98: 80 01 00 68 lwz 0, 104(1) +CHECK-NEXT: 9c: 7c 08 03 a6 mtlr 0 +CHECK-NEXT: a0: 38 21 00 60 addi 1, 1, 96 +CHECK-NEXT: a4: 83 e1 ff fc lwz 31, -4(1) +CHECK-NEXT: a8: 4e 80 00 20 blr +CHECK-NEXT: ac: 00 00 00 00 # Traceback table begin +CHECK-NEXT: b0: 00 # Version = 0 +CHECK-NEXT: b1: 00 # Language = C +CHECK-NEXT: b2: 22 # GlobaLinkage=0, Is_Eprol=0, Has_CodeLen=1 +CHECK-NEXT: , Int_Proc=0, Has_Ctl=0, TOCLess=0 +CHECK-NEXT: , FP_Present=1, Log_Abort=0 +CHECK-NEXT: b3: 41 # Int_Handler=0, Name_Present=1, Used_Alloca=0 +CHECK-NEXT: , Cl_Dis_Inv=0, Saves_CR=0, Saves_LR=1 +CHECK-NEXT: b4: 80 # Stores_BC=1, Fixup=0, FP_Saved=0 +CHECK-NEXT: b5: 01 # Has_Vec_Info=0, GP_SAVED=1 +CHECK-NEXT: b6: 00 # FixedParms = 0 +CHECK-NEXT: b7: 01 # NumberOfFPPara=0, ParmsOnStack=1 +CHECK-NEXT: b8: 00 00 00 4c # Code Len = 76 +CHECK-NEXT: bc: 00 04 # Length of function name = 4 +CHECK-NEXT: be: 6d 61 69 6e # Function Name: main +CHECK-NEXT: c2: 00 00 # Padding +CHECK-NEXT: ... + diff --git a/llvm/tools/llvm-objdump/XCOFFDump.h b/llvm/tools/llvm-objdump/XCOFFDump.h --- a/llvm/tools/llvm-objdump/XCOFFDump.h +++ b/llvm/tools/llvm-objdump/XCOFFDump.h @@ -10,6 +10,7 @@ #define LLVM_TOOLS_LLVM_OBJDUMP_XCOFFDUMP_H #include "llvm/Object/XCOFFObjectFile.h" +#include "llvm/Support/raw_ostream.h" namespace llvm { @@ -28,6 +29,13 @@ Error getXCOFFRelocationValueString(const object::XCOFFObjectFile *Obj, const object::RelocationRef &RelRef, llvm::SmallVectorImpl &Result); +void formatTracebackTableOutput(ArrayRef Bytes, uint64_t Address, + raw_ostream &OS, bool OnlyComment = false); + +void dumpTracebackTable(ArrayRef Bytes, uint64_t Address, + raw_ostream &OS, uint64_t End); + +bool isXCOFFTracebackTableBegin(ArrayRef Bytes); } // namespace objdump } // namespace llvm #endif diff --git a/llvm/tools/llvm-objdump/XCOFFDump.cpp b/llvm/tools/llvm-objdump/XCOFFDump.cpp --- a/llvm/tools/llvm-objdump/XCOFFDump.cpp +++ b/llvm/tools/llvm-objdump/XCOFFDump.cpp @@ -15,9 +15,13 @@ #include "llvm-objdump.h" #include "llvm/Demangle/Demangle.h" +#include "llvm/MC/MCInstPrinter.h" +#include "llvm/Support/Endian.h" using namespace llvm; using namespace llvm::object; +using namespace llvm::XCOFF; +using namespace llvm::support; Error objdump::getXCOFFRelocationValueString(const XCOFFObjectFile *Obj, const RelocationRef &Rel, @@ -86,3 +90,226 @@ return Result; } + +bool objdump::isXCOFFTracebackTableBegin(ArrayRef Bytes) { + // Tableback table begin with sizeof(long) bytes zero. + if (Bytes.size() == 4) + return (*reinterpret_cast(Bytes.data()) == 0); + + return (*reinterpret_cast(Bytes.data()) == 0); +} + +void objdump::formatTracebackTableOutput(ArrayRef Bytes, + uint64_t Address, raw_ostream &OS, + bool OnlyComment) { + + size_t Start = OS.tell(); + if (!OnlyComment) { + if (!NoLeadingAddr) + OS << format("%8" PRIx64 ":", Address); + if (!NoShowRawInsn) { + OS << ' '; + dumpBytes(Bytes, OS); + } + } + + // The output of printInst starts with a tab. Print some spaces so that + // the tab has 1 column and advances to the target tab stop. + unsigned TabStop = NoShowRawInsn ? 16 : 40; + unsigned Column = OS.tell() - Start; + OS.indent(Column < TabStop - 1 ? TabStop - 1 - Column : 7 - Column % 8); +} + +std::string SourceLanguageIdentifier[] = { + "C", "FORTRAN", "Pascal", "ADA", "PL/I", + "BASIC", "LISP", "COBOL", "Modulas2", "C++", + "RPG", "PL8", "Assembler", "Java", "Objective C"}; + +#define BITCONTENT_ONEBIT(Prefix, field) \ + Tb.field = Value & Traceback_Table::field##_Mask ? 1 : 0, \ + OS << Prefix << " " << #field << "=" << Tb.field + +#define BITCONTENT_SHIFT(Prefix, field) \ + Tb.field = (Value & Traceback_Table::field##_Mask) >> \ + Traceback_Table::field##_Shift, \ + OS << Prefix << " " << #field << "=" << Tb.field + +#define BITCONTENT_END(Prefix, field) \ + Tb.field = Value & Traceback_Table::field##_Mask, \ + OS << Prefix << " " << #field << "=" << Tb.field + +void objdump::dumpTracebackTable(ArrayRef Bytes, uint64_t Address, + raw_ostream &OS, uint64_t End) { + unsigned int Index = 0; + uint8_t Value; + Traceback_Table Tb; + + // Backtrace table boundary. + formatTracebackTableOutput(Bytes.slice(Index, 4), Address, OS); + OS << "# Traceback table begin\n"; + Index += 4; + + // Backtrace table version. + auto CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + OS << "# Version = " << (int)CurBytes.front() << "\n"; + Index++; + + // Source language identifier. + CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + Value = CurBytes.front(); + OS << "# Language = " + << (Value < sizeof(SourceLanguageIdentifier) / sizeof(char *) + ? SourceLanguageIdentifier[Value] + : "Unknown") + << "\n"; + Index++; + + // Decode the 3th byte of the backtrace table. + CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + Value = CurBytes.front(); + BITCONTENT_ONEBIT("#", GlobaLinkage); + BITCONTENT_ONEBIT(",", Is_Eprol); + BITCONTENT_ONEBIT(",", Has_CodeLen); + OS << "\n"; + formatTracebackTableOutput(CurBytes, Address + Index, OS, true); + BITCONTENT_ONEBIT(",", Int_Proc); + BITCONTENT_ONEBIT(",", Has_Ctl); + BITCONTENT_ONEBIT(",", TOCLess); + OS << "\n"; + formatTracebackTableOutput(CurBytes, Address + Index, OS, true); + BITCONTENT_ONEBIT(",", FP_Present); + BITCONTENT_ONEBIT(",", Log_Abort); + OS << "\n"; + Index++; + + // Decode the 4th byte of backtrace table. + CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + Value = CurBytes.front(); + BITCONTENT_ONEBIT("#", Int_Handler); + BITCONTENT_ONEBIT(",", Name_Present); + BITCONTENT_ONEBIT(",", Used_Alloca); + OS << "\n"; + formatTracebackTableOutput(CurBytes, Address + Index, OS, true); + BITCONTENT_SHIFT(",", Cl_Dis_Inv); + BITCONTENT_ONEBIT(",", Saves_CR); + BITCONTENT_ONEBIT(",", Saves_LR); + OS << "\n"; + Index++; + + // Decode the 5th byte of backtrace table. + CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + Value = CurBytes.front(); + BITCONTENT_ONEBIT("#", Stores_BC); + BITCONTENT_ONEBIT(",", Fixup); + BITCONTENT_END(",", FP_Saved); + OS << "\n"; + Index++; + + // Decode the 6th byte of backtrace table. + CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + Value = CurBytes.front(); + BITCONTENT_END("#", Has_Vec_Info); + BITCONTENT_END(",", GP_SAVED); + OS << "\n"; + Index++; + + // Decode 7th byte of backtrace table. + CurBytes = Bytes.slice(Index, 1); + Tb.NumberOfFixedPara = CurBytes.front(); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + OS << "# FixedParms = " << (unsigned)Tb.NumberOfFixedPara << "\n"; + Index++; + + // Decode the 8th byte of backtrace table. + CurBytes = Bytes.slice(Index, 1); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + Value = CurBytes.front(); + BITCONTENT_SHIFT("#", NumberOfFPPara); + BITCONTENT_ONEBIT(",", ParmsOnStack); + OS << "\n"; + Index++; + + // Decode option bytes. + + // Decode parameter type if there is. + if (Tb.NumberOfFixedPara || Tb.NumberOfFPPara) { + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, OS); + OS << "# Parameter Type\n"; + Index += 4; + } + + // Decode function code len if there present. + if (Tb.Has_CodeLen) { + CurBytes = Bytes.slice(Index, 4); + uint32_t CodeLen = endian::read32(CurBytes.data(), big); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + OS << "# Code Len = " << CodeLen << "\n"; + Index += 4; + } + + + if (Tb.Int_Handler) { + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, OS); + OS << "# HAND_MASK\n"; + Index += 4; + } + + if (Tb.Has_Ctl) { + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, OS); + OS << "# Number of CTL anchors\n"; + Index += 4; + } + + // Decode length of function name and the name of function if Name_Present is 1. + if (Tb.Name_Present) { + CurBytes = Bytes.slice(Index, 2); + uint16_t NameLen = endian::read16(CurBytes.data(), big); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + OS << "# Length of function name = " << NameLen << "\n"; + Index += 2; + CurBytes = Bytes.slice(Index, 4); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + OS << "# Function Name: "; + OS << StringRef((const char *)CurBytes.data(), 4) << "\n"; + NameLen -= 4; + Index += 4; + while (NameLen > 0) { + int Len = NameLen >= 4 ? 4 : NameLen; + CurBytes = Bytes.slice(Index, Len); + formatTracebackTableOutput(CurBytes, Address + Index, OS); + OS << StringRef((const char *)CurBytes.data(), Len) << "\n"; + NameLen -= Len; + Index += Len; + } + } + + if (Tb.Used_Alloca) { + formatTracebackTableOutput(Bytes.slice(Index, 1), Address + Index, OS); + OS << "# Alloca_Reg\n"; + Index++; + } + + if (Index % 4 != 0) { + formatTracebackTableOutput(Bytes.slice(Index, 4 - (Index % 4)), + Address + Index, OS); + OS << "# Padding\n"; + Index += 4 - (Index % 4); + } + + // Print out all padding. + if (End - Address + Index >= 8) + OS << "\t\t...\n"; + else { + formatTracebackTableOutput(Bytes.slice(Index, 4), Address + Index, OS); + OS << "# Padding\n"; + } +} +#undef BITCONTENT_ONEBIT +#undef BITCONTENT_SHIFT +#undef BITCONTENT_END diff --git a/llvm/tools/llvm-objdump/llvm-objdump.h b/llvm/tools/llvm-objdump/llvm-objdump.h --- a/llvm/tools/llvm-objdump/llvm-objdump.h +++ b/llvm/tools/llvm-objdump/llvm-objdump.h @@ -45,6 +45,7 @@ extern cl::opt SectionHeaders; extern cl::opt SectionContents; extern cl::opt SymbolDescription; +extern cl::opt TracebackTable; extern cl::opt SymbolTable; extern cl::opt TripleName; extern cl::opt UnwindInfo; diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp b/llvm/tools/llvm-objdump/llvm-objdump.cpp --- a/llvm/tools/llvm-objdump/llvm-objdump.cpp +++ b/llvm/tools/llvm-objdump/llvm-objdump.cpp @@ -138,6 +138,12 @@ "option is for XCOFF files only"), cl::init(false), cl::cat(ObjdumpCat)); +cl::opt objdump::TracebackTable( + "traceback-table", + cl::desc("Decode traceback table for disassembly. This " + "option is for XCOFF files only"), + cl::init(false), cl::cat(ObjdumpCat)); + static cl::list DisassembleSymbols("disassemble-symbols", cl::CommaSeparated, cl::desc("List of symbols to disassemble. " @@ -1155,7 +1161,7 @@ const uint64_t Addr = unwrapOrError(Symbol.getAddress(), FileName); const StringRef Name = unwrapOrError(Symbol.getName(), FileName); - if (Obj->isXCOFF() && SymbolDescription) { + if (Obj->isXCOFF() && (SymbolDescription || TracebackTable)) { const auto *XCOFFObj = cast(Obj); DataRefImpl SymbolDRI = Symbol.getRawDataRefImpl(); @@ -1173,7 +1179,7 @@ static SymbolInfoTy createDummySymbolInfo(const ObjectFile *Obj, const uint64_t Addr, StringRef &Name, uint8_t Type) { - if (Obj->isXCOFF() && SymbolDescription) + if (Obj->isXCOFF() && (SymbolDescription || TracebackTable)) return SymbolInfoTy(Addr, Name, None, None, false); else return SymbolInfoTy(Addr, Name, Type); @@ -1452,6 +1458,12 @@ Symbols[SI].Type != ELF::STT_OBJECT && !DisassembleAll; bool DumpARMELFData = false; + bool IsXCOFFFunctionEntryPointSymbol = + Obj->isXCOFF() && Section.isText() && TracebackTable && + Symbols[SI].XCOFFSymInfo.StorageMappingClass && + Symbols[SI].XCOFFSymInfo.StorageMappingClass.getValue() == + XCOFF::XMC_PR; + while (Index < End) { // ARM and AArch64 ELF binaries can interleave data and text in the // same section. We rely on the markers introduced to understand what @@ -1492,6 +1504,16 @@ } } + if (IsXCOFFFunctionEntryPointSymbol && + isXCOFFTracebackTableBegin(Bytes.slice( + Index, cast(Obj)->is64Bit() ? 8 : 4))) { + dumpTracebackTable(Bytes.slice(Index), + SectionAddr + Index + VMAAdjustment, outs(), + End); + Index = End; + continue; + } + // Disassemble a real instruction or a data when disassemble all is // provided MCInst Inst;