Is it possible to dump the current debug bytecode instruction in lldb?

[FlintWangacc]

For example, I am debugging bytecode using lldb in this function. Is it possible to let the function dump bytecode instruction in asm?

  static iree_status_t iree_vm_bytecode_dispatch(
      iree_vm_stack_t* IREE_RESTRICT stack,
      iree_vm_bytecode_module_t* IREE_RESTRICT module,
      iree_vm_stack_frame_t* IREE_RESTRICT current_frame,
      iree_vm_registers_t regs, iree_byte_span_t call_results) {
    // When required emit the dispatch tables here referencing the labels we are
    // defining below.
    DEFINE_DISPATCH_TABLES();

    // Primary dispatch state. This is our 'native stack frame' and really
    // just enough to make dereferencing common addresses (like the current
    // offset) faster. You can think of this like CPU state (like PC).
    //
    // The hope is that the compiler decides to keep these in registers (as
    // they are touched for every instruction executed). The frame will change
    // as we call into different functions.
    const iree_vm_bytecode_module_state_t* IREE_RESTRICT module_state =
        (iree_vm_bytecode_module_state_t*)current_frame->module_state;
    const uint8_t* IREE_RESTRICT bytecode_data =
        module->bytecode_data.data +
A>      module->function_descriptor_table[current_frame->function.ordinal]
            .bytecode_offset;

    int32_t* IREE_RESTRICT regs_i32 = regs.i32;
    IREE_BUILTIN_ASSUME_ALIGNED(regs_i32, sizeof(iree_max_align_t));
    iree_vm_ref_t* IREE_RESTRICT regs_ref = regs.ref;
    IREE_BUILTIN_ASSUME_ALIGNED(regs_ref, sizeof(iree_max_align_t));

    iree_vm_source_offset_t pc = current_frame->pc;
    BEGIN_DISPATCH_CORE() {
      //===------------------------------------------------------------------===//
      // Globals
      //===------------------------------------------------------------------===//

      DISPATCH_OP(CORE, GlobalLoadI32, {
        uint32_t byte_offset = ptr: VM_DecGlobalAttr("global");
        assertion: file: function: line: IREE_ASSERT(byte_offset + 4 <= module_state->rwdata_storage.data_length);
        int32_t* value = ptr: VM_DecResultRegI32("value");
        const int32_t global_value =
            vm_global_load_i32(base: module_state->rwdata_storage.data, byte_offset);
        *value = global_value;
      });

      DISPATCH_OP(CORE, GlobalStoreI32, {
        uint32_t byte_offset = ptr: VM_DecGlobalAttr("global");
        assertion: file: function: line: IREE_ASSERT(byte_offset + 4 <= module_state->rwdata_storage.data_length);
        int32_t value = ptr: VM_DecOperandRegI32("value");
        vm_global_store_i32(base: module_state->rwdata_storage.data, byte_offset,
                            value);
      });

for example, print instruction like this

%c327680_i32 = arith.constant 327680 : i32
      %c655360_i32 = arith.constant 655360 : i32
      %__parameter_global_q_proj_weight_tensor_4096x4096xf32 = util.global.load immutable @__parameter_global_q_proj_weight_tensor_4096x4096xf32 : !stream.resource<constant>
      %__parameter_global_k_proj_weight_tensor_4096x4096xf32 = util.global.load immutable @__parameter_global_k_proj_weight_tensor_4096x4096xf32 : !stream.resource<constant>
      %__parameter_global_v_proj_weight_tensor_4096x4096xf32 = util.global.load immutable @__parameter_global_v_proj_weight_tensor_4096x4096xf32 : !stream.resource<constant>