From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 7478 invoked by alias); 9 Jul 2009 06:36:06 -0000 Received: (qmail 7455 invoked by uid 22791); 9 Jul 2009 06:36:03 -0000 X-SWARE-Spam-Status: No, hits=-1.4 required=5.0 tests=AWL,BAYES_00,J_CHICKENPOX_37,SARE_MSGID_LONG40,SPF_PASS X-Spam-Check-By: sourceware.org Received: from mail-pz0-f203.google.com (HELO mail-pz0-f203.google.com) (209.85.222.203) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Thu, 09 Jul 2009 06:35:56 +0000 Received: by pzk41 with SMTP id 41so5260336pzk.12 for ; Wed, 08 Jul 2009 23:35:54 -0700 (PDT) MIME-Version: 1.0 Received: by 10.142.135.16 with SMTP id i16mr114889wfd.261.1247121354140; Wed, 08 Jul 2009 23:35:54 -0700 (PDT) Date: Thu, 09 Jul 2009 12:22:00 -0000 Message-ID: Subject: Add a new modifier /c to "disassemble" command to make it output binary code From: Hui Zhu To: gdb-patches ml Content-Type: multipart/mixed; boundary=000e0cd328724e2c1d046e4011c0 X-IsSubscribed: yes Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org X-SW-Source: 2009-07/txt/msg00278.txt.bz2 --000e0cd328724e2c1d046e4011c0 Content-Type: text/plain; charset=ISO-8859-1 Content-Transfer-Encoding: 7bit Content-length: 10117 Hi, The objdump will output the binary code when it works but gdb not. I make a patch to add a new modifier /c to "disassemble" command to make it output binary code. Please help me review it. Thanks, Hui 2009-07-09 Hui Zhu * cli/cli-cmds.c (disassemble_command): Add a new modifier /c to "disassemble" command to make it output binary code. (init_cli_cmds): Ditto. (print_disassembly): Add a new argument "code" to make sure output binary code or not. (disassemble_current_function): Ditto. * mi/mi-cmd-disas.c (mi_cmd_disassemble): Ditto. * stack.c (gdb_disassembly_stub): Ditto. * disasm.h (gdb_disassembly): Ditto. * disasm.c (do_mixed_source_and_assembly): Ditto. (do_mixed_source_and_assembly): Ditto. (do_assembly_only): Ditto. (gdb_disassembly): Ditto. (dump_insns): Output the binary code if "code" is true. --- cli/cli-cmds.c | 27 +++++++++++++++++---------- disasm.c | 35 ++++++++++++++++++++++++++--------- disasm.h | 3 ++- mi/mi-cmd-disas.c | 2 +- stack.c | 2 +- 5 files changed, 47 insertions(+), 22 deletions(-) --- a/cli/cli-cmds.c +++ b/cli/cli-cmds.c @@ -908,7 +908,7 @@ list_command (char *arg, int from_tty) static void print_disassembly (struct gdbarch *gdbarch, const char *name, - CORE_ADDR low, CORE_ADDR high, int mixed) + CORE_ADDR low, CORE_ADDR high, int mixed, int code) { #if defined(TUI) if (!tui_is_window_visible (DISASSEM_WIN)) @@ -922,7 +922,7 @@ print_disassembly (struct gdbarch *gdbar paddress (gdbarch, low), paddress (gdbarch, high)); /* Dump the specified range. */ - gdb_disassembly (gdbarch, uiout, 0, mixed, -1, low, high); + gdb_disassembly (gdbarch, uiout, 0, mixed, -1, code, low, high); printf_filtered ("End of assembler dump.\n"); gdb_flush (gdb_stdout); @@ -940,7 +940,7 @@ print_disassembly (struct gdbarch *gdbar MIXED is non-zero to print source with the assembler. */ static void -disassemble_current_function (int mixed) +disassemble_current_function (int mixed, int code) { struct frame_info *frame; struct gdbarch *gdbarch; @@ -961,20 +961,21 @@ disassemble_current_function (int mixed) #endif low += gdbarch_deprecated_function_start_offset (gdbarch); - print_disassembly (gdbarch, name, low, high, mixed); + print_disassembly (gdbarch, name, low, high, mixed, code); } /* Dump a specified section of assembly code. Usage: - disassemble [/m] + disassemble [/mc] - dump the assembly code for the function of the current pc - disassemble [/m] addr + disassemble [/mc] addr - dump the assembly code for the function at ADDR - disassemble [/m] low high + disassemble [/mc] low high - dump the assembly code in the range [LOW,HIGH) - A /m modifier will include source code with the assembly. */ + A /m modifier will include source code with the assembly. + A /c modifier will include binary code with the assembly. */ static void disassemble_command (char *arg, int from_tty) @@ -985,9 +986,11 @@ disassemble_command (char *arg, int from CORE_ADDR pc, pc_masked; char *space_index; int mixed_source_and_assembly; + int code; name = NULL; mixed_source_and_assembly = 0; + code = 0; if (arg && *arg == '/') { @@ -1003,6 +1006,9 @@ disassemble_command (char *arg, int from case 'm': mixed_source_and_assembly = 1; break; + case 'c': + code = 1; + break; default: error (_("Invalid disassembly modifier.")); } @@ -1014,7 +1020,7 @@ disassemble_command (char *arg, int from if (! arg || ! *arg) { - disassemble_current_function (mixed_source_and_assembly); + disassemble_current_function (mixed_source_and_assembly, code); return; } @@ -1044,7 +1050,7 @@ disassemble_command (char *arg, int from high = parse_and_eval_address (space_index + 1); } - print_disassembly (gdbarch, name, low, high, mixed_source_and_assembly); + print_disassembly (gdbarch, name, low, high, mixed_source_and_assembly, code); } static void @@ -1453,6 +1459,7 @@ With two args if one is empty it stands Disassemble a specified section of memory.\n\ Default is the function surrounding the pc of the selected frame.\n\ With a /m modifier, source lines are included (if available).\n\ +With a /c modifier, binary code are included.\n\ With a single argument, the function surrounding that address is dumped.\n\ Two arguments are taken as a range of memory to dump.")); set_cmd_completer (c, location_completer); --- a/disasm.c +++ b/disasm.c @@ -88,7 +88,7 @@ static int dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, - int how_many, struct ui_stream *stb) + int how_many, int code, struct ui_stream *stb) { int num_displayed = 0; CORE_ADDR pc; @@ -135,7 +135,23 @@ dump_insns (struct gdbarch *gdbarch, str xfree (name); ui_file_rewind (stb->stream); - pc += gdbarch_print_insn (gdbarch, pc, di); + if (code) + { + CORE_ADDR old_pc = pc; + bfd_byte data; + int status; + pc += gdbarch_print_insn (gdbarch, pc, di); + for (;old_pc < pc; old_pc++) + { + status = (*di->read_memory_func) (old_pc, &data, 1, di); + if (status != 0) + (*di->memory_error_func) (status, old_pc, di); + ui_out_message (uiout, 0, " %02x", (unsigned)data); + } + ui_out_text (uiout, "\t"); + } + else + pc += gdbarch_print_insn (gdbarch, pc, di); ui_out_field_stream (uiout, "inst", stb); ui_file_rewind (stb->stream); do_cleanups (ui_out_chain); @@ -154,7 +170,7 @@ do_mixed_source_and_assembly (struct gdb struct linetable_entry *le, CORE_ADDR low, CORE_ADDR high, struct symtab *symtab, - int how_many, struct ui_stream *stb) + int how_many, int code, struct ui_stream *stb) { int newlines = 0; struct dis_line_entry *mle; @@ -278,7 +294,7 @@ do_mixed_source_and_assembly (struct gdb num_displayed += dump_insns (gdbarch, uiout, di, mle[i].start_pc, mle[i].end_pc, - how_many, stb); + how_many, code, stb); /* When we've reached the end of the mle array, or we've seen the last assembly range for this source line, close out the list/tuple. */ @@ -301,14 +317,15 @@ static void do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, - int how_many, struct ui_stream *stb) + int how_many, int code, struct ui_stream *stb) { int num_displayed = 0; struct cleanup *ui_out_chain; ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); - num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many, stb); + num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many, + code, stb); do_cleanups (ui_out_chain); } @@ -357,7 +374,7 @@ void gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout, char *file_string, int mixed_source_and_assembly, - int how_many, CORE_ADDR low, CORE_ADDR high) + int how_many, int code, CORE_ADDR low, CORE_ADDR high) { struct ui_stream *stb = ui_out_stream_new (uiout); struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb); @@ -379,11 +396,11 @@ gdb_disassembly (struct gdbarch *gdbarch if (!mixed_source_and_assembly || nlines <= 0 || symtab == NULL || symtab->linetable == NULL) - do_assembly_only (gdbarch, uiout, &di, low, high, how_many, stb); + do_assembly_only (gdbarch, uiout, &di, low, high, how_many, code, stb); else if (mixed_source_and_assembly) do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low, - high, symtab, how_many, stb); + high, symtab, how_many, code, stb); do_cleanups (cleanups); gdb_flush (gdb_stdout); --- a/disasm.h +++ b/disasm.h @@ -25,7 +25,8 @@ struct ui_file; extern void gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout, char *file_string, int mixed_source_and_assembly, - int how_many, CORE_ADDR low, CORE_ADDR high); + int how_many, int code, CORE_ADDR low, + CORE_ADDR high); /* Print the instruction at address MEMADDR in debugged memory, on STREAM. Returns the length of the instruction, in bytes, --- a/mi/mi-cmd-disas.c +++ b/mi/mi-cmd-disas.c @@ -156,6 +156,6 @@ mi_cmd_disassemble (char *command, char gdb_disassembly (gdbarch, uiout, file_string, - mixed_source_and_assembly, how_many, low, high); + mixed_source_and_assembly, 0, how_many, low, high); } --- a/stack.c +++ b/stack.c @@ -481,7 +481,7 @@ static void gdb_disassembly_stub (void *args) { struct gdb_disassembly_stub_args *p = args; - gdb_disassembly (p->gdbarch, uiout, 0, 0, p->how_many, p->low, p->high); + gdb_disassembly (p->gdbarch, uiout, 0, 0, 1, p->how_many, p->low, p->high); } /* Use TRY_CATCH to catch the exception from the gdb_disassembly 2009-07-09 Hui Zhu * gdb.texinfo (disassemble): Add a new modifier /c to "disassemble" command to make it output binary code. --- doc/gdb.texinfo | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) --- a/doc/gdb.texinfo +++ b/doc/gdb.texinfo @@ -6177,10 +6177,11 @@ Variables}). @cindex machine instructions @cindex listing machine instructions @item disassemble -@itemx disassemble /m +@itemx disassemble /mc This specialized command dumps a range of memory as machine instructions. It can also print mixed source+disassembly by specifying -the @code{/m} modifier. +the @code{/m} modifier and print binary code by specifying +the @code{/c}. The default memory range is the function surrounding the program counter of the selected frame. A single argument to this command is a program counter value; @value{GDBN} dumps the function --000e0cd328724e2c1d046e4011c0 Content-Type: text/plain; charset=US-ASCII; name="disassemble-output-code.txt" Content-Disposition: attachment; filename="disassemble-output-code.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fwx3vs310 Content-length: 11395 LS0tCiBjbGkvY2xpLWNtZHMuYyAgICB8ICAgMjcgKysrKysrKysrKysrKysr KystLS0tLS0tLS0tCiBkaXNhc20uYyAgICAgICAgICB8ICAgMzUgKysrKysr KysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0KIGRpc2FzbS5oICAgICAg ICAgIHwgICAgMyArKy0KIG1pL21pLWNtZC1kaXNhcy5jIHwgICAgMiArLQog c3RhY2suYyAgICAgICAgICAgfCAgICAyICstCiA1IGZpbGVzIGNoYW5nZWQs IDQ3IGluc2VydGlvbnMoKyksIDIyIGRlbGV0aW9ucygtKQoKLS0tIGEvY2xp L2NsaS1jbWRzLmMKKysrIGIvY2xpL2NsaS1jbWRzLmMKQEAgLTkwOCw3ICs5 MDgsNyBAQCBsaXN0X2NvbW1hbmQgKGNoYXIgKmFyZywgaW50IGZyb21fdHR5 KQogCiBzdGF0aWMgdm9pZAogcHJpbnRfZGlzYXNzZW1ibHkgKHN0cnVjdCBn ZGJhcmNoICpnZGJhcmNoLCBjb25zdCBjaGFyICpuYW1lLAotCQkgICBDT1JF X0FERFIgbG93LCBDT1JFX0FERFIgaGlnaCwgaW50IG1peGVkKQorCQkgICBD T1JFX0FERFIgbG93LCBDT1JFX0FERFIgaGlnaCwgaW50IG1peGVkLCBpbnQg Y29kZSkKIHsKICNpZiBkZWZpbmVkKFRVSSkKICAgaWYgKCF0dWlfaXNfd2lu ZG93X3Zpc2libGUgKERJU0FTU0VNX1dJTikpCkBAIC05MjIsNyArOTIyLDcg QEAgcHJpbnRfZGlzYXNzZW1ibHkgKHN0cnVjdCBnZGJhcmNoICpnZGJhcgog CQkJIHBhZGRyZXNzIChnZGJhcmNoLCBsb3cpLCBwYWRkcmVzcyAoZ2RiYXJj aCwgaGlnaCkpOwogCiAgICAgICAvKiBEdW1wIHRoZSBzcGVjaWZpZWQgcmFu Z2UuICAqLwotICAgICAgZ2RiX2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCB1aW91 dCwgMCwgbWl4ZWQsIC0xLCBsb3csIGhpZ2gpOworICAgICAgZ2RiX2Rpc2Fz c2VtYmx5IChnZGJhcmNoLCB1aW91dCwgMCwgbWl4ZWQsIC0xLCBjb2RlLCBs b3csIGhpZ2gpOwogCiAgICAgICBwcmludGZfZmlsdGVyZWQgKCJFbmQgb2Yg YXNzZW1ibGVyIGR1bXAuXG4iKTsKICAgICAgIGdkYl9mbHVzaCAoZ2RiX3N0 ZG91dCk7CkBAIC05NDAsNyArOTQwLDcgQEAgcHJpbnRfZGlzYXNzZW1ibHkg KHN0cnVjdCBnZGJhcmNoICpnZGJhcgogICAgTUlYRUQgaXMgbm9uLXplcm8g dG8gcHJpbnQgc291cmNlIHdpdGggdGhlIGFzc2VtYmxlci4gICovCiAKIHN0 YXRpYyB2b2lkCi1kaXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQg bWl4ZWQpCitkaXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChpbnQgbWl4 ZWQsIGludCBjb2RlKQogewogICBzdHJ1Y3QgZnJhbWVfaW5mbyAqZnJhbWU7 CiAgIHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoOwpAQCAtOTYxLDIwICs5NjEs MjEgQEAgZGlzYXNzZW1ibGVfY3VycmVudF9mdW5jdGlvbiAoaW50IG1peGVk KQogI2VuZGlmCiAgIGxvdyArPSBnZGJhcmNoX2RlcHJlY2F0ZWRfZnVuY3Rp b25fc3RhcnRfb2Zmc2V0IChnZGJhcmNoKTsKIAotICBwcmludF9kaXNhc3Nl bWJseSAoZ2RiYXJjaCwgbmFtZSwgbG93LCBoaWdoLCBtaXhlZCk7CisgIHBy aW50X2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCBuYW1lLCBsb3csIGhpZ2gsIG1p eGVkLCBjb2RlKTsKIH0KIAogLyogRHVtcCBhIHNwZWNpZmllZCBzZWN0aW9u IG9mIGFzc2VtYmx5IGNvZGUuCiAKICAgIFVzYWdlOgotICAgICBkaXNhc3Nl bWJsZSBbL21dCisgICAgIGRpc2Fzc2VtYmxlIFsvbWNdCiAgICAgICAgLSBk dW1wIHRoZSBhc3NlbWJseSBjb2RlIGZvciB0aGUgZnVuY3Rpb24gb2YgdGhl IGN1cnJlbnQgcGMKLSAgICAgZGlzYXNzZW1ibGUgWy9tXSBhZGRyCisgICAg IGRpc2Fzc2VtYmxlIFsvbWNdIGFkZHIKICAgICAgICAtIGR1bXAgdGhlIGFz c2VtYmx5IGNvZGUgZm9yIHRoZSBmdW5jdGlvbiBhdCBBRERSCi0gICAgIGRp c2Fzc2VtYmxlIFsvbV0gbG93IGhpZ2gKKyAgICAgZGlzYXNzZW1ibGUgWy9t Y10gbG93IGhpZ2gKICAgICAgICAtIGR1bXAgdGhlIGFzc2VtYmx5IGNvZGUg aW4gdGhlIHJhbmdlIFtMT1csSElHSCkKIAotICAgQSAvbSBtb2RpZmllciB3 aWxsIGluY2x1ZGUgc291cmNlIGNvZGUgd2l0aCB0aGUgYXNzZW1ibHkuICAq LworICAgQSAvbSBtb2RpZmllciB3aWxsIGluY2x1ZGUgc291cmNlIGNvZGUg d2l0aCB0aGUgYXNzZW1ibHkuCisgICBBIC9jIG1vZGlmaWVyIHdpbGwgaW5j bHVkZSBiaW5hcnkgY29kZSB3aXRoIHRoZSBhc3NlbWJseS4gICovCiAKIHN0 YXRpYyB2b2lkCiBkaXNhc3NlbWJsZV9jb21tYW5kIChjaGFyICphcmcsIGlu dCBmcm9tX3R0eSkKQEAgLTk4NSw5ICs5ODYsMTEgQEAgZGlzYXNzZW1ibGVf Y29tbWFuZCAoY2hhciAqYXJnLCBpbnQgZnJvbQogICBDT1JFX0FERFIgcGMs IHBjX21hc2tlZDsKICAgY2hhciAqc3BhY2VfaW5kZXg7CiAgIGludCBtaXhl ZF9zb3VyY2VfYW5kX2Fzc2VtYmx5OworICBpbnQgY29kZTsKIAogICBuYW1l ID0gTlVMTDsKICAgbWl4ZWRfc291cmNlX2FuZF9hc3NlbWJseSA9IDA7Cisg IGNvZGUgPSAwOwogCiAgIGlmIChhcmcgJiYgKmFyZyA9PSAnLycpCiAgICAg ewpAQCAtMTAwMyw2ICsxMDA2LDkgQEAgZGlzYXNzZW1ibGVfY29tbWFuZCAo Y2hhciAqYXJnLCBpbnQgZnJvbQogCSAgICBjYXNlICdtJzoKIAkgICAgICBt aXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5ID0gMTsKIAkgICAgICBicmVhazsK KwkgICAgY2FzZSAnYyc6CisJICAgICAgY29kZSA9IDE7CisJICAgICAgYnJl YWs7CiAJICAgIGRlZmF1bHQ6CiAJICAgICAgZXJyb3IgKF8oIkludmFsaWQg ZGlzYXNzZW1ibHkgbW9kaWZpZXIuIikpOwogCSAgICB9CkBAIC0xMDE0LDcg KzEwMjAsNyBAQCBkaXNhc3NlbWJsZV9jb21tYW5kIChjaGFyICphcmcsIGlu dCBmcm9tCiAKICAgaWYgKCEgYXJnIHx8ICEgKmFyZykKICAgICB7Ci0gICAg ICBkaXNhc3NlbWJsZV9jdXJyZW50X2Z1bmN0aW9uIChtaXhlZF9zb3VyY2Vf YW5kX2Fzc2VtYmx5KTsKKyAgICAgIGRpc2Fzc2VtYmxlX2N1cnJlbnRfZnVu Y3Rpb24gKG1peGVkX3NvdXJjZV9hbmRfYXNzZW1ibHksIGNvZGUpOwogICAg ICAgcmV0dXJuOwogICAgIH0KIApAQCAtMTA0NCw3ICsxMDUwLDcgQEAgZGlz YXNzZW1ibGVfY29tbWFuZCAoY2hhciAqYXJnLCBpbnQgZnJvbQogICAgICAg aGlnaCA9IHBhcnNlX2FuZF9ldmFsX2FkZHJlc3MgKHNwYWNlX2luZGV4ICsg MSk7CiAgICAgfQogCi0gIHByaW50X2Rpc2Fzc2VtYmx5IChnZGJhcmNoLCBu YW1lLCBsb3csIGhpZ2gsIG1peGVkX3NvdXJjZV9hbmRfYXNzZW1ibHkpOwor ICBwcmludF9kaXNhc3NlbWJseSAoZ2RiYXJjaCwgbmFtZSwgbG93LCBoaWdo LCBtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5LCBjb2RlKTsKIH0KIAogc3Rh dGljIHZvaWQKQEAgLTE0NTMsNiArMTQ1OSw3IEBAIFdpdGggdHdvIGFyZ3Mg aWYgb25lIGlzIGVtcHR5IGl0IHN0YW5kcyAKIERpc2Fzc2VtYmxlIGEgc3Bl Y2lmaWVkIHNlY3Rpb24gb2YgbWVtb3J5LlxuXAogRGVmYXVsdCBpcyB0aGUg ZnVuY3Rpb24gc3Vycm91bmRpbmcgdGhlIHBjIG9mIHRoZSBzZWxlY3RlZCBm cmFtZS5cblwKIFdpdGggYSAvbSBtb2RpZmllciwgc291cmNlIGxpbmVzIGFy ZSBpbmNsdWRlZCAoaWYgYXZhaWxhYmxlKS5cblwKK1dpdGggYSAvYyBtb2Rp ZmllciwgYmluYXJ5IGNvZGUgYXJlIGluY2x1ZGVkLlxuXAogV2l0aCBhIHNp bmdsZSBhcmd1bWVudCwgdGhlIGZ1bmN0aW9uIHN1cnJvdW5kaW5nIHRoYXQg YWRkcmVzcyBpcyBkdW1wZWQuXG5cCiBUd28gYXJndW1lbnRzIGFyZSB0YWtl biBhcyBhIHJhbmdlIG9mIG1lbW9yeSB0byBkdW1wLiIpKTsKICAgc2V0X2Nt ZF9jb21wbGV0ZXIgKGMsIGxvY2F0aW9uX2NvbXBsZXRlcik7Ci0tLSBhL2Rp c2FzbS5jCisrKyBiL2Rpc2FzbS5jCkBAIC04OCw3ICs4OCw3IEBAIHN0YXRp YyBpbnQKIGR1bXBfaW5zbnMgKHN0cnVjdCBnZGJhcmNoICpnZGJhcmNoLCBz dHJ1Y3QgdWlfb3V0ICp1aW91dCwKIAkgICAgc3RydWN0IGRpc2Fzc2VtYmxl X2luZm8gKiBkaSwKIAkgICAgQ09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhp Z2gsCi0JICAgIGludCBob3dfbWFueSwgc3RydWN0IHVpX3N0cmVhbSAqc3Ri KQorCSAgICBpbnQgaG93X21hbnksIGludCBjb2RlLCBzdHJ1Y3QgdWlfc3Ry ZWFtICpzdGIpCiB7CiAgIGludCBudW1fZGlzcGxheWVkID0gMDsKICAgQ09S RV9BRERSIHBjOwpAQCAtMTM1LDcgKzEzNSwyMyBAQCBkdW1wX2luc25zIChz dHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwgc3RyCiAJeGZyZWUgKG5hbWUpOwog CiAgICAgICB1aV9maWxlX3Jld2luZCAoc3RiLT5zdHJlYW0pOwotICAgICAg cGMgKz0gZ2RiYXJjaF9wcmludF9pbnNuIChnZGJhcmNoLCBwYywgZGkpOwor ICAgICAgaWYgKGNvZGUpCisgICAgICAgIHsKKyAgICAgICAgICBDT1JFX0FE RFIgb2xkX3BjID0gcGM7CisgICAgICAgICAgYmZkX2J5dGUgZGF0YTsKKyAg ICAgICAgICBpbnQgc3RhdHVzOworICAgICAgICAgIHBjICs9IGdkYmFyY2hf cHJpbnRfaW5zbiAoZ2RiYXJjaCwgcGMsIGRpKTsKKyAgICAgICAgICBmb3Ig KDtvbGRfcGMgPCBwYzsgb2xkX3BjKyspCisgICAgICAgICAgICB7CisgICAg ICAgICAgICAgIHN0YXR1cyA9ICgqZGktPnJlYWRfbWVtb3J5X2Z1bmMpIChv bGRfcGMsICZkYXRhLCAxLCBkaSk7CisgICAgICAgICAgICAgIGlmIChzdGF0 dXMgIT0gMCkKKyAgICAgICAgICAgICAgICAoKmRpLT5tZW1vcnlfZXJyb3Jf ZnVuYykgKHN0YXR1cywgb2xkX3BjLCBkaSk7CisgICAgICAgICAgICAgIHVp X291dF9tZXNzYWdlICh1aW91dCwgMCwgIiAlMDJ4IiwgKHVuc2lnbmVkKWRh dGEpOworICAgICAgICAgICAgfQorICAgICAgICAgIHVpX291dF90ZXh0ICh1 aW91dCwgIlx0Iik7CisgICAgICAgIH0KKyAgICAgIGVsc2UKKyAgICAgICAg cGMgKz0gZ2RiYXJjaF9wcmludF9pbnNuIChnZGJhcmNoLCBwYywgZGkpOwog ICAgICAgdWlfb3V0X2ZpZWxkX3N0cmVhbSAodWlvdXQsICJpbnN0Iiwgc3Ri KTsKICAgICAgIHVpX2ZpbGVfcmV3aW5kIChzdGItPnN0cmVhbSk7CiAgICAg ICBkb19jbGVhbnVwcyAodWlfb3V0X2NoYWluKTsKQEAgLTE1NCw3ICsxNzAs NyBAQCBkb19taXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5IChzdHJ1Y3QgZ2Ri CiAJCQkgICAgICBzdHJ1Y3QgbGluZXRhYmxlX2VudHJ5ICpsZSwKIAkJCSAg ICAgIENPUkVfQUREUiBsb3csIENPUkVfQUREUiBoaWdoLAogCQkJICAgICAg c3RydWN0IHN5bXRhYiAqc3ltdGFiLAotCQkJICAgICAgaW50IGhvd19tYW55 LCBzdHJ1Y3QgdWlfc3RyZWFtICpzdGIpCisJCQkgICAgICBpbnQgaG93X21h bnksIGludCBjb2RlLCBzdHJ1Y3QgdWlfc3RyZWFtICpzdGIpCiB7CiAgIGlu dCBuZXdsaW5lcyA9IDA7CiAgIHN0cnVjdCBkaXNfbGluZV9lbnRyeSAqbWxl OwpAQCAtMjc4LDcgKzI5NCw3IEBAIGRvX21peGVkX3NvdXJjZV9hbmRfYXNz ZW1ibHkgKHN0cnVjdCBnZGIKIAogICAgICAgbnVtX2Rpc3BsYXllZCArPSBk dW1wX2luc25zIChnZGJhcmNoLCB1aW91dCwgZGksCiAJCQkJICAgbWxlW2ld LnN0YXJ0X3BjLCBtbGVbaV0uZW5kX3BjLAotCQkJCSAgIGhvd19tYW55LCBz dGIpOworCQkJCSAgIGhvd19tYW55LCBjb2RlLCBzdGIpOwogCiAgICAgICAv KiBXaGVuIHdlJ3ZlIHJlYWNoZWQgdGhlIGVuZCBvZiB0aGUgbWxlIGFycmF5 LCBvciB3ZSd2ZSBzZWVuIHRoZSBsYXN0CiAgICAgICAgICBhc3NlbWJseSBy YW5nZSBmb3IgdGhpcyBzb3VyY2UgbGluZSwgY2xvc2Ugb3V0IHRoZSBsaXN0 L3R1cGxlLiAgKi8KQEAgLTMwMSwxNCArMzE3LDE1IEBAIHN0YXRpYyB2b2lk CiBkb19hc3NlbWJseV9vbmx5IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJjaCwg c3RydWN0IHVpX291dCAqdWlvdXQsCiAJCSAgc3RydWN0IGRpc2Fzc2VtYmxl X2luZm8gKiBkaSwKIAkJICBDT1JFX0FERFIgbG93LCBDT1JFX0FERFIgaGln aCwKLQkJICBpbnQgaG93X21hbnksIHN0cnVjdCB1aV9zdHJlYW0gKnN0YikK KwkJICBpbnQgaG93X21hbnksIGludCBjb2RlLCBzdHJ1Y3QgdWlfc3RyZWFt ICpzdGIpCiB7CiAgIGludCBudW1fZGlzcGxheWVkID0gMDsKICAgc3RydWN0 IGNsZWFudXAgKnVpX291dF9jaGFpbjsKIAogICB1aV9vdXRfY2hhaW4gPSBt YWtlX2NsZWFudXBfdWlfb3V0X2xpc3RfYmVnaW5fZW5kICh1aW91dCwgImFz bV9pbnNucyIpOwogCi0gIG51bV9kaXNwbGF5ZWQgPSBkdW1wX2luc25zIChn ZGJhcmNoLCB1aW91dCwgZGksIGxvdywgaGlnaCwgaG93X21hbnksIHN0Yik7 CisgIG51bV9kaXNwbGF5ZWQgPSBkdW1wX2luc25zIChnZGJhcmNoLCB1aW91 dCwgZGksIGxvdywgaGlnaCwgaG93X21hbnksCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICBjb2RlLCBzdGIpOwogCiAgIGRvX2NsZWFudXBzICh1 aV9vdXRfY2hhaW4pOwogfQpAQCAtMzU3LDcgKzM3NCw3IEBAIHZvaWQKIGdk Yl9kaXNhc3NlbWJseSAoc3RydWN0IGdkYmFyY2ggKmdkYmFyY2gsIHN0cnVj dCB1aV9vdXQgKnVpb3V0LAogCQljaGFyICpmaWxlX3N0cmluZywKIAkJaW50 IG1peGVkX3NvdXJjZV9hbmRfYXNzZW1ibHksCi0JCWludCBob3dfbWFueSwg Q09SRV9BRERSIGxvdywgQ09SRV9BRERSIGhpZ2gpCisJCWludCBob3dfbWFu eSwgaW50IGNvZGUsIENPUkVfQUREUiBsb3csIENPUkVfQUREUiBoaWdoKQog ewogICBzdHJ1Y3QgdWlfc3RyZWFtICpzdGIgPSB1aV9vdXRfc3RyZWFtX25l dyAodWlvdXQpOwogICBzdHJ1Y3QgY2xlYW51cCAqY2xlYW51cHMgPSBtYWtl X2NsZWFudXBfdWlfb3V0X3N0cmVhbV9kZWxldGUgKHN0Yik7CkBAIC0zNzks MTEgKzM5NiwxMSBAQCBnZGJfZGlzYXNzZW1ibHkgKHN0cnVjdCBnZGJhcmNo ICpnZGJhcmNoCiAKICAgaWYgKCFtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5 IHx8IG5saW5lcyA8PSAwCiAgICAgICB8fCBzeW10YWIgPT0gTlVMTCB8fCBz eW10YWItPmxpbmV0YWJsZSA9PSBOVUxMKQotICAgIGRvX2Fzc2VtYmx5X29u bHkgKGdkYmFyY2gsIHVpb3V0LCAmZGksIGxvdywgaGlnaCwgaG93X21hbnks IHN0Yik7CisgICAgZG9fYXNzZW1ibHlfb25seSAoZ2RiYXJjaCwgdWlvdXQs ICZkaSwgbG93LCBoaWdoLCBob3dfbWFueSwgY29kZSwgc3RiKTsKIAogICBl bHNlIGlmIChtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5KQogICAgIGRvX21p eGVkX3NvdXJjZV9hbmRfYXNzZW1ibHkgKGdkYmFyY2gsIHVpb3V0LCAmZGks IG5saW5lcywgbGUsIGxvdywKLQkJCQkgIGhpZ2gsIHN5bXRhYiwgaG93X21h bnksIHN0Yik7CisJCQkJICBoaWdoLCBzeW10YWIsIGhvd19tYW55LCBjb2Rl LCBzdGIpOwogCiAgIGRvX2NsZWFudXBzIChjbGVhbnVwcyk7CiAgIGdkYl9m bHVzaCAoZ2RiX3N0ZG91dCk7Ci0tLSBhL2Rpc2FzbS5oCisrKyBiL2Rpc2Fz bS5oCkBAIC0yNSw3ICsyNSw4IEBAIHN0cnVjdCB1aV9maWxlOwogZXh0ZXJu IHZvaWQgZ2RiX2Rpc2Fzc2VtYmx5IChzdHJ1Y3QgZ2RiYXJjaCAqZ2RiYXJj aCwgc3RydWN0IHVpX291dCAqdWlvdXQsCiAJCQkgICAgIGNoYXIgKmZpbGVf c3RyaW5nLAogCQkJICAgICBpbnQgbWl4ZWRfc291cmNlX2FuZF9hc3NlbWJs eSwKLQkJCSAgICAgaW50IGhvd19tYW55LCBDT1JFX0FERFIgbG93LCBDT1JF X0FERFIgaGlnaCk7CisJCQkgICAgIGludCBob3dfbWFueSwgaW50IGNvZGUs IENPUkVfQUREUiBsb3csCisJICAgICAgICAgICAgICAgICAgICAgQ09SRV9B RERSIGhpZ2gpOwogCiAvKiBQcmludCB0aGUgaW5zdHJ1Y3Rpb24gYXQgYWRk cmVzcyBNRU1BRERSIGluIGRlYnVnZ2VkIG1lbW9yeSwKICAgIG9uIFNUUkVB TS4gIFJldHVybnMgdGhlIGxlbmd0aCBvZiB0aGUgaW5zdHJ1Y3Rpb24sIGlu IGJ5dGVzLAotLS0gYS9taS9taS1jbWQtZGlzYXMuYworKysgYi9taS9taS1j bWQtZGlzYXMuYwpAQCAtMTU2LDYgKzE1Niw2IEBAIG1pX2NtZF9kaXNhc3Nl bWJsZSAoY2hhciAqY29tbWFuZCwgY2hhciAKIAogICBnZGJfZGlzYXNzZW1i bHkgKGdkYmFyY2gsIHVpb3V0LAogICAJCSAgIGZpbGVfc3RyaW5nLAotCQkg ICBtaXhlZF9zb3VyY2VfYW5kX2Fzc2VtYmx5LCBob3dfbWFueSwgbG93LCBo aWdoKTsKKwkJICAgbWl4ZWRfc291cmNlX2FuZF9hc3NlbWJseSwgMCwgaG93 X21hbnksIGxvdywgaGlnaCk7CiAKIH0KLS0tIGEvc3RhY2suYworKysgYi9z dGFjay5jCkBAIC00ODEsNyArNDgxLDcgQEAgc3RhdGljIHZvaWQKIGdkYl9k aXNhc3NlbWJseV9zdHViICh2b2lkICphcmdzKQogewogICBzdHJ1Y3QgZ2Ri X2Rpc2Fzc2VtYmx5X3N0dWJfYXJncyAqcCA9IGFyZ3M7Ci0gIGdkYl9kaXNh c3NlbWJseSAocC0+Z2RiYXJjaCwgdWlvdXQsIDAsIDAsIHAtPmhvd19tYW55 LCBwLT5sb3csIHAtPmhpZ2gpOworICBnZGJfZGlzYXNzZW1ibHkgKHAtPmdk YmFyY2gsIHVpb3V0LCAwLCAwLCAxLCBwLT5ob3dfbWFueSwgcC0+bG93LCBw LT5oaWdoKTsKIH0KIAogLyogVXNlIFRSWV9DQVRDSCB0byBjYXRjaCB0aGUg ZXhjZXB0aW9uIGZyb20gdGhlIGdkYl9kaXNhc3NlbWJseQo= --000e0cd328724e2c1d046e4011c0 Content-Type: text/plain; charset=US-ASCII; name="disassemble-output-code-doc.txt" Content-Disposition: attachment; filename="disassemble-output-code-doc.txt" Content-Transfer-Encoding: base64 X-Attachment-Id: f_fwx3vswz1 Content-length: 989 LS0tCiBkb2MvZ2RiLnRleGluZm8gfCAgICA1ICsrKy0tCiAxIGZpbGUgY2hh bmdlZCwgMyBpbnNlcnRpb25zKCspLCAyIGRlbGV0aW9ucygtKQoKLS0tIGEv ZG9jL2dkYi50ZXhpbmZvCisrKyBiL2RvYy9nZGIudGV4aW5mbwpAQCAtNjE3 NywxMCArNjE3NywxMSBAQCBWYXJpYWJsZXN9KS4KIEBjaW5kZXggbWFjaGlu ZSBpbnN0cnVjdGlvbnMKIEBjaW5kZXggbGlzdGluZyBtYWNoaW5lIGluc3Ry dWN0aW9ucwogQGl0ZW0gZGlzYXNzZW1ibGUKLUBpdGVteCBkaXNhc3NlbWJs ZSAvbQorQGl0ZW14IGRpc2Fzc2VtYmxlIC9tYwogVGhpcyBzcGVjaWFsaXpl ZCBjb21tYW5kIGR1bXBzIGEgcmFuZ2Ugb2YgbWVtb3J5IGFzIG1hY2hpbmUK IGluc3RydWN0aW9ucy4gIEl0IGNhbiBhbHNvIHByaW50IG1peGVkIHNvdXJj ZStkaXNhc3NlbWJseSBieSBzcGVjaWZ5aW5nCi10aGUgQGNvZGV7L219IG1v ZGlmaWVyLgordGhlIEBjb2Rley9tfSBtb2RpZmllciBhbmQgcHJpbnQgYmlu YXJ5IGNvZGUgYnkgc3BlY2lmeWluZwordGhlIEBjb2Rley9jfS4KIFRoZSBk ZWZhdWx0IG1lbW9yeSByYW5nZSBpcyB0aGUgZnVuY3Rpb24gc3Vycm91bmRp bmcgdGhlCiBwcm9ncmFtIGNvdW50ZXIgb2YgdGhlIHNlbGVjdGVkIGZyYW1l LiAgQSBzaW5nbGUgYXJndW1lbnQgdG8gdGhpcwogY29tbWFuZCBpcyBhIHBy b2dyYW0gY291bnRlciB2YWx1ZTsgQHZhbHVle0dEQk59IGR1bXBzIHRoZSBm dW5jdGlvbgo= --000e0cd328724e2c1d046e4011c0--