Index: lldb/include/lldb/Core/Disassembler.h =================================================================== --- lldb/include/lldb/Core/Disassembler.h +++ lldb/include/lldb/Core/Disassembler.h @@ -79,6 +79,9 @@ return m_comment.c_str(); } + lldb::InstructionControlFlowType + GetControlFlowInstructionKind(const ExecutionContext *exe_ctx); + virtual void CalculateMnemonicOperandsAndComment(const ExecutionContext *exe_ctx) = 0; @@ -105,6 +108,9 @@ /// \param[in] show_bytes /// Whether the bytes of the assembly instruction should be printed. /// + /// \param[in] show_control_flow_kind + /// Whether the control flow type of the instruction should be printed. + /// /// \param[in] max_opcode_byte_size /// The size (in bytes) of the largest instruction in the list that /// we are printing (for text justification/alignment purposes) @@ -140,7 +146,8 @@ /// so this method can properly align the instruction opcodes. /// May be 0 to indicate no indentation/alignment of the opcodes. virtual void Dump(Stream *s, uint32_t max_opcode_byte_size, bool show_address, - bool show_bytes, const ExecutionContext *exe_ctx, + bool show_bytes, bool show_control_flow_kind, + const ExecutionContext *exe_ctx, const SymbolContext *sym_ctx, const SymbolContext *prev_sym_ctx, const FormatEntity::Entry *disassembly_addr_format, @@ -320,7 +327,7 @@ void Append(lldb::InstructionSP &inst_sp); void Dump(Stream *s, bool show_address, bool show_bytes, - const ExecutionContext *exe_ctx); + bool show_control_flow_kind, const ExecutionContext *exe_ctx); private: typedef std::vector collection; @@ -375,7 +382,8 @@ eOptionMarkPCSourceLine = (1u << 2), // Mark the source line that contains // the current PC (mixed mode only) eOptionMarkPCAddress = - (1u << 3) // Mark the disassembly line the contains the PC + (1u << 3), // Mark the disassembly line the contains the PC + eOptionShowControlFlowKind = (1u << 4), }; enum HexImmediateStyle { Index: lldb/include/lldb/Target/TraceDumper.h =================================================================== --- lldb/include/lldb/Target/TraceDumper.h +++ lldb/include/lldb/Target/TraceDumper.h @@ -34,6 +34,8 @@ bool show_tsc = false; /// Dump the events that happened between instructions. bool show_events = false; + /// For each instruction, print the instruction type. + bool show_control_flow_kind = false; /// Optional custom id to start traversing from. llvm::Optional id = llvm::None; /// Optional number of instructions to skip from the starting position Index: lldb/include/lldb/lldb-enumerations.h =================================================================== --- lldb/include/lldb/lldb-enumerations.h +++ lldb/include/lldb/lldb-enumerations.h @@ -970,20 +970,29 @@ /// control flow of a trace. /// /// A single instruction can match one or more of these categories. -FLAGS_ENUM(TraceInstructionControlFlowType){ - /// Any instruction. - eTraceInstructionControlFlowTypeInstruction = (1u << 1), - /// A conditional or unconditional branch/jump. - eTraceInstructionControlFlowTypeBranch = (1u << 2), - /// A conditional or unconditional branch/jump that changed - /// the control flow of the program. - eTraceInstructionControlFlowTypeTakenBranch = (1u << 3), - /// A call to a function. - eTraceInstructionControlFlowTypeCall = (1u << 4), - /// A return from a function. - eTraceInstructionControlFlowTypeReturn = (1u << 5)}; - -LLDB_MARK_AS_BITMASK_ENUM(TraceInstructionControlFlowType) +enum InstructionControlFlowType { + /// The instruction could not be classified. + eInstructionControlFlowTypeUnknown = 0, + /// The instruction is something not listed below. + eInstructionControlFlowTypeOther, + /// The instruction is a near (function) call. + eInstructionControlFlowTypeCall, + /// The instruction is a near (function) return. + eInstructionControlFlowTypeReturn, + /// The instruction is a near unconditional jump. + eInstructionControlFlowTypeJump, + /// The instruction is a near conditional jump. + eInstructionControlFlowTypeCondJump, + /// The instruction is a call-like far transfer. + /// E.g. SYSCALL, SYSENTER, or FAR CALL. + eInstructionControlFlowTypeFarCall, + /// The instruction is a return-like far transfer. + /// E.g. SYSRET, SYSEXIT, IRET, or FAR RET. + eInstructionControlFlowTypeFarReturn, + /// The instruction is a jump-like far transfer. + /// E.g. FAR JMP. + eInstructionControlFlowTypeFarJump +}; /// Watchpoint Kind. /// Index: lldb/source/API/SBInstruction.cpp =================================================================== --- lldb/source/API/SBInstruction.cpp +++ lldb/source/API/SBInstruction.cpp @@ -241,7 +241,8 @@ // didn't have a stream already created, one will get created... FormatEntity::Entry format; FormatEntity::Parse("${addr}: ", format); - inst_sp->Dump(&s.ref(), 0, true, false, nullptr, &sc, nullptr, &format, 0); + inst_sp->Dump(&s.ref(), 0, true, false, /*show_control_flow_type*/ false, + nullptr, &sc, nullptr, &format, 0); return true; } return false; @@ -275,8 +276,8 @@ StreamFile out_stream(out_sp); FormatEntity::Entry format; FormatEntity::Parse("${addr}: ", format); - inst_sp->Dump(&out_stream, 0, true, false, nullptr, &sc, nullptr, &format, - 0); + inst_sp->Dump(&out_stream, 0, true, false, /*show_control_flow_type*/ false, + nullptr, &sc, nullptr, &format, 0); } } Index: lldb/source/API/SBInstructionList.cpp =================================================================== --- lldb/source/API/SBInstructionList.cpp +++ lldb/source/API/SBInstructionList.cpp @@ -165,8 +165,9 @@ addr, eSymbolContextEverything, sc); } - inst->Dump(&sref, max_opcode_byte_size, true, false, nullptr, &sc, - &prev_sc, &format, 0); + inst->Dump(&sref, max_opcode_byte_size, true, false, + /*show_control_flow_type*/ false, nullptr, &sc, &prev_sc, + &format, 0); sref.EOL(); } return true; Index: lldb/source/Commands/CommandObjectDisassemble.h =================================================================== --- lldb/source/Commands/CommandObjectDisassemble.h +++ lldb/source/Commands/CommandObjectDisassemble.h @@ -46,6 +46,7 @@ bool show_mixed; // Show mixed source/assembly bool show_bytes; + bool show_control_flow_kind; uint32_t num_lines_context = 0; uint32_t num_instructions = 0; bool raw; Index: lldb/source/Commands/CommandObjectDisassemble.cpp =================================================================== --- lldb/source/Commands/CommandObjectDisassemble.cpp +++ lldb/source/Commands/CommandObjectDisassemble.cpp @@ -65,6 +65,10 @@ show_bytes = true; break; + case 'k': + show_control_flow_kind = true; + break; + case 's': { start_addr = OptionArgParser::ToAddress(execution_context, option_arg, LLDB_INVALID_ADDRESS, &error); @@ -154,6 +158,7 @@ ExecutionContext *execution_context) { show_mixed = false; show_bytes = false; + show_control_flow_kind = false; num_lines_context = 0; num_instructions = 0; func_name.clear(); @@ -493,6 +498,9 @@ if (m_options.show_bytes) options |= Disassembler::eOptionShowBytes; + if (m_options.show_control_flow_kind) + options |= Disassembler::eOptionShowControlFlowKind; + if (m_options.raw) options |= Disassembler::eOptionRawOuput; Index: lldb/source/Commands/CommandObjectThread.cpp =================================================================== --- lldb/source/Commands/CommandObjectThread.cpp +++ lldb/source/Commands/CommandObjectThread.cpp @@ -2164,6 +2164,10 @@ m_dumper_options.forwards = true; break; } + case 'k': { + m_dumper_options.show_control_flow_kind = true; + break; + } case 't': { m_dumper_options.show_tsc = true; break; Index: lldb/source/Commands/Options.td =================================================================== --- lldb/source/Commands/Options.td +++ lldb/source/Commands/Options.td @@ -300,6 +300,10 @@ let Command = "disassemble" in { def disassemble_options_bytes : Option<"bytes", "b">, Desc<"Show opcode bytes when disassembling.">; + def disassemble_options_kind : Option<"kind", "k">, + Desc<"Show instruction control flow kind. Refer enum " + "`InstructionControlFlowType` for a list of control flow kind. " + "far jump and far return often indicate syscall and return.">; def disassemble_options_context : Option<"context", "C">, Arg<"NumLines">, Desc<"Number of context lines of source to show.">; def disassemble_options_mixed : Option<"mixed", "m">, @@ -1150,6 +1154,10 @@ def thread_trace_dump_instructions_pretty_print: Option<"pretty-json", "J">, Group<1>, Desc<"Dump in JSON format but pretty printing the output for easier readability.">; + def thread_trace_dump_instructions_show_kind : Option<"kind", "k">, Group<1>, + Desc<"For each instruction, print the instruction control flow kind. " + "`InstructionControlFlowType` enum has a list of control flow kind. " + "far jump and far return often indicate syscall and return.">; def thread_trace_dump_instructions_show_tsc : Option<"tsc", "t">, Group<1>, Desc<"For each instruction, print the corresponding timestamp counter if " "available.">; Index: lldb/source/Core/Disassembler.cpp =================================================================== --- lldb/source/Core/Disassembler.cpp +++ lldb/source/Core/Disassembler.cpp @@ -527,8 +527,11 @@ } const bool show_bytes = (options & eOptionShowBytes) != 0; - inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, &exe_ctx, &sc, - &prev_sc, nullptr, address_text_size); + const bool show_control_flow_kind = + (options & eOptionShowControlFlowKind) != 0; + inst->Dump(&strm, max_opcode_byte_size, true, show_bytes, + show_control_flow_kind, &exe_ctx, &sc, &prev_sc, nullptr, + address_text_size); strm.EOL(); } else { break; @@ -568,6 +571,283 @@ Instruction::~Instruction() = default; +namespace x86 { +enum PTI_MAP { + PTI_MAP_0, /* 1-byte opcodes. may have modrm */ + PTI_MAP_1, /* 2-byte opcodes (0x0f). may have modrm */ + PTI_MAP_2, /* 3-byte opcodes (0x0f38). has modrm */ + PTI_MAP_3, /* 3-byte opcodes (0x0f3a). has modrm */ + PTI_MAP_AMD3DNOW, /* 3d-now opcodes (0x0f0f). has modrm */ + PTI_MAP_INVALID +}; + +/// Decide InstructionControlFlowType based on bytes of instruction. +/// The insruction bytes are parsed beforehand into opcode, modrm and map byte +/// to be passed as parameters. +lldb::InstructionControlFlowType +DecodeInstructionOpcode(uint8_t opcode, uint8_t modrm, uint8_t map) { + lldb::InstructionControlFlowType itype; + if (map > PTI_MAP_1) + return lldb::eInstructionControlFlowTypeUnknown; + + if (opcode >= 0x70 && opcode <= 0x7F) { + if (map == PTI_MAP_0) + return lldb::eInstructionControlFlowTypeCondJump; + } else if (opcode >= 0x80 && opcode <= 0x8F) { + if (map == PTI_MAP_1) + return lldb::eInstructionControlFlowTypeCondJump; + } + + itype = lldb::eInstructionControlFlowTypeOther; + switch (opcode) { + case 0x9A: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeFarCall; + break; + case 0xFF: + if (map == PTI_MAP_0) { + uint8_t modrm_reg = (modrm >> 3) & 7; + if (modrm_reg == 2) + itype = lldb::eInstructionControlFlowTypeCall; + else if (modrm_reg == 3) + itype = lldb::eInstructionControlFlowTypeFarCall; + else if (modrm_reg == 4) + itype = lldb::eInstructionControlFlowTypeJump; + else if (modrm_reg == 5) + itype = lldb::eInstructionControlFlowTypeFarJump; + } + break; + case 0xE8: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeCall; + break; + case 0xCD: + case 0xCC: + case 0xCE: + case 0xF1: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeFarCall; + break; + case 0xCF: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeFarReturn; + break; + case 0xE9: + case 0xEB: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeJump; + break; + case 0xEA: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeFarJump; + break; + case 0xE3: + case 0xE0: + case 0xE1: + case 0xE2: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeCondJump; + break; + case 0xC3: + case 0xC2: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeReturn; + break; + case 0xCB: + case 0xCA: + if (map == PTI_MAP_0) + itype = lldb::eInstructionControlFlowTypeFarReturn; + break; + case 0x05: + case 0x34: + if (map == PTI_MAP_1) + itype = lldb::eInstructionControlFlowTypeFarCall; + break; + case 0x35: + case 0x07: + if (map == PTI_MAP_1) + itype = lldb::eInstructionControlFlowTypeFarReturn; + break; + case 0x01: + if (map == PTI_MAP_1) { + switch (modrm) { + case 0xc1: + itype = lldb::eInstructionControlFlowTypeFarCall; + break; + case 0xc2: + case 0xc3: + itype = lldb::eInstructionControlFlowTypeFarReturn; + break; + default: + break; + } + } + break; + default: + break; + } + return itype; +} + +lldb::InstructionControlFlowType +GetControlFlowInstructionKind(const ExecutionContext *exe_ctx, + Opcode m_opcode) { + // inst_bytes will be parsed into opcode, modrm and map bytes. + // These are the three values deciding instruction control flow type. + uint8_t inst_bytes[16]; + uint8_t opcode, modrm, map; + int op_idx = 0; + bool prefix_done = false; + + if (m_opcode.GetOpcodeBytes() == nullptr || m_opcode.GetByteSize() <= 0) { + // x86_64 and i386 are the only ones that use bytes right now + // Else, we have ARM or MIPS, not yet implemented + return lldb::eInstructionControlFlowTypeUnknown; + } + + memcpy(inst_bytes, m_opcode.GetOpcodeBytes(), m_opcode.GetByteSize()); + + // In most cases, opcode is the first byte of instruction (and modrm is the + // second byte), but some instructions has prefix to be skipped. + // The mapping is inspired from libipt's instruction decode logic + // in `src/pt_ild.c` + map = PTI_MAP_INVALID; + while (!prefix_done) { + opcode = inst_bytes[op_idx]; + switch (opcode) { + // prefix_ignore + case 0x26: + case 0x2e: + case 0x36: + case 0x3e: + case 0x64: + case 0x65: + // prefix_osz, prefix_asz + case 0x66: + case 0x67: + // prefix_lock, prefix_f2, prefix_f3 + case 0xf0: + case 0xf2: + case 0xf3: + op_idx++; + break; + + // prefix_rex + case 0x40: + case 0x41: + case 0x42: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4a: + case 0x4b: + case 0x4c: + case 0x4d: + case 0x4e: + case 0x4f: + if (exe_ctx->GetTargetRef().GetArchitecture().GetMachine() == + llvm::Triple::ArchType::x86_64) + op_idx++; + else + prefix_done = true; + break; + + // prefix_vex_c4, c5 + case 0xc5: + if (exe_ctx->GetTargetRef().GetArchitecture().GetMachine() != + llvm::Triple::ArchType::x86_64 && + (inst_bytes[op_idx + 1] & 0xc0) != 0xc0) { + prefix_done = true; + break; + } + + map = PTI_MAP_1; + opcode = inst_bytes[op_idx + 2]; + modrm = inst_bytes[op_idx + 3]; + return DecodeInstructionOpcode(opcode, modrm, map); + break; + + case 0xc4: + if (exe_ctx->GetTargetRef().GetArchitecture().GetMachine() != + llvm::Triple::ArchType::x86_64 && + (inst_bytes[op_idx + 1] & 0xc0) != 0xc0) { + prefix_done = true; + break; + } + map = inst_bytes[op_idx + 1] & 0x1f; + opcode = inst_bytes[op_idx + 3]; + modrm = inst_bytes[op_idx + 4]; + return DecodeInstructionOpcode(opcode, modrm, map); + break; + + // prefix_evex + case 0x62: + if (exe_ctx->GetTargetRef().GetArchitecture().GetMachine() != + llvm::Triple::ArchType::x86_64 && + (inst_bytes[op_idx + 1] & 0xc0) != 0xc0) { + prefix_done = true; + break; + } + map = inst_bytes[op_idx + 1] & 0x03; + opcode = inst_bytes[op_idx + 4]; + modrm = inst_bytes[op_idx + 5]; + return DecodeInstructionOpcode(opcode, modrm, map); + break; + + default: + prefix_done = true; + break; + } + } // prefix done + + opcode = inst_bytes[op_idx]; + modrm = inst_bytes[op_idx + 1]; + map = PTI_MAP_0; + + if (opcode == 0x0F) { + if (inst_bytes[op_idx + 1] == 0x38) { + map = PTI_MAP_2; + opcode = inst_bytes[op_idx + 2]; + modrm = inst_bytes[op_idx + 3]; + } else if (inst_bytes[op_idx + 1] == 0x3A) { + map = PTI_MAP_3; + opcode = inst_bytes[op_idx + 2]; + modrm = inst_bytes[op_idx + 3]; + } else if ((inst_bytes[op_idx + 1] & 0xf8) == 0x38) { + map = PTI_MAP_INVALID; + opcode = inst_bytes[op_idx + 2]; + modrm = inst_bytes[op_idx + 3]; + } else if (inst_bytes[op_idx + 1] == 0x0F) { + map = PTI_MAP_AMD3DNOW; + opcode = inst_bytes[op_idx + 1]; + modrm = inst_bytes[op_idx + 2]; + } else { + map = PTI_MAP_1; + opcode = inst_bytes[op_idx + 1]; + modrm = inst_bytes[op_idx + 2]; + } + } + + return DecodeInstructionOpcode(opcode, modrm, map); +} + +} // namespace x86 + +lldb::InstructionControlFlowType +Instruction::GetControlFlowInstructionKind(const ExecutionContext *exe_ctx) { + if (exe_ctx->GetTargetRef().GetArchitecture().GetMachine() == + llvm::Triple::ArchType::x86 || + exe_ctx->GetTargetRef().GetArchitecture().GetMachine() == + llvm::Triple::ArchType::x86_64) { + return x86::GetControlFlowInstructionKind(exe_ctx, m_opcode); + } else + return eInstructionControlFlowTypeUnknown; // not implemented +} + AddressClass Instruction::GetAddressClass() { if (m_address_class == AddressClass::eInvalid) m_address_class = m_address.GetAddressClass(); @@ -576,6 +856,7 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t max_opcode_byte_size, bool show_address, bool show_bytes, + bool show_control_flow_kind, const ExecutionContext *exe_ctx, const SymbolContext *sym_ctx, const SymbolContext *prev_sym_ctx, @@ -613,6 +894,38 @@ } } + if (show_control_flow_kind) { + switch (GetControlFlowInstructionKind(exe_ctx)) { + case eInstructionControlFlowTypeUnknown: + ss.Printf("%-12s", "unknown"); + break; + case eInstructionControlFlowTypeOther: + ss.Printf("%-12s", "other"); + break; + case eInstructionControlFlowTypeCall: + ss.Printf("%-12s", "call"); + break; + case eInstructionControlFlowTypeReturn: + ss.Printf("%-12s", "return"); + break; + case eInstructionControlFlowTypeJump: + ss.Printf("%-12s", "jump"); + break; + case eInstructionControlFlowTypeCondJump: + ss.Printf("%-12s", "cond jump"); + break; + case eInstructionControlFlowTypeFarCall: + ss.Printf("%-12s", "far call"); + break; + case eInstructionControlFlowTypeFarReturn: + ss.Printf("%-12s", "far return"); + break; + case eInstructionControlFlowTypeFarJump: + ss.Printf("%-12s", "far jump"); + break; + } + } + const size_t opcode_pos = ss.GetSizeOfLastLine(); // The default opcode size of 7 characters is plenty for most architectures @@ -957,6 +1270,7 @@ } void InstructionList::Dump(Stream *s, bool show_address, bool show_bytes, + bool show_control_flow_kind, const ExecutionContext *exe_ctx) { const uint32_t max_opcode_byte_size = GetMaxOpcocdeByteSize(); collection::const_iterator pos, begin, end; @@ -975,8 +1289,9 @@ pos != end; ++pos) { if (pos != begin) s->EOL(); - (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, exe_ctx, - nullptr, nullptr, disassembly_format, 0); + (*pos)->Dump(s, max_opcode_byte_size, show_address, show_bytes, + show_control_flow_kind, exe_ctx, nullptr, nullptr, + disassembly_format, 0); } } @@ -994,7 +1309,7 @@ size_t num_instructions = m_instructions.size(); uint32_t next_branch = UINT32_MAX; - + if (found_calls) *found_calls = false; for (size_t i = start; i < num_instructions; i++) { Index: lldb/source/Core/DumpDataExtractor.cpp =================================================================== --- lldb/source/Core/DumpDataExtractor.cpp +++ lldb/source/Core/DumpDataExtractor.cpp @@ -170,10 +170,11 @@ offset += bytes_consumed; const bool show_address = base_addr != LLDB_INVALID_ADDRESS; const bool show_bytes = true; + const bool show_kind = true; ExecutionContext exe_ctx; exe_scope->CalculateExecutionContext(exe_ctx); disassembler_sp->GetInstructionList().Dump(s, show_address, show_bytes, - &exe_ctx); + show_kind, &exe_ctx); } } } else Index: lldb/source/Expression/IRExecutionUnit.cpp =================================================================== --- lldb/source/Expression/IRExecutionUnit.cpp +++ lldb/source/Expression/IRExecutionUnit.cpp @@ -200,7 +200,9 @@ UINT32_MAX, false, false); InstructionList &instruction_list = disassembler_sp->GetInstructionList(); - instruction_list.Dump(&stream, true, true, &exe_ctx); + instruction_list.Dump(&stream, true, true, /*show_control_flow_type*/ true, + &exe_ctx); + return ret; } Index: lldb/source/Plugins/TraceExporter/common/TraceHTR.cpp =================================================================== --- lldb/source/Plugins/TraceExporter/common/TraceHTR.cpp +++ lldb/source/Plugins/TraceExporter/common/TraceHTR.cpp @@ -158,7 +158,7 @@ cursor.Next(); } else { lldb::addr_t current_instruction_load_address = cursor.GetLoadAddress(); - lldb::TraceInstructionControlFlowType current_instruction_type = + lldb::InstructionControlFlowType current_instruction_type = cursor.GetInstructionControlFlowType(); m_instruction_layer_up->AppendInstruction( @@ -166,7 +166,7 @@ cursor.Next(); bool more_data_in_trace = cursor.HasValue(); if (current_instruction_type & - lldb::eTraceInstructionControlFlowTypeCall) { + lldb::eInstructionControlFlowTypeCall) { if (more_data_in_trace && !cursor.IsError()) { m_instruction_layer_up->AddCallInstructionMetadata( current_instruction_load_address, Index: lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp =================================================================== --- lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp +++ lldb/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp @@ -83,6 +83,7 @@ const uint32_t addr_byte_size = m_arch.GetAddressByteSize(); const bool show_address = true; const bool show_bytes = true; + const bool show_control_flow_kind = true; m_inst_emulator_up->GetRegisterInfo(unwind_plan.GetRegisterKind(), unwind_plan.GetInitialCFARegister(), m_cfa_reg_info); @@ -244,7 +245,8 @@ lldb_private::FormatEntity::Entry format; FormatEntity::Parse("${frame.pc}: ", format); inst->Dump(&strm, inst_list.GetMaxOpcocdeByteSize(), show_address, - show_bytes, nullptr, nullptr, nullptr, &format, 0); + show_bytes, show_control_flow_kind, nullptr, nullptr, + nullptr, &format, 0); log->PutString(strm.GetString()); } Index: lldb/source/Symbol/Function.cpp =================================================================== --- lldb/source/Symbol/Function.cpp +++ lldb/source/Symbol/Function.cpp @@ -440,8 +440,9 @@ if (disassembler_sp) { const bool show_address = true; const bool show_bytes = false; - disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes, - &exe_ctx); + const bool show_control_flow_kind = false; + disassembler_sp->GetInstructionList().Dump( + &strm, show_address, show_bytes, show_control_flow_kind, &exe_ctx); return true; } return false; Index: lldb/source/Symbol/Symbol.cpp =================================================================== --- lldb/source/Symbol/Symbol.cpp +++ lldb/source/Symbol/Symbol.cpp @@ -558,8 +558,9 @@ if (disassembler_sp) { const bool show_address = true; const bool show_bytes = false; - disassembler_sp->GetInstructionList().Dump(&strm, show_address, show_bytes, - &exe_ctx); + const bool show_control_flow_kind = false; + disassembler_sp->GetInstructionList().Dump( + &strm, show_address, show_bytes, show_control_flow_kind, &exe_ctx); return true; } return false; Index: lldb/source/Target/ThreadPlanTracer.cpp =================================================================== --- lldb/source/Target/ThreadPlanTracer.cpp +++ lldb/source/Target/ThreadPlanTracer.cpp @@ -170,13 +170,14 @@ if (instruction_list.GetSize()) { const bool show_bytes = true; const bool show_address = true; + const bool show_control_flow_kind = true; Instruction *instruction = instruction_list.GetInstructionAtIndex(0).get(); const FormatEntity::Entry *disassemble_format = m_process.GetTarget().GetDebugger().GetDisassemblyFormat(); instruction->Dump(stream, max_opcode_byte_size, show_address, - show_bytes, nullptr, nullptr, nullptr, - disassemble_format, 0); + show_bytes, show_control_flow_kind, nullptr, nullptr, + nullptr, disassemble_format, 0); } } } Index: lldb/source/Target/TraceDumper.cpp =================================================================== --- lldb/source/Target/TraceDumper.cpp +++ lldb/source/Target/TraceDumper.cpp @@ -147,14 +147,14 @@ m_s.Format("{0:x+16}", item.load_address); if (item.symbol_info) { m_s << " "; - item.symbol_info->instruction->Dump(&m_s, /*max_opcode_byte_size=*/0, - /*show_address=*/false, - /*show_bytes=*/false, - &item.symbol_info->exe_ctx, - &item.symbol_info->sc, - /*prev_sym_ctx=*/nullptr, - /*disassembly_addr_format=*/nullptr, - /*max_address_text_size=*/0); + item.symbol_info->instruction->Dump( + &m_s, /*max_opcode_byte_size=*/0, + /*show_address=*/false, + /*show_bytes=*/false, m_options.show_control_flow_kind, + &item.symbol_info->exe_ctx, &item.symbol_info->sc, + /*prev_sym_ctx=*/nullptr, + /*disassembly_addr_format=*/nullptr, + /*max_address_text_size=*/0); } }