diff options
| -rw-r--r-- | gdb/ChangeLog | 23 | ||||
| -rw-r--r-- | gdb/NEWS | 7 | ||||
| -rw-r--r-- | gdb/cli/cli-cmds.c | 44 | ||||
| -rw-r--r-- | gdb/disasm.c | 404 | ||||
| -rw-r--r-- | gdb/disasm.h | 3 | ||||
| -rw-r--r-- | gdb/doc/ChangeLog | 6 | ||||
| -rw-r--r-- | gdb/doc/gdb.texinfo | 121 | ||||
| -rw-r--r-- | gdb/mi/mi-cmd-disas.c | 39 | ||||
| -rw-r--r-- | gdb/record.c | 2 | ||||
| -rw-r--r-- | gdb/testsuite/ChangeLog | 8 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.base/disasm-optim.S | 352 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.base/disasm-optim.c | 27 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.base/disasm-optim.exp | 40 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.base/disasm-optim.h | 26 | ||||
| -rw-r--r-- | gdb/testsuite/gdb.mi/mi-disassemble.exp | 2 |
15 files changed, 1045 insertions, 59 deletions
diff --git a/gdb/ChangeLog b/gdb/ChangeLog index d699070..298f44d 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,26 @@ +2015-08-14 Doug Evans <xdje42@gmail.com> + + PR gdb/11833 + * NEWS: Document new /s modifier for the disassemble command. + * cli/cli-cmds.c (disassemble_command): Add support for /s. + (_initialize_cli_cmds): Update online docs of disassemble command. + * disasm.c: #include "source.h". + (struct deprecated_dis_line_entry): Renamed from dis_line_entry. + All uses updated. + (dis_line_entry): New struct. + (hash_dis_line_entry, eq_dis_line_entry): New functions. + (allocate_dis_line_table): New functions. + (maybe_add_dis_line_entry, line_has_code_p): New functions. + (dump_insns): New arg end_pc. All callers updated. + (do_mixed_source_and_assembly_deprecated): Renamed from + do_mixed_source_and_assembly. All callers updated. + (do_mixed_source_and_assembly): New function. + (gdb_disassembly): Handle /s (DISASSEMBLY_SOURCE). + * disasm.h (DISASSEMBLY_SOURCE_DEPRECATED): Renamed from + DISASSEMBLY_SOURCE. All uses updated. + (DISASSEMBLY_SOURCE): New macro. + * mi/mi-cmd-disas.c (mi_cmd_disassemble): New modes 4,5. + 2015-08-14 Keith Seitz <keiths@redhat.com> * d-exp.y (PrimaryExpression : TypeExp '.' IdentifierExp): Rename @@ -20,6 +20,13 @@ maint show target-non-stop "set non-stop" is "off". The default is "auto", meaning non-stop mode is enabled if supported by the target. +* The "disassemble" command accepts a new modifier: /s. + It prints mixed source+disassembly like /m with two differences: + - disassembled instructions are now printed in program order, and + - and source for all relevant files is now printed. + The "/m" option is now considered deprecated: its "source-centric" + output hasn't proved useful in practice. + *** Changes in GDB 7.10 * Support for process record-replay and reverse debugging on aarch64*-linux* diff --git a/gdb/cli/cli-cmds.c b/gdb/cli/cli-cmds.c index e9664c9..bcd7802 100644 --- a/gdb/cli/cli-cmds.c +++ b/gdb/cli/cli-cmds.c @@ -1175,16 +1175,26 @@ disassemble_current_function (int flags) /* Dump a specified section of assembly code. Usage: - disassemble [/mr] + disassemble [/mrs] - dump the assembly code for the function of the current pc - disassemble [/mr] addr + disassemble [/mrs] addr - dump the assembly code for the function at ADDR - disassemble [/mr] low,high - disassemble [/mr] low,+length + disassemble [/mrs] low,high + disassemble [/mrs] low,+length - dump the assembly code in the range [LOW,HIGH), or [LOW,LOW+length) - A /m modifier will include source code with the assembly. - A /r modifier will include raw instructions in hex with the assembly. */ + A /m modifier will include source code with the assembly in a + "source centric" view. This view lists only the file of the first insn, + even if other source files are involved (e.g., inlined functions), and + the output is in source order, even with optimized code. This view is + considered deprecated as it hasn't been useful in practice. + + A /r modifier will include raw instructions in hex with the assembly. + + A /s modifier will include source code with the assembly, like /m, with + two important differences: + 1) The output is still in pc address order. + 2) File names and contents for all relevant source files are displayed. */ static void disassemble_command (char *arg, int from_tty) @@ -1212,11 +1222,14 @@ disassemble_command (char *arg, int from_tty) switch (*p++) { case 'm': - flags |= DISASSEMBLY_SOURCE; + flags |= DISASSEMBLY_SOURCE_DEPRECATED; break; case 'r': flags |= DISASSEMBLY_RAW_INSN; break; + case 's': + flags |= DISASSEMBLY_SOURCE; + break; default: error (_("Invalid disassembly modifier.")); } @@ -1225,6 +1238,10 @@ disassemble_command (char *arg, int from_tty) p = skip_spaces_const (p); } + if ((flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE)) + == (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE)) + error (_("Cannot specify both /m and /s.")); + if (! p || ! *p) { flags |= DISASSEMBLY_OMIT_FNAME; @@ -1885,8 +1902,21 @@ the other arg.")); c = add_com ("disassemble", class_vars, disassemble_command, _("\ Disassemble a specified section of memory.\n\ Default is the function surrounding the pc of the selected frame.\n\ +\n\ With a /m modifier, source lines are included (if available).\n\ +This view is \"source centric\": the output is in source line order,\n\ +regardless of any optimization that is present. Only the main source file\n\ +is displayed, not those of, e.g., any inlined functions.\n\ +This modifier hasn't proved useful in practice and is deprecated\n\ +in favor of /s.\n\ +\n\ +With a /s modifier, source lines are included (if available).\n\ +This differs from /m in two important respects:\n\ +- the output is still in pc address order, and\n\ +- file names and contents for all relevant source files are displayed.\n\ +\n\ With a /r modifier, raw instructions in hex are included.\n\ +\n\ With a single argument, the function surrounding that address is dumped.\n\ Two arguments (separated by a comma) are taken as a range of memory to dump,\n\ in the form of \"start,end\", or \"start,+length\".\n\ diff --git a/gdb/disasm.c b/gdb/disasm.c index 483df01..2b65c6a 100644 --- a/gdb/disasm.c +++ b/gdb/disasm.c @@ -24,23 +24,101 @@ #include "disasm.h" #include "gdbcore.h" #include "dis-asm.h" +#include "source.h" /* Disassemble functions. FIXME: We should get rid of all the duplicate code in gdb that does the same thing: disassemble_command() and the gdbtk variation. */ -/* This Structure is used to store line number information. +/* This structure is used to store line number information for the + deprecated /m option. We need a different sort of line table from the normal one cuz we can't depend upon implicit line-end pc's for lines to do the reordering in this function. */ -struct dis_line_entry +struct deprecated_dis_line_entry { int line; CORE_ADDR start_pc; CORE_ADDR end_pc; }; +/* This Structure is used to store line number information. + We need a different sort of line table from the normal one cuz we can't + depend upon implicit line-end pc's for lines to do the + reordering in this function. */ + +struct dis_line_entry +{ + struct symtab *symtab; + int line; +}; + +/* Hash function for dis_line_entry. */ + +static hashval_t +hash_dis_line_entry (const void *item) +{ + const struct dis_line_entry *dle = item; + + return htab_hash_pointer (dle->symtab) + dle->line; +} + +/* Equal function for dis_line_entry. */ + +static int +eq_dis_line_entry (const void *item_lhs, const void *item_rhs) +{ + const struct dis_line_entry *lhs = item_lhs; + const struct dis_line_entry *rhs = item_rhs; + + return (lhs->symtab == rhs->symtab + && lhs->line == rhs->line); +} + +/* Create the table to manage lines for mixed source/disassembly. */ + +static htab_t +allocate_dis_line_table (void) +{ + return htab_create_alloc (41, + hash_dis_line_entry, eq_dis_line_entry, + xfree, xcalloc, xfree); +} + +/* Add DLE to TABLE. + Returns 1 if added, 0 if already present. */ + +static void +maybe_add_dis_line_entry (htab_t table, struct symtab *symtab, int line) +{ + void **slot; + struct dis_line_entry dle, *dlep; + + dle.symtab = symtab; + dle.line = line; + slot = htab_find_slot (table, &dle, INSERT); + if (*slot == NULL) + { + dlep = XNEW (struct dis_line_entry); + dlep->symtab = symtab; + dlep->line = line; + *slot = dlep; + } +} + +/* Return non-zero if SYMTAB, LINE are in TABLE. */ + +static int +line_has_code_p (htab_t table, struct symtab *symtab, int line) +{ + struct dis_line_entry dle; + + dle.symtab = symtab; + dle.line = line; + return htab_find (table, &dle) != NULL; +} + /* Like target_read_memory, but slightly different parameters. */ static int dis_asm_read_memory (bfd_vma memaddr, gdb_byte *myaddr, unsigned int len, @@ -69,11 +147,11 @@ dis_asm_print_address (bfd_vma addr, struct disassemble_info *info) static int compare_lines (const void *mle1p, const void *mle2p) { - struct dis_line_entry *mle1, *mle2; + struct deprecated_dis_line_entry *mle1, *mle2; int val; - mle1 = (struct dis_line_entry *) mle1p; - mle2 = (struct dis_line_entry *) mle2p; + mle1 = (struct deprecated_dis_line_entry *) mle1p; + mle2 = (struct deprecated_dis_line_entry *) mle2p; /* End of sequence markers have a line number of 0 but don't want to be sorted to the head of the list, instead sort by PC. */ @@ -96,7 +174,8 @@ static int dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, struct disassemble_info * di, CORE_ADDR low, CORE_ADDR high, - int how_many, int flags, struct ui_file *stb) + int how_many, int flags, struct ui_file *stb, + CORE_ADDR *end_pc) { int num_displayed = 0; CORE_ADDR pc; @@ -182,24 +261,30 @@ dump_insns (struct gdbarch *gdbarch, struct ui_out *uiout, do_cleanups (ui_out_chain); ui_out_text (uiout, "\n"); } + + if (end_pc != NULL) + *end_pc = pc; return num_displayed; } /* The idea here is to present a source-O-centric view of a function to the user. This means that things are presented in source order, with (possibly) out of order assembly - immediately following. */ + immediately following. + + N.B. This view is deprecated. */ static void -do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, - struct disassemble_info *di, int nlines, - struct linetable_entry *le, - CORE_ADDR low, CORE_ADDR high, - struct symtab *symtab, - int how_many, int flags, struct ui_file *stb) +do_mixed_source_and_assembly_deprecated + (struct gdbarch *gdbarch, struct ui_out *uiout, + struct disassemble_info *di, struct symtab *symtab, + CORE_ADDR low, CORE_ADDR high, + int how_many, int flags, struct ui_file *stb) { int newlines = 0; - struct dis_line_entry *mle; + int nlines; + struct linetable_entry *le; + struct deprecated_dis_line_entry *mle; struct symtab_and_line sal; int i; int out_of_order = 0; @@ -210,11 +295,16 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, struct cleanup *ui_out_tuple_chain = make_cleanup (null_cleanup, 0); struct cleanup *ui_out_list_chain = make_cleanup (null_cleanup, 0); + gdb_assert (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL); + + nlines = SYMTAB_LINETABLE (symtab)->nitems; + le = SYMTAB_LINETABLE (symtab)->item; + if (flags & DISASSEMBLY_FILENAME) psl_flags |= PRINT_SOURCE_LINES_FILENAME; - mle = (struct dis_line_entry *) alloca (nlines - * sizeof (struct dis_line_entry)); + mle = (struct deprecated_dis_line_entry *) + alloca (nlines * sizeof (struct deprecated_dis_line_entry)); /* Copy linetable entries for this function into our data structure, creating end_pc's and setting out_of_order as @@ -255,11 +345,11 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, newlines++; } - /* Now, sort mle by line #s (and, then by addresses within - lines). */ + /* Now, sort mle by line #s (and, then by addresses within lines). */ if (out_of_order) - qsort (mle, newlines, sizeof (struct dis_line_entry), compare_lines); + qsort (mle, newlines, sizeof (struct deprecated_dis_line_entry), + compare_lines); /* Now, for each line entry, emit the specified lines (unless they have been emitted before), followed by the assembly code @@ -324,7 +414,7 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, num_displayed += dump_insns (gdbarch, uiout, di, mle[i].start_pc, mle[i].end_pc, - how_many, flags, stb); + how_many, flags, stb, NULL); /* 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. */ @@ -342,6 +432,260 @@ do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, do_cleanups (ui_out_chain); } +/* The idea here is to present a source-O-centric view of a + function to the user. This means that things are presented + in source order, with (possibly) out of order assembly + immediately following. */ + +static void +do_mixed_source_and_assembly (struct gdbarch *gdbarch, struct ui_out *uiout, + struct disassemble_info *di, + struct symtab *main_symtab, + CORE_ADDR low, CORE_ADDR high, + int how_many, int flags, struct ui_file *stb) +{ + int newlines = 0; + const struct linetable_entry *le, *first_le; + struct symtab_and_line sal; + int i, nlines; + int out_of_order = 0; + int next_line = 0; + int num_displayed = 0; + enum print_source_lines_flags psl_flags = 0; + struct cleanup *cleanups; + struct cleanup *ui_out_chain; + struct cleanup *ui_out_tuple_chain; + struct cleanup *ui_out_list_chain; + CORE_ADDR pc; + struct symtab *last_symtab; + int last_line; + htab_t dis_line_table; + + gdb_assert (main_symtab != NULL && SYMTAB_LINETABLE (main_symtab) != NULL); + + /* First pass: collect the list of all source files and lines. + We do this so that we can only print lines containing code once. + We try to print the source text leading up to the next instruction, + but if that text is for code that will be disassembled later, then + we'll want to defer printing it until later with its associated code. */ + + dis_line_table = allocate_dis_line_table (); + cleanups = make_cleanup_htab_delete (dis_line_table); + + pc = low; + + /* The prologue may be empty, but there may still be a line number entry + for the opening brace which is distinct from the first line of code. + If the prologue has been eliminated find_pc_line may return the source + line after the opening brace. We still want to print this opening brace. + first_le is used to implement this. */ + + nlines = SYMTAB_LINETABLE (main_symtab)->nitems; + le = SYMTAB_LINETABLE (main_symtab)->item; + first_le = NULL; + + /* Skip all the preceding functions. */ + for (i = 0; i < nlines && le[i].pc < low; i++) + continue; + + if (i < nlines && le[i].pc < high) + first_le = &le[i]; + + /* Add lines for every pc value. */ + while (pc < high) + { + struct symtab_and_line sal; + int length; + + sal = find_pc_line (pc, 0); + length = gdb_insn_length (gdbarch, pc); + pc += length; + + if (sal.symtab != NULL) + maybe_add_dis_line_entry (dis_line_table, sal.symtab, sal.line); + } + + /* Second pass: print the disassembly. + + Output format, from an MI perspective: + The result is a ui_out list, field name "asm_insns", where elements have + name "src_and_asm_line". + Each element is a tuple of source line specs (field names line, file, + fullname), and field "line_asm_insn" which contains the disassembly. + Field "line_asm_insn" is a list of tuples: address, func-name, offset, + opcodes, inst. + + CLI output works on top of this because MI ignores ui_out_text output, + which is where we put file name and source line contents output. + + Cleanup usage: + cleanups: + For things created at the beginning of this function and need to be + kept until the end of this function. + ui_out_chain + Handles the outer "asm_insns" list. + ui_out_tuple_chain + The tuples for each group of consecutive disassemblies. + ui_out_list_chain + List of consecutive source lines or disassembled insns. */ + + if (flags & DISASSEMBLY_FILENAME) + psl_flags |= PRINT_SOURCE_LINES_FILENAME; + + ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); + + ui_out_tuple_chain = NULL; + ui_out_list_chain = NULL; + + last_symtab = NULL; + last_line = 0; + pc = low; + + while (pc < high) + { + struct linetable_entry *le = NULL; + struct symtab_and_line sal; + CORE_ADDR end_pc; + int start_preceding_line_to_display = 0; + int end_preceding_line_to_display = 0; + int new_source_line = 0; + + sal = find_pc_line (pc, 0); + + if (sal.symtab != last_symtab) + { + /* New source file. */ + new_source_line = 1; + + /* If this is the first line of output, check for any preceding + lines. */ + if (last_line == 0 + && first_le != NULL + && first_le->line < sal.line) + { + start_preceding_line_to_display = first_le->line; + end_preceding_line_to_display = sal.line; + } + } + else + { + /* Same source file as last time. */ + if (sal.symtab != NULL) + { + if (sal.line > last_line + 1 && last_line != 0) + { + int l; + + /* Several preceding source lines. Print the trailing ones + not associated with code that we'll print later. */ + for (l = sal.line - 1; l > last_line; --l) + { + if (line_has_code_p (dis_line_table, sal.symtab, l)) + break; + } + if (l < sal.line - 1) + { + start_preceding_line_to_display = l + 1; + end_preceding_line_to_display = sal.line; + } + } + if (sal.line != last_line) + new_source_line = 1; + else + { + /* Same source line as last time. This can happen, depending + on the debug info. */ + } + } + } + + if (new_source_line) + { + /* Skip the newline if this is the first instruction. */ + if (pc > low) + ui_out_text (uiout, "\n"); + if (ui_out_tuple_chain != NULL) + { + gdb_assert (ui_out_list_chain != NULL); + do_cleanups (ui_out_list_chain); + do_cleanups (ui_out_tuple_chain); + } + if (sal.symtab != last_symtab + && !(flags & DISASSEMBLY_FILENAME)) + { + /* Remember MI ignores ui_out_text. + We don't have to do anything here for MI because MI + output includes the source specs for each line. */ + if (sal.symtab != NULL) + { + ui_out_text (uiout, + symtab_to_filename_for_display (sal.symtab)); + } + else + ui_out_text (uiout, "unknown"); + ui_out_text (uiout, ":\n"); + } + if (start_preceding_line_to_display > 0) + { + /* Several source lines w/o asm instructions associated. + We need to preserve the structure of the output, so output + a bunch of line tuples with no asm entries. */ + int l; + struct cleanup *ui_out_list_chain_line; + struct cleanup *ui_out_tuple_chain_line; + + gdb_assert (sal.symtab != NULL); + for (l = start_preceding_line_to_display; + l < end_preceding_line_to_display; + ++l) + { + ui_out_tuple_chain_line + = make_cleanup_ui_out_tuple_begin_end (uiout, + "src_and_asm_line"); + print_source_lines (sal.symtab, l, l + 1, psl_flags); + ui_out_list_chain_line + = make_cleanup_ui_out_list_begin_end (uiout, + "line_asm_insn"); + do_cleanups (ui_out_list_chain_line); + do_cleanups (ui_out_tuple_chain_line); + } + } + ui_out_tuple_chain + = make_cleanup_ui_out_tuple_begin_end (uiout, "src_and_asm_line"); + if (sal.symtab != NULL) + print_source_lines (sal.symtab, sal.line, sal.line + 1, psl_flags); + else + ui_out_text (uiout, _("--- no source info for this pc ---\n")); + ui_out_list_chain + = make_cleanup_ui_out_list_begin_end (uiout, "line_asm_insn"); + } + else + { + /* Here we're appending instructions to an existing line. + By construction the very first insn will have a symtab + and follow the new_source_line path above. */ + gdb_assert (ui_out_tuple_chain != NULL); + gdb_assert (ui_out_list_chain != NULL); + } + + if (sal.end != 0) + end_pc = min (sal.end, high); + else + end_pc = pc + 1; + num_displayed += dump_insns (gdbarch, uiout, di, pc, end_pc, + how_many, flags, stb, &end_pc); + pc = end_pc; + + if (how_many >= 0 && num_displayed >= how_many) + break; + + last_symtab = sal.symtab; + last_line = sal.line; + } + + do_cleanups (ui_out_chain); + do_cleanups (cleanups); +} static void do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout, @@ -355,7 +699,7 @@ do_assembly_only (struct gdbarch *gdbarch, struct ui_out *uiout, ui_out_chain = make_cleanup_ui_out_list_begin_end (uiout, "asm_insns"); num_displayed = dump_insns (gdbarch, uiout, di, low, high, how_many, - flags, stb); + flags, stb, NULL); do_cleanups (ui_out_chain); } @@ -418,19 +762,19 @@ gdb_disassembly (struct gdbarch *gdbarch, struct ui_out *uiout, symtab = find_pc_line_symtab (low); if (symtab != NULL && SYMTAB_LINETABLE (symtab) != NULL) - { - /* Convert the linetable to a bunch of my_line_entry's. */ - le = SYMTAB_LINETABLE (symtab)->item; - nlines = SYMTAB_LINETABLE (symtab)->nitems; - } + nlines = SYMTAB_LINETABLE (symtab)->nitems; - if (!(flags & DISASSEMBLY_SOURCE) || nlines <= 0 - || symtab == NULL || SYMTAB_LINETABLE (symtab) == NULL) + if (!(flags & (DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_SOURCE)) + || nlines <= 0) do_assembly_only (gdbarch, uiout, &di, low, high, how_many, flags, stb); else if (flags & DISASSEMBLY_SOURCE) - do_mixed_source_and_assembly (gdbarch, uiout, &di, nlines, le, low, - high, symtab, how_many, flags, stb); + do_mixed_source_and_assembly (gdbarch, uiout, &di, symtab, low, high, + how_many, flags, stb); + + else if (flags & DISASSEMBLY_SOURCE_DEPRECATED) + do_mixed_source_and_assembly_deprecated (gdbarch, uiout, &di, symtab, + low, high, how_many, flags, stb); do_cleanups (cleanups); gdb_flush (gdb_stdout); diff --git a/gdb/disasm.h b/gdb/disasm.h index a91211e..7e6f1a2 100644 --- a/gdb/disasm.h +++ b/gdb/disasm.h @@ -21,11 +21,12 @@ #include "dis-asm.h" -#define DISASSEMBLY_SOURCE (0x1 << 0) +#define DISASSEMBLY_SOURCE_DEPRECATED (0x1 << 0) #define DISASSEMBLY_RAW_INSN (0x1 << 1) #define DISASSEMBLY_OMIT_FNAME (0x1 << 2) #define DISASSEMBLY_FILENAME (0x1 << 3) #define DISASSEMBLY_OMIT_PC (0x1 << 4) +#define DISASSEMBLY_SOURCE (0x1 << 5) struct gdbarch; struct ui_out; diff --git a/gdb/doc/ChangeLog b/gdb/doc/ChangeLog index 5b3d9a1..806dac4 100644 --- a/gdb/doc/ChangeLog +++ b/gdb/doc/ChangeLog @@ -1,3 +1,9 @@ +2015-08-14 Doug Evans <xdje42@gmail.com> + + * gdb.texinfo (Machine Code): Update docs for mixed source/assembly + disassembly. + (GDB/MI Data Manipulation): Update docs for new disassembly modes. + 2015-08-11 Keith Seitz <keiths@redhat.com> * gdb.texinfo (Thread-Specific Breakpoints, Printing Source Lines): diff --git a/gdb/doc/gdb.texinfo b/gdb/doc/gdb.texinfo index c64c7a1..c876ed6 100644 --- a/gdb/doc/gdb.texinfo +++ b/gdb/doc/gdb.texinfo @@ -8098,11 +8098,12 @@ Variables}). @cindex listing machine instructions @item disassemble @itemx disassemble /m +@itemx disassemble /s @itemx disassemble /r This specialized command dumps a range of memory as machine instructions. It can also print mixed source+disassembly by specifying -the @code{/m} modifier and print the raw instructions in hex as well as -in symbolic form by specifying the @code{/r}. +the @code{/m} or @code{/s} modifier and print the raw instructions in hex +as well as in symbolic form by specifying the @code{/r} modifier. 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 @@ -8146,8 +8147,9 @@ Dump of assembler code from 0x32c4 to 0x32e4: End of assembler dump. @end smallexample -Here is an example showing mixed source+assembly for Intel x86, when the -program is stopped just after function prologue: +Here is an example showing mixed source+assembly for Intel x86 +with @code{/m} or @code{/s}, when the program is stopped just after +function prologue in a non-optimized function with no inline code. @smallexample (@value{GDBP}) disas /m main @@ -8172,6 +8174,96 @@ Dump of assembler code for function main: End of assembler dump. @end smallexample +The @code{/m} option is deprecated as its output is not useful when +there is either inlined code or re-ordered code. +The @code{/s} option is the preferred choice. +Here is an example for AMD x86-64 showing the difference between +@code{/m} output and @code{/s} output. +This example has one inline function defined in a header file, +and the code is compiled with @samp{-O2} optimization. +Note how the @code{/m} output is missing the disassembly of +several instructions that are present in the @code{/s} output. + +@file{foo.h}: + +@smallexample +int +foo (int a) +@{ + if (a < 0) + return a * 2; + if (a == 0) + return 1; + return a + 10; +@} +@end smallexample + +@file{foo.c}: + +@smallexample +#include "foo.h" +volatile int x, y; +int +main () +@{ + x = foo (y); + return 0; +@} +@end smallexample + +@smallexample +(@value{GDBP}) disas /m main +Dump of assembler code for function main: +5 @{ + +6 x = foo (y); + 0x0000000000400400 <+0>: mov 0x200c2e(%rip),%eax # 0x601034 <y> + 0x0000000000400417 <+23>: mov %eax,0x200c13(%rip) # 0x601030 <x> + +7 return 0; +8 @} + 0x000000000040041d <+29>: xor %eax,%eax + 0x000000000040041f <+31>: retq + 0x0000000000400420 <+32>: add %eax,%eax + 0x0000000000400422 <+34>: jmp 0x400417 <main+23> + +End of assembler dump. +(@value{GDBP}) disas /s main +Dump of assembler code for function main: +foo.c: +5 @{ +6 x = foo (y); + 0x0000000000400400 <+0>: mov 0x200c2e(%rip),%eax # 0x601034 <y> + +foo.h: +4 if (a < 0) + 0x0000000000400406 <+6>: test %eax,%eax + 0x0000000000400408 <+8>: js 0x400420 <main+32> + +6 if (a == 0) +7 return 1; +8 return a + 10; + 0x000000000040040a <+10>: lea 0xa(%rax),%edx + 0x000000000040040d <+13>: test %eax,%eax + 0x000000000040040f <+15>: mov $0x1,%eax + 0x0000000000400414 <+20>: cmovne %edx,%eax + +foo.c: +6 x = foo (y); + 0x0000000000400417 <+23>: mov %eax,0x200c13(%rip) # 0x601030 <x> + +7 return 0; +8 @} + 0x000000000040041d <+29>: xor %eax,%eax + 0x000000000040041f <+31>: retq + +foo.h: +5 return a * 2; + 0x0000000000400420 <+32>: add %eax,%eax + 0x0000000000400422 <+34>: jmp 0x400417 <main+23> +End of assembler dump. +@end smallexample + Here is another example showing raw instructions in hex for AMD x86-64, @smallexample @@ -29782,9 +29874,20 @@ displayed; if @var{lines} is higher than the number of lines between @var{start-addr} and @var{end-addr}, only the lines up to @var{end-addr} are displayed. @item @var{mode} -is either 0 (meaning only disassembly), 1 (meaning mixed source and -disassembly), 2 (meaning disassembly with raw opcodes), or 3 (meaning -mixed source and disassembly with raw opcodes). +is one of: +@itemize @bullet +@item 0 disassembly only +@item 1 mixed source and disassembly (deprecated) +@item 2 disassembly with raw opcodes +@item 3 mixed source and disassembly with raw opcodes (deprecated) +@item 4 mixed source and disassembly +@item 5 mixed source and disassembly with raw opcodes +@end itemize + +Modes 1 and 3 are deprecated. The output is ``source centric'' +which hasn't proved useful in practice. +@xref{Machine Code}, for a discussion of the difference between +@code{/m} and @code{/s} output of the @code{disassemble} command. @end table @subsubheading Result @@ -29810,12 +29913,12 @@ The decimal offset in bytes from the start of @samp{func-name}. The text disassembly for this @samp{address}. @item opcodes -This field is only present for mode 2. This contains the raw opcode +This field is only present for modes 2, 3 and 5. This contains the raw opcode bytes for the @samp{inst} field. @end table -For modes 1 and 3 the @samp{asm_insns} list contains tuples named +For modes 1, 3, 4 and 5 the @samp{asm_insns} list contains tuples named @samp{src_and_asm_line}, each of which has the following fields: @table @code diff --git a/gdb/mi/mi-cmd-disas.c b/gdb/mi/mi-cmd-disas.c index 01cad2d..250124d 100644 --- a/gdb/mi/mi-cmd-disas.c +++ b/gdb/mi/mi-cmd-disas.c @@ -44,10 +44,11 @@ always required: MODE: 0 -- disassembly. - 1 -- disassembly and source. + 1 -- disassembly and source (with deprecated source-centric view). 2 -- disassembly and opcodes. - 3 -- disassembly, source and opcodes. -*/ + 3 -- disassembly, source-centric and opcodes. + 4 -- disassembly, and source (with pc-centric view). + 5 -- disassembly, source (pc-centric) and opcodes. */ void mi_cmd_disassemble (char *command, char **argv, int argc) @@ -141,16 +142,34 @@ mi_cmd_disassemble (char *command, char **argv, int argc) "[-n howmany]] [-s startaddr -e endaddr] [--] mode.")); mode = atoi (argv[0]); - if (mode < 0 || mode > 3) - error (_("-data-disassemble: Mode argument must be 0, 1, 2, or 3.")); + if (mode < 0 || mode > 5) + error (_("-data-disassemble: Mode argument must be in the range 0-5.")); /* Convert the mode into a set of disassembly flags. */ - disasm_flags = 0; - if (mode & 0x1) - disasm_flags |= DISASSEMBLY_SOURCE; - if (mode & 0x2) - disasm_flags |= DISASSEMBLY_RAW_INSN; + disasm_flags = 0; /* Initialize here for -Wall. */ + switch (mode) + { + case 0: + break; + case 1: + disasm_flags |= DISASSEMBLY_SOURCE_DEPRECATED; + break; + case 2: + disasm_flags |= DISASSEMBLY_RAW_INSN; + break; + case 3: + disasm_flags |= DISASSEMBLY_SOURCE_DEPRECATED | DISASSEMBLY_RAW_INSN; + break; + case 4: + disasm_flags |= DISASSEMBLY_SOURCE; + break; + case 5: + disasm_flags |= DISASSEMBLY_SOURCE | DISASSEMBLY_RAW_INSN; + break; + default: + gdb_assert_not_reached ("bad disassembly mode"); + } /* We must get the function beginning and end where line_num is contained. */ diff --git a/gdb/record.c b/gdb/record.c index a64543a..ad83a29 100644 --- a/gdb/record.c +++ b/gdb/record.c @@ -458,7 +458,7 @@ get_insn_history_modifiers (char **arg) switch (*args) { case 'm': - modifiers |= DISASSEMBLY_SOURCE; + modifiers |= DISASSEMBLY_SOURCE_DEPRECATED; modifiers |= DISASSEMBLY_FILENAME; break; case 'r': diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog index 71989e7..3deb8a4 100644 --- a/gdb/testsuite/ChangeLog +++ b/gdb/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2015-08-14 Doug Evans <xdje42@gmail.com> + + * gdb.mi/mi-disassemble.exp: Update. + * gdb.base/disasm-optim.S: New file. + * gdb.base/disasm-optim.c: New file. + * gdb.base/disasm-optim.h: New file. + * gdb.base/disasm-optim.exp: New file. + 2015-08-14 Keith Seitz <keiths@redhat.com> * lib/mi-support.exp (mi_make_breakpoint): Add option/handling for diff --git a/gdb/testsuite/gdb.base/disasm-optim.S b/gdb/testsuite/gdb.base/disasm-optim.S new file mode 100644 index 0000000..0856731 --- /dev/null +++ b/gdb/testsuite/gdb.base/disasm-optim.S @@ -0,0 +1,352 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright (C) 2015 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. + + This file was created with gcc -O2 -g -S -fverbose-asm -dA disasm-optim.c + and then cleaning up the output. */ + + .file "disasm-optim.c" + + .text + .p2align 4,,15 + .globl main + .type main, @function +main: +.LFB1: + .file 1 "disasm-optim.c" + # disasm-optim.c:24 + .loc 1 24 0 + .cfi_startproc + # disasm-optim.c:25 + .loc 1 25 0 + movl y(%rip), %eax +.LVL0: +.LBB4: +.LBB5: + .file 2 "disasm-optim.h" + # disasm-optim.h:21 + .loc 2 21 0 + testl %eax, %eax + js .L6 + # disasm-optim.h:25 + .loc 2 25 0 + leal 10(%rax), %edx + testl %eax, %eax + movl $1, %eax +.LVL1: + cmovne %edx, %eax +.LVL2: +.L3: +.LBE5: +.LBE4: + # disasm-optim.c:25 + .loc 1 25 0 + movl %eax, x(%rip) + # disasm-optim.c:27 + .loc 1 27 0 + xorl %eax, %eax + ret +.LVL3: +.L6: +.LBB7: +.LBB6: + # disasm-optim.h:22 + .loc 2 22 0 + addl %eax, %eax +.LVL4: + jmp .L3 +.LBE6: +.LBE7: + .cfi_endproc +.LFE1: + .size main, .-main + .comm y,4,4 + .comm x,4,4 + .text +.Letext0: + .section .debug_info,"",@progbits +.Ldebug_info0: + .long 0xb1 # Length of Compilation Unit Info + .value 0x4 # DWARF version number + .long .Ldebug_abbrev0 # Offset Into Abbrev. Section + .byte 0x8 # Pointer Size (in bytes) + .uleb128 0x1 # (DIE (0xb) DW_TAG_compile_unit) + .long .LASF0 # DW_AT_producer: "GNU C 4.9.2 20150212 (Red Hat 4.9.2-6) -mtune=generic -march=x86-64 -g -O2" + .byte 0x1 # DW_AT_language + .long .LASF1 # DW_AT_name: "disasm-optim.c" + .long .LASF2 # DW_AT_comp_dir: "/main/disassemble3/gdb/testsuite/gdb.base" + .long .Ldebug_ranges0+0x30 # DW_AT_ranges + .quad 0 # DW_AT_low_pc + .long .Ldebug_line0 # DW_AT_stmt_list + .uleb128 0x2 # (DIE (0x29) DW_TAG_subprogram) + # DW_AT_external + .ascii "foo\0" # DW_AT_name + .byte 0x2 # DW_AT_decl_file (disasm-optim.h) + .byte 0x13 # DW_AT_decl_line + # DW_AT_prototyped + .long 0x43 # DW_AT_type + .byte 0x3 # DW_AT_inline + .long 0x43 # DW_AT_sibling + .uleb128 0x3 # (DIE (0x39) DW_TAG_formal_parameter) + .ascii "a\0" # DW_AT_name + .byte 0x2 # DW_AT_decl_file (disasm-optim.h) + .byte 0x13 # DW_AT_decl_line + .long 0x43 # DW_AT_type + .byte 0 # end of children of DIE 0x29 + .uleb128 0x4 # (DIE (0x43) DW_TAG_base_type) + .byte 0x4 # DW_AT_byte_size + .byte 0x5 # DW_AT_encoding + .ascii "int\0" # DW_AT_name + .uleb128 0x5 # (DIE (0x4a) DW_TAG_subprogram) + # DW_AT_external + .long .LASF3 # DW_AT_name: "main" + .byte 0x1 # DW_AT_decl_file (disasm-optim.c) + .byte 0x17 # DW_AT_decl_line + .long 0x43 # DW_AT_type + .quad .LFB1 # DW_AT_low_pc + .quad .LFE1-.LFB1 # DW_AT_high_pc + .uleb128 0x1 # DW_AT_frame_base + .byte 0x9c # DW_OP_call_frame_cfa + # DW_AT_GNU_all_call_sites + .long 0x89 # DW_AT_sibling + .uleb128 0x6 # (DIE (0x6b) DW_TAG_inlined_subroutine) + .long 0x29 # DW_AT_abstract_origin + .quad .LBB4 # DW_AT_entry_pc + .long .Ldebug_ranges0+0 # DW_AT_ranges + .byte 0x1 # DW_AT_call_file (disasm-optim.c) + .byte 0x19 # DW_AT_call_line + .uleb128 0x7 # (DIE (0x7e) DW_TAG_formal_parameter) + .long 0x39 # DW_AT_abstract_origin + .long .LLST0 # DW_AT_location + .byte 0 # end of children of DIE 0x6b + .byte 0 # end of children of DIE 0x4a + .uleb128 0x8 # (DIE (0x89) DW_TAG_variable) + .ascii "x\0" # DW_AT_name + .byte 0x1 # DW_AT_decl_file (disasm-optim.c) + .byte 0x14 # DW_AT_decl_line + .long 0x9c # DW_AT_type + # DW_AT_external + .uleb128 0x9 # DW_AT_location + .byte 0x3 # DW_OP_addr + .quad x + .uleb128 0x9 # (DIE (0x9c) DW_TAG_volatile_type) + .long 0x43 # DW_AT_type + .uleb128 0x8 # (DIE (0xa1) DW_TAG_variable) + .ascii "y\0" # DW_AT_name + .byte 0x1 # DW_AT_decl_file (disasm-optim.c) + .byte 0x14 # DW_AT_decl_line + .long 0x9c # DW_AT_type + # DW_AT_external + .uleb128 0x9 # DW_AT_location + .byte 0x3 # DW_OP_addr + .quad y + .byte 0 # end of children of DIE 0xb + .section .debug_abbrev,"",@progbits +.Ldebug_abbrev0: + .uleb128 0x1 # (abbrev code) + .uleb128 0x11 # (TAG: DW_TAG_compile_unit) + .byte 0x1 # DW_children_yes + .uleb128 0x25 # (DW_AT_producer) + .uleb128 0xe # (DW_FORM_strp) + .uleb128 0x13 # (DW_AT_language) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3 # (DW_AT_name) + .uleb128 0xe # (DW_FORM_strp) + .uleb128 0x1b # (DW_AT_comp_dir) + .uleb128 0xe # (DW_FORM_strp) + .uleb128 0x55 # (DW_AT_ranges) + .uleb128 0x17 # (DW_FORM_sec_offset) + .uleb128 0x11 # (DW_AT_low_pc) + .uleb128 0x1 # (DW_FORM_addr) + .uleb128 0x10 # (DW_AT_stmt_list) + .uleb128 0x17 # (DW_FORM_sec_offset) + .byte 0 + .byte 0 + .uleb128 0x2 # (abbrev code) + .uleb128 0x2e # (TAG: DW_TAG_subprogram) + .byte 0x1 # DW_children_yes + .uleb128 0x3f # (DW_AT_external) + .uleb128 0x19 # (DW_FORM_flag_present) + .uleb128 0x3 # (DW_AT_name) + .uleb128 0x8 # (DW_FORM_string) + .uleb128 0x3a # (DW_AT_decl_file) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3b # (DW_AT_decl_line) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x27 # (DW_AT_prototyped) + .uleb128 0x19 # (DW_FORM_flag_present) + .uleb128 0x49 # (DW_AT_type) + .uleb128 0x13 # (DW_FORM_ref4) + .uleb128 0x20 # (DW_AT_inline) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x1 # (DW_AT_sibling) + .uleb128 0x13 # (DW_FORM_ref4) + .byte 0 + .byte 0 + .uleb128 0x3 # (abbrev code) + .uleb128 0x5 # (TAG: DW_TAG_formal_parameter) + .byte 0 # DW_children_no + .uleb128 0x3 # (DW_AT_name) + .uleb128 0x8 # (DW_FORM_string) + .uleb128 0x3a # (DW_AT_decl_file) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3b # (DW_AT_decl_line) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x49 # (DW_AT_type) + .uleb128 0x13 # (DW_FORM_ref4) + .byte 0 + .byte 0 + .uleb128 0x4 # (abbrev code) + .uleb128 0x24 # (TAG: DW_TAG_base_type) + .byte 0 # DW_children_no + .uleb128 0xb # (DW_AT_byte_size) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3e # (DW_AT_encoding) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3 # (DW_AT_name) + .uleb128 0x8 # (DW_FORM_string) + .byte 0 + .byte 0 + .uleb128 0x5 # (abbrev code) + .uleb128 0x2e # (TAG: DW_TAG_subprogram) + .byte 0x1 # DW_children_yes + .uleb128 0x3f # (DW_AT_external) + .uleb128 0x19 # (DW_FORM_flag_present) + .uleb128 0x3 # (DW_AT_name) + .uleb128 0xe # (DW_FORM_strp) + .uleb128 0x3a # (DW_AT_decl_file) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3b # (DW_AT_decl_line) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x49 # (DW_AT_type) + .uleb128 0x13 # (DW_FORM_ref4) + .uleb128 0x11 # (DW_AT_low_pc) + .uleb128 0x1 # (DW_FORM_addr) + .uleb128 0x12 # (DW_AT_high_pc) + .uleb128 0x7 # (DW_FORM_data8) + .uleb128 0x40 # (DW_AT_frame_base) + .uleb128 0x18 # (DW_FORM_exprloc) + .uleb128 0x2117 # (DW_AT_GNU_all_call_sites) + .uleb128 0x19 # (DW_FORM_flag_present) + .uleb128 0x1 # (DW_AT_sibling) + .uleb128 0x13 # (DW_FORM_ref4) + .byte 0 + .byte 0 + .uleb128 0x6 # (abbrev code) + .uleb128 0x1d # (TAG: DW_TAG_inlined_subroutine) + .byte 0x1 # DW_children_yes + .uleb128 0x31 # (DW_AT_abstract_origin) + .uleb128 0x13 # (DW_FORM_ref4) + .uleb128 0x52 # (DW_AT_entry_pc) + .uleb128 0x1 # (DW_FORM_addr) + .uleb128 0x55 # (DW_AT_ranges) + .uleb128 0x17 # (DW_FORM_sec_offset) + .uleb128 0x58 # (DW_AT_call_file) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x59 # (DW_AT_call_line) + .uleb128 0xb # (DW_FORM_data1) + .byte 0 + .byte 0 + .uleb128 0x7 # (abbrev code) + .uleb128 0x5 # (TAG: DW_TAG_formal_parameter) + .byte 0 # DW_children_no + .uleb128 0x31 # (DW_AT_abstract_origin) + .uleb128 0x13 # (DW_FORM_ref4) + .uleb128 0x2 # (DW_AT_location) + .uleb128 0x17 # (DW_FORM_sec_offset) + .byte 0 + .byte 0 + .uleb128 0x8 # (abbrev code) + .uleb128 0x34 # (TAG: DW_TAG_variable) + .byte 0 # DW_children_no + .uleb128 0x3 # (DW_AT_name) + .uleb128 0x8 # (DW_FORM_string) + .uleb128 0x3a # (DW_AT_decl_file) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x3b # (DW_AT_decl_line) + .uleb128 0xb # (DW_FORM_data1) + .uleb128 0x49 # (DW_AT_type) + .uleb128 0x13 # (DW_FORM_ref4) + .uleb128 0x3f # (DW_AT_external) + .uleb128 0x19 # (DW_FORM_flag_present) + .uleb128 0x2 # (DW_AT_location) + .uleb128 0x18 # (DW_FORM_exprloc) + .byte 0 + .byte 0 + .uleb128 0x9 # (abbrev code) + .uleb128 0x35 # (TAG: DW_TAG_volatile_type) + .byte 0 # DW_children_no + .uleb128 0x49 # (DW_AT_type) + .uleb128 0x13 # (DW_FORM_ref4) + .byte 0 + .byte 0 + .byte 0 + .section .debug_loc,"",@progbits +.Ldebug_loc0: +.LLST0: + .quad .LVL0 # Location list begin address (*.LLST0) + .quad .LVL1 # Location list end address (*.LLST0) + .value 0x1 # Location expression size + .byte 0x50 # DW_OP_reg0 + .quad .LVL1 # Location list begin address (*.LLST0) + .quad .LVL2 # Location list end address (*.LLST0) + .value 0x3 # Location expression size + .byte 0x71 # DW_OP_breg1 + .sleb128 -10 + .byte 0x9f # DW_OP_stack_value + .quad .LVL3 # Location list begin address (*.LLST0) + .quad .LVL4 # Location list end address (*.LLST0) + .value 0x1 # Location expression size + .byte 0x50 # DW_OP_reg0 + .quad 0 # Location list terminator begin (*.LLST0) + .quad 0 # Location list terminator end (*.LLST0) + .section .debug_aranges,"",@progbits + .long 0x2c # Length of Address Ranges Info + .value 0x2 # DWARF Version + .long .Ldebug_info0 # Offset of Compilation Unit Info + .byte 0x8 # Size of Address + .byte 0 # Size of Segment Descriptor + .value 0 # Pad to 16 byte boundary + .value 0 + .quad .LFB1 # Address + .quad .LFE1-.LFB1 # Length + .quad 0 + .quad 0 + .section .debug_ranges,"",@progbits +.Ldebug_ranges0: + .quad .LBB4 # Offset 0 + .quad .LBE4 + .quad .LBB7 + .quad .LBE7 + .quad 0 + .quad 0 + .quad .LFB1 # Offset 0x30 + .quad .LFE1 + .quad 0 + .quad 0 + .section .debug_line,"",@progbits +.Ldebug_line0: + .section .debug_str,"MS",@progbits,1 +.LASF2: + .string "/main/disassemble3/gdb/testsuite/gdb.base" +.LASF1: + .string "disasm-optim.c" +.LASF3: + .string "main" +.LASF0: + .string "GNU C 4.9.2 20150212 (Red Hat 4.9.2-6) -mtune=generic -march=x86-64 -g -O2" + .ident "GCC: (GNU) 4.9.2 20150212 (Red Hat 4.9.2-6)" + .section .note.GNU-stack,"",@progbits diff --git a/gdb/testsuite/gdb.base/disasm-optim.c b/gdb/testsuite/gdb.base/disasm-optim.c new file mode 100644 index 0000000..710c8a7 --- /dev/null +++ b/gdb/testsuite/gdb.base/disasm-optim.c @@ -0,0 +1,27 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright (C) 2015 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +#include "disasm-optim.h" + +volatile int x, y; + +int +main () +{ + x = foo (y); + return 0; +} diff --git a/gdb/testsuite/gdb.base/disasm-optim.exp b/gdb/testsuite/gdb.base/disasm-optim.exp new file mode 100644 index 0000000..ef6b7be --- /dev/null +++ b/gdb/testsuite/gdb.base/disasm-optim.exp @@ -0,0 +1,40 @@ +# Copyright (C) 2015 Free Software Foundation, Inc. + +# This program is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 3 of the License, or +# (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +# This test exercises disassemble /s with optimized and inlined code. + +if { ![istarget "x86_64-*-linux*"] } { + continue +} + +standard_testfile .S + +if { [prepare_for_testing ${testfile}.exp $testfile ${testfile}.S {nodebug}] } { + return -1 +} + +if ![runto_main] { + return -1 +} + +gdb_test_sequence "disassemble /s main" \ + "Disassemble main with source" { + "Dump of assembler code for function main:" + "disasm-optim\\.c:\r\n24" + "disasm-optim\\.h:\r\n21" + "disasm-optim\\.c:\r\n25" + "disasm-optim\\.h:\r\n22" + "End of assembler dump\\." + } diff --git a/gdb/testsuite/gdb.base/disasm-optim.h b/gdb/testsuite/gdb.base/disasm-optim.h new file mode 100644 index 0000000..8229d13 --- /dev/null +++ b/gdb/testsuite/gdb.base/disasm-optim.h @@ -0,0 +1,26 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright (C) 2015 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. */ + +extern inline int +foo (int a) +{ + if (a < 0) + return a * 2; + if (a == 0) + return 1; + return a + 10; +} diff --git a/gdb/testsuite/gdb.mi/mi-disassemble.exp b/gdb/testsuite/gdb.mi/mi-disassemble.exp index 4f5a352..f97c471 100644 --- a/gdb/testsuite/gdb.mi/mi-disassemble.exp +++ b/gdb/testsuite/gdb.mi/mi-disassemble.exp @@ -223,7 +223,7 @@ proc test_disassembly_bogus_args {} { "data-disassemble mix different args" mi_gdb_test "789-data-disassemble -f basics.c -l $line_main_body -- 9" \ - "789\\^error,msg=\"-data-disassemble: Mode argument must be 0, 1, 2, or 3.\"" \ + "789\\^error,msg=\"-data-disassemble: Mode argument must be in the range 0-5.\"" \ "data-disassemble wrong mode arg" } |