2003-04-28 Andrew Cagney * disasm.c (gdb_disassemble_from_exec): Delete global variable. (gdb_disassembly): Make "di" non static, always initialize and cleanup. Always use dis_asm_read_memory. (gdb_dis_asm_read_memory): Delete function. Index: testsuite/ChangeLog 2003-04-28 Andrew Cagney * gdb.asm/asm-source.exp: Check that the disassm and x/i of a variable doesn't give a memory error. Index: disasm.c =================================================================== RCS file: /cvs/src/src/gdb/disasm.c,v retrieving revision 1.6 diff -u -r1.6 disasm.c --- disasm.c 8 Apr 2003 01:40:31 -0000 1.6 +++ disasm.c 28 Apr 2003 20:57:57 -0000 @@ -43,29 +43,6 @@ CORE_ADDR end_pc; }; -/* This variable determines where memory used for disassembly is read from. */ -int gdb_disassemble_from_exec = -1; - -/* This is the memory_read_func for gdb_disassemble when we are - disassembling from the exec file. */ -static int -gdb_dis_asm_read_memory (bfd_vma memaddr, bfd_byte * myaddr, - unsigned int len, disassemble_info * info) -{ - extern struct target_ops exec_ops; - int res; - - errno = 0; - res = xfer_memory (memaddr, myaddr, len, 0, 0, &exec_ops); - - if (res == len) - return 0; - else if (errno == 0) - return EIO; - else - return errno; -} - static int compare_lines (const void *mle1p, const void *mle2p) { @@ -315,62 +292,31 @@ int mixed_source_and_assembly, int how_many, CORE_ADDR low, CORE_ADDR high) { - static disassemble_info di; - static int di_initialized; + struct ui_stream *stb = ui_out_stream_new (uiout); + struct cleanup *cleanups = make_cleanup_ui_out_stream_delete (stb); + disassemble_info di; /* To collect the instruction outputted from opcodes. */ - static struct ui_stream *stb = NULL; struct symtab *symtab = NULL; struct linetable_entry *le = NULL; int nlines = -1; - if (!di_initialized) - { - /* We don't add a cleanup for this, because the allocation of - the stream is done once only for each gdb run, and we need to - keep it around until the end. Hopefully there won't be any - errors in the init code below, that make this function bail - out. */ - stb = ui_out_stream_new (uiout); - INIT_DISASSEMBLE_INFO_NO_ARCH (di, stb->stream, - (fprintf_ftype) fprintf_unfiltered); - di.flavour = bfd_target_unknown_flavour; - di.memory_error_func = dis_asm_memory_error; - di.print_address_func = dis_asm_print_address; - di_initialized = 1; - } - + INIT_DISASSEMBLE_INFO_NO_ARCH (di, stb->stream, + (fprintf_ftype) fprintf_unfiltered); + di.flavour = bfd_target_unknown_flavour; + di.memory_error_func = dis_asm_memory_error; + di.print_address_func = dis_asm_print_address; + /* NOTE: cagney/2003-04-28: The original code, from the old Insight + disassembler had a local optomization here. By default it would + access the executable file, instead of the target memory (there + was a growing list of exceptions though). Unfortunatly, the + heuristic was flawed. Commands like "disassemble &variable" + didn't work as they relied on the access going to the target. + Further, it has been supperseeded by trust-read-only-sections + (although that should be superseeded by target_trust..._p()). */ + di.read_memory_func = dis_asm_read_memory; di.mach = gdbarch_bfd_arch_info (current_gdbarch)->mach; di.endian = gdbarch_byte_order (current_gdbarch); - /* If gdb_disassemble_from_exec == -1, then we use the following heuristic to - determine whether or not to do disassembly from target memory or from the - exec file: - - If we're debugging a local process, read target memory, instead of the - exec file. This makes disassembly of functions in shared libs work - correctly. Also, read target memory if we are debugging native threads. - - Else, we're debugging a remote process, and should disassemble from the - exec file for speed. However, this is no good if the target modifies its - code (for relocation, or whatever). */ - - if (gdb_disassemble_from_exec == -1) - { - if (strcmp (target_shortname, "child") == 0 - || strcmp (target_shortname, "procfs") == 0 - || strcmp (target_shortname, "vxprocess") == 0 - || strcmp (target_shortname, "core") == 0 - || strstr (target_shortname, "-thread") != NULL) - gdb_disassemble_from_exec = 0; /* It's a child process, read inferior mem */ - else - gdb_disassemble_from_exec = 1; /* It's remote, read the exec file */ - } - - if (gdb_disassemble_from_exec) - di.read_memory_func = gdb_dis_asm_read_memory; - else - di.read_memory_func = dis_asm_read_memory; - /* Assume symtab is valid for whole PC range */ symtab = find_pc_symtab (low); @@ -389,5 +335,6 @@ do_mixed_source_and_assembly (uiout, &di, nlines, le, low, high, symtab, how_many, stb); + do_cleanups (cleanups); gdb_flush (gdb_stdout); } Index: testsuite/gdb.asm/asm-source.exp =================================================================== RCS file: /cvs/src/src/gdb/testsuite/gdb.asm/asm-source.exp,v retrieving revision 1.30 diff -u -r1.30 asm-source.exp --- testsuite/gdb.asm/asm-source.exp 21 Mar 2003 20:34:38 -0000 1.30 +++ testsuite/gdb.asm/asm-source.exp 28 Apr 2003 20:58:00 -0000 @@ -293,11 +293,35 @@ gdb_test "return" "\#0 main .*37\[ \t\]+gdbasm_exit0" "return from foo2" \ "Make (foo2|selected stack frame) return now\?.*" "y" -# See if we can look at a global variable +# Disassemble something, check the output +proc test_dis { command var } { + global gdb_prompt + send_gdb "${command}\n" + gdb_expect { + -re "${var}.*:.*Cannot access" { + # The "disassembler" was only accessing the local + # executable and that would cause attempts to disassemble + # variables to fail (memory not valid). + fail "${command} (memory read error)" + } + -re "${var}.*:.*${gdb_prompt}" { + pass "${command}" + } + timeout { + fail "${command} (timeout)" + } + } +} + +# See if we can look at a global variable, three ways gdb_test "print globalvar" ".* = 11" "look at global variable" +test_dis "x/i globalvar" "globalvar" +test_dis "disassem &globalvar &globalvar+1" "globalvar" -# See if we can look at a static variable +# See if we can look at a static variable, three ways gdb_test "print staticvar" ".* = 5" "look at static variable" +test_dis "x/i &staticvar" "staticvar" +test_dis "disassem &staticvar &staticvar+1" "staticvar" # See if we can look at a static function gdb_test "disassem foostatic" ".*:.*End of assembler dump." \