X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=gdb%2Fstack.c;h=53d4aebb85809749950e533fe0ac4ea3f0f21a8c;hb=2c58c0a9a5952b35ae2fe707bebb88ed36ab0b09;hp=caf23a4c03103ca6a65b91a89978bfffebb98d4a;hpb=123680036c40f8ed10bbdf9da800e71b48b3a4fc;p=platform%2Fupstream%2Fbinutils.git diff --git a/gdb/stack.c b/gdb/stack.c index caf23a4..53d4aeb 100644 --- a/gdb/stack.c +++ b/gdb/stack.c @@ -1,8 +1,8 @@ /* Print and select stack frames for GDB, the GNU debugger. Copyright (C) 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, - 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007 - Free Software Foundation, Inc. + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, + 2009, 2010 Free Software Foundation, Inc. This file is part of GDB. @@ -43,11 +43,18 @@ #include "regcache.h" #include "solib.h" #include "valprint.h" +#include "gdbthread.h" +#include "cp-support.h" +#include "disasm.h" +#include "inline-frame.h" #include "gdb_assert.h" #include #include "gdb_string.h" +#include "psymtab.h" +#include "symfile.h" + void (*deprecated_selected_frame_level_changed_hook) (int); /* The possible choices of "set print frame-arguments, and the value @@ -55,7 +62,7 @@ void (*deprecated_selected_frame_level_changed_hook) (int); static const char *print_frame_arguments_choices[] = {"all", "scalars", "none", NULL}; -static const char *print_frame_arguments = "all"; +static const char *print_frame_arguments = "scalars"; /* Prototypes for local functions. */ @@ -96,6 +103,30 @@ print_stack_frame_stub (void *args) return 0; } +/* Return 1 if we should display the address in addition to the location, + because we are in the middle of a statement. */ + +static int +frame_show_address (struct frame_info *frame, + struct symtab_and_line sal) +{ + /* If there is a line number, but no PC, then there is no location + information associated with this sal. The only way that should + happen is for the call sites of inlined functions (SAL comes from + find_frame_sal). Otherwise, we would have some PC range if the + SAL came from a line table. */ + if (sal.line != 0 && sal.pc == 0 && sal.end == 0) + { + if (get_next_frame (frame) == NULL) + gdb_assert (inline_skipped_frames (inferior_ptid) > 0); + else + gdb_assert (get_frame_type (get_next_frame (frame)) == INLINE_FRAME); + return 0; + } + + return get_frame_pc (frame) != sal.pc; +} + /* Show or print a stack frame FRAME briefly. The output is format according to PRINT_LEVEL and PRINT_WHAT printing the frame's relative level, function name, argument list, and file name and @@ -115,7 +146,7 @@ print_stack_frame (struct frame_info *frame, int print_level, args.print_what = ui_out_is_mi_like_p (uiout) ? LOC_AND_ADDRESS : print_what; args.print_args = 1; - catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ALL); + catch_errors (print_stack_frame_stub, &args, "", RETURN_MASK_ERROR); } struct print_args_args @@ -136,6 +167,8 @@ static void print_frame_nameless_args (struct frame_info *frame, long start, int num, int first, struct ui_file *stream) { + struct gdbarch *gdbarch = get_frame_arch (frame); + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); int i; CORE_ADDR argsaddr; long arg_value; @@ -146,7 +179,8 @@ print_frame_nameless_args (struct frame_info *frame, long start, int num, argsaddr = get_frame_args_address (frame); if (!argsaddr) return; - arg_value = read_memory_integer (argsaddr + start, sizeof (int)); + arg_value = read_memory_integer (argsaddr + start, + sizeof (int), byte_order); if (!first) fprintf_filtered (stream, ", "); fprintf_filtered (stream, "%ld", arg_value); @@ -155,54 +189,14 @@ print_frame_nameless_args (struct frame_info *frame, long start, int num, } } -/* Return non-zero if the debugger should print the value of the provided - symbol parameter (SYM). */ - -static int -print_this_frame_argument_p (struct symbol *sym) -{ - struct type *type; - - /* If the user asked to print no argument at all, then obviously - do not print this argument. */ - - if (strcmp (print_frame_arguments, "none") == 0) - return 0; - - /* If the user asked to print all arguments, then we should print - that one. */ - - if (strcmp (print_frame_arguments, "all") == 0) - return 1; - - /* The user asked to print only the scalar arguments, so do not - print the non-scalar ones. */ - - type = CHECK_TYPEDEF (SYMBOL_TYPE (sym)); - while (TYPE_CODE (type) == TYPE_CODE_REF) - type = CHECK_TYPEDEF (TYPE_TARGET_TYPE (type)); - switch (TYPE_CODE (type)) - { - case TYPE_CODE_ARRAY: - case TYPE_CODE_STRUCT: - case TYPE_CODE_UNION: - case TYPE_CODE_SET: - case TYPE_CODE_STRING: - case TYPE_CODE_BITSTRING: - return 0; - default: - return 1; - } -} - /* Print the arguments of frame FRAME on STREAM, given the function FUNC running in that frame (as a symbol), where NUM is the number of arguments according to the stack frame (or -1 if the number of arguments is unknown). */ -/* Note that currently the "number of argumentss according to the +/* Note that currently the "number of arguments according to the stack frame" is only known on VAX where i refers to the "number of - ints of argumentss according to the stack frame". */ + ints of arguments according to the stack frame". */ static void print_frame_args (struct symbol *func, struct frame_info *frame, @@ -217,6 +211,10 @@ print_frame_args (struct symbol *func, struct frame_info *frame, int args_printed = 0; struct cleanup *old_chain, *list_chain; struct ui_stream *stb; + /* True if we should print arguments, false otherwise. */ + int print_args = strcmp (print_frame_arguments, "none"); + /* True in "summary" mode, false otherwise. */ + int summary = !strcmp (print_frame_arguments, "scalars"); stb = ui_out_stream_new (uiout); old_chain = make_cleanup_ui_out_stream_delete (stb); @@ -235,6 +233,9 @@ print_frame_args (struct symbol *func, struct frame_info *frame, /* Keep track of the highest stack argument offset seen, and skip over any kinds of symbols we don't care about. */ + if (!SYMBOL_IS_ARGUMENT (sym)) + continue; + switch (SYMBOL_CLASS (sym)) { case LOC_ARG: @@ -262,16 +263,12 @@ print_frame_args (struct symbol *func, struct frame_info *frame, /* We care about types of symbols, but don't need to keep track of stack offsets in them. */ - case LOC_REGPARM: + case LOC_REGISTER: case LOC_REGPARM_ADDR: - case LOC_LOCAL_ARG: - case LOC_BASEREG_ARG: - case LOC_COMPUTED_ARG: - break; - - /* Other types of symbols we just skip over. */ + case LOC_COMPUTED: + case LOC_OPTIMIZED_OUT: default: - continue; + break; } /* We have to look up the symbol because arguments can have @@ -287,13 +284,14 @@ print_frame_args (struct symbol *func, struct frame_info *frame, parameter names occur on the RS/6000, for traceback tables. FIXME, should we even print them? */ - if (*DEPRECATED_SYMBOL_NAME (sym)) + if (*SYMBOL_LINKAGE_NAME (sym)) { struct symbol *nsym; - nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym), - b, VAR_DOMAIN, NULL, NULL); + nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), + b, VAR_DOMAIN, NULL); gdb_assert (nsym != NULL); - if (SYMBOL_CLASS (nsym) == LOC_REGISTER) + if (SYMBOL_CLASS (nsym) == LOC_REGISTER + && !SYMBOL_IS_ARGUMENT (nsym)) { /* There is a LOC_ARG/LOC_REGISTER pair. This means that it was passed on the stack and loaded into a @@ -351,7 +349,7 @@ print_frame_args (struct symbol *func, struct frame_info *frame, annotate_arg_name_end (); ui_out_text (uiout, "="); - if (print_this_frame_argument_p (sym)) + if (print_args) { /* Avoid value_print because it will deref ref parameters. We just want to print their addresses. Print ??? for @@ -365,8 +363,21 @@ print_frame_args (struct symbol *func, struct frame_info *frame, if (val) { - common_val_print (val, stb->stream, 0, 0, 2, - Val_no_prettyprint); + const struct language_defn *language; + struct value_print_options opts; + + /* Use the appropriate language to display our symbol, + unless the user forced the language to a specific + language. */ + if (language_mode == language_mode_auto) + language = language_def (SYMBOL_LANGUAGE (sym)); + else + language = current_language; + + get_raw_print_options (&opts); + opts.deref_ref = 0; + opts.summary = summary; + common_val_print (val, stb->stream, 2, &opts, language); ui_out_field_stream (uiout, "value", stb); } else @@ -441,6 +452,67 @@ set_current_sal_from_frame (struct frame_info *frame, int center) } } +/* If ON, GDB will display disassembly of the next source line when + execution of the program being debugged stops. + If AUTO (which is the default), or there's no line info to determine + the source line of the next instruction, display disassembly of next + instruction instead. */ + +static enum auto_boolean disassemble_next_line; + +static void +show_disassemble_next_line (struct ui_file *file, int from_tty, + struct cmd_list_element *c, + const char *value) +{ + fprintf_filtered (file, _("\ +Debugger's willingness to use disassemble-next-line is %s.\n"), + value); +} + +/* Show assembly codes; stub for catch_errors. */ + +struct gdb_disassembly_stub_args +{ + struct gdbarch *gdbarch; + int how_many; + CORE_ADDR low; + CORE_ADDR high; +}; + +static void +gdb_disassembly_stub (void *args) +{ + struct gdb_disassembly_stub_args *p = args; + gdb_disassembly (p->gdbarch, uiout, 0, + DISASSEMBLY_RAW_INSN, p->how_many, + p->low, p->high); +} + +/* Use TRY_CATCH to catch the exception from the gdb_disassembly + because it will be broken by filter sometime. */ + +static void +do_gdb_disassembly (struct gdbarch *gdbarch, + int how_many, CORE_ADDR low, CORE_ADDR high) +{ + volatile struct gdb_exception exception; + struct gdb_disassembly_stub_args args; + + args.gdbarch = gdbarch; + args.how_many = how_many; + args.low = low; + args.high = high; + TRY_CATCH (exception, RETURN_MASK_ALL) + { + gdb_disassembly_stub (&args); + } + /* If an exception was thrown while doing the disassembly, print + the error message, to give the user a clue of what happened. */ + if (exception.reason == RETURN_ERROR) + exception_print (gdb_stderr, exception); +} + /* Print information about frame FRAME. The output is format according to PRINT_LEVEL and PRINT_WHAT and PRINT ARGS. The meaning of PRINT_WHAT is: @@ -456,18 +528,20 @@ void print_frame_info (struct frame_info *frame, int print_level, enum print_what print_what, int print_args) { + struct gdbarch *gdbarch = get_frame_arch (frame); struct symtab_and_line sal; int source_print; int location_print; if (get_frame_type (frame) == DUMMY_FRAME - || get_frame_type (frame) == SIGTRAMP_FRAME) + || get_frame_type (frame) == SIGTRAMP_FRAME + || get_frame_type (frame) == ARCH_FRAME) { struct cleanup *uiout_cleanup = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, - get_frame_pc (frame)); + gdbarch, get_frame_pc (frame)); /* Do this regardless of SOURCE because we don't have any source to list for this frame. */ @@ -480,7 +554,8 @@ print_frame_info (struct frame_info *frame, int print_level, if (ui_out_is_mi_like_p (uiout)) { annotate_frame_address (); - ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame)); + ui_out_field_core_addr (uiout, "addr", + gdbarch, get_frame_pc (frame)); annotate_frame_address_end (); } @@ -494,6 +569,10 @@ print_frame_info (struct frame_info *frame, int print_level, annotate_signal_handler_caller (); ui_out_field_string (uiout, "func", ""); } + else if (get_frame_type (frame) == ARCH_FRAME) + { + ui_out_field_string (uiout, "func", ""); + } ui_out_text (uiout, "\n"); annotate_frame_end (); @@ -518,11 +597,19 @@ print_frame_info (struct frame_info *frame, int print_level, source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC); + /* If disassemble-next-line is set to auto or on and doesn't have + the line debug messages for $pc, output the next instruction. */ + if ((disassemble_next_line == AUTO_BOOLEAN_AUTO + || disassemble_next_line == AUTO_BOOLEAN_TRUE) + && source_print && !sal.symtab) + do_gdb_disassembly (get_frame_arch (frame), 1, + get_frame_pc (frame), get_frame_pc (frame) + 1); + if (source_print && sal.symtab) { int done = 0; int mid_statement = ((print_what == SRC_LINE) - && (get_frame_pc (frame) != sal.pc)); + && frame_show_address (frame, sal)); if (annotation_level) done = identify_source_line (sal.symtab, sal.line, mid_statement, @@ -535,6 +622,8 @@ print_frame_info (struct frame_info *frame, int print_level, sal.line + 1, 0); else { + struct value_print_options opts; + get_user_print_options (&opts); /* We used to do this earlier, but that is clearly wrong. This function is used by many different parts of gdb, including normal_stop in infrun.c, @@ -543,40 +632,44 @@ print_frame_info (struct frame_info *frame, int print_level, line. Only the command line really wants this behavior. Other UIs probably would like the ability to decide for themselves if it is desired. */ - if (addressprint && mid_statement) + if (opts.addressprint && mid_statement) { - ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame)); + ui_out_field_core_addr (uiout, "addr", + gdbarch, get_frame_pc (frame)); ui_out_text (uiout, "\t"); } print_source_lines (sal.symtab, sal.line, sal.line + 1, 0); } } + + /* If disassemble-next-line is set to on and there is line debug + messages, output assembly codes for next line. */ + if (disassemble_next_line == AUTO_BOOLEAN_TRUE) + do_gdb_disassembly (get_frame_arch (frame), -1, sal.pc, sal.end); } if (print_what != LOCATION) - set_default_breakpoint (1, get_frame_pc (frame), sal.symtab, sal.line); + set_default_breakpoint (1, sal.pspace, + get_frame_pc (frame), sal.symtab, sal.line); annotate_frame_end (); gdb_flush (gdb_stdout); } -static void -print_frame (struct frame_info *frame, int print_level, - enum print_what print_what, int print_args, - struct symtab_and_line sal) +/* Attempt to obtain the FUNNAME and FUNLANG of the function corresponding + to FRAME. */ +void +find_frame_funname (struct frame_info *frame, char **funname, + enum language *funlang) { struct symbol *func; - char *funname = NULL; - enum language funlang = language_unknown; - struct ui_stream *stb; - struct cleanup *old_chain, *list_chain; - stb = ui_out_stream_new (uiout); - old_chain = make_cleanup_ui_out_stream_delete (stb); + *funname = NULL; + *funlang = language_unknown; - func = find_pc_function (get_frame_address_in_block (frame)); + func = get_frame_function (frame); if (func) { /* In certain pathological cases, the symtabs give the wrong @@ -597,8 +690,13 @@ print_frame (struct frame_info *frame, int print_level, changed (and we'll create a find_pc_minimal_function or some such). */ - struct minimal_symbol *msymbol = - lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame)); + struct minimal_symbol *msymbol = NULL; + + /* Don't attempt to do this for inlined functions, which do not + have a corresponding minimal symbol. */ + if (!block_inlined_p (SYMBOL_BLOCK_VALUE (func))) + msymbol + = lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame)); if (msymbol != NULL && (SYMBOL_VALUE_ADDRESS (msymbol) @@ -607,36 +705,26 @@ print_frame (struct frame_info *frame, int print_level, /* We also don't know anything about the function besides its address and name. */ func = 0; - funname = DEPRECATED_SYMBOL_NAME (msymbol); - funlang = SYMBOL_LANGUAGE (msymbol); + *funname = SYMBOL_PRINT_NAME (msymbol); + *funlang = SYMBOL_LANGUAGE (msymbol); } else { - funname = DEPRECATED_SYMBOL_NAME (func); - funlang = SYMBOL_LANGUAGE (func); - if (funlang == language_cplus) + *funname = SYMBOL_PRINT_NAME (func); + *funlang = SYMBOL_LANGUAGE (func); + if (*funlang == language_cplus) { /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to display the demangled name that we already have stored in the symbol table, but we stored a version with DMGL_PARAMS turned on, and here we don't want to - display parameters. So call the demangler again, with - DMGL_ANSI only. - - Yes, printf_symbol_filtered() will again try to - demangle the name on the fly, but the issue is that - if cplus_demangle() fails here, it will fail there - too. So we want to catch the failure (where DEMANGLED - is NULL below) here, while we still have our hands on - the function symbol.) */ - char *demangled = cplus_demangle (funname, DMGL_ANSI); - if (demangled == NULL) - /* If the demangler fails, try the demangled name from - the symbol table. That'll have parameters, but - that's preferable to displaying a mangled name. */ - funname = SYMBOL_PRINT_NAME (func); - else - xfree (demangled); + display parameters. So remove the parameters. */ + char *func_only = cp_remove_params (*funname); + if (func_only) + { + *funname = func_only; + make_cleanup (xfree, func_only); + } } } } @@ -647,13 +735,31 @@ print_frame (struct frame_info *frame, int print_level, if (msymbol != NULL) { - funname = DEPRECATED_SYMBOL_NAME (msymbol); - funlang = SYMBOL_LANGUAGE (msymbol); + *funname = SYMBOL_PRINT_NAME (msymbol); + *funlang = SYMBOL_LANGUAGE (msymbol); } } +} + +static void +print_frame (struct frame_info *frame, int print_level, + enum print_what print_what, int print_args, + struct symtab_and_line sal) +{ + struct gdbarch *gdbarch = get_frame_arch (frame); + char *funname = NULL; + enum language funlang = language_unknown; + struct ui_stream *stb; + struct cleanup *old_chain, *list_chain; + struct value_print_options opts; + + stb = ui_out_stream_new (uiout); + old_chain = make_cleanup_ui_out_stream_delete (stb); + + find_frame_funname (frame, &funname, &funlang); annotate_frame_begin (print_level ? frame_relative_level (frame) : 0, - get_frame_pc (frame)); + gdbarch, get_frame_pc (frame)); list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame"); @@ -663,12 +769,13 @@ print_frame (struct frame_info *frame, int print_level, ui_out_field_fmt_int (uiout, 2, ui_left, "level", frame_relative_level (frame)); } - if (addressprint) - if (get_frame_pc (frame) != sal.pc || !sal.symtab + get_user_print_options (&opts); + if (opts.addressprint) + if (frame_show_address (frame, sal) || !sal.symtab || print_what == LOC_AND_ADDRESS) { annotate_frame_address (); - ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame)); + ui_out_field_core_addr (uiout, "addr", gdbarch, get_frame_pc (frame)); annotate_frame_address_end (); ui_out_text (uiout, " in "); } @@ -685,10 +792,10 @@ print_frame (struct frame_info *frame, int print_level, struct print_args_args args; struct cleanup *args_list_chain; args.frame = frame; - args.func = func; + args.func = find_pc_function (get_frame_address_in_block (frame)); args.stream = gdb_stdout; args_list_chain = make_cleanup_ui_out_list_begin_end (uiout, "args"); - catch_errors (print_args_stub, &args, "", RETURN_MASK_ALL); + catch_errors (print_args_stub, &args, "", RETURN_MASK_ERROR); /* FIXME: ARGS must be a list. If one argument is a string it will have " that will not be properly escaped. */ /* Invoke ui_out_tuple_end. */ @@ -721,7 +828,8 @@ print_frame (struct frame_info *frame, int print_level, #ifdef PC_SOLIB char *lib = PC_SOLIB (get_frame_pc (frame)); #else - char *lib = solib_address (get_frame_pc (frame)); + char *lib = solib_name_from_address (get_frame_program_space (frame), + get_frame_pc (frame)); #endif if (lib) { @@ -738,14 +846,6 @@ print_frame (struct frame_info *frame, int print_level, do_cleanups (old_chain); } -/* Show the frame info. If this is the tui, it will be shown in the - source display otherwise, nothing is done. */ - -void -show_stack_frame (struct frame_info *frame) -{ -} - /* Read a frame specification in whatever the appropriate format is from FRAME_EXP. Call error(), printing MESSAGE, if the @@ -831,7 +931,7 @@ parse_frame_specification_1 (const char *frame_exp, const char *message, { int i; for (i = 0; i < numargs; i++) - addrs[i] = value_as_address (args[0]); + addrs[i] = value_as_address (args[i]); } /* Assume that the single arg[0] is an address, use that to identify @@ -852,8 +952,16 @@ parse_frame_specification_1 (const char *frame_exp, const char *message, { if (frame_id_eq (id, get_frame_id (fid))) { - while (frame_id_eq (id, frame_unwind_id (fid))) - fid = get_prev_frame (fid); + struct frame_info *prev_frame; + + while (1) + { + prev_frame = get_prev_frame (fid); + if (!prev_frame + || !frame_id_eq (id, get_frame_id (prev_frame))) + break; + fid = prev_frame; + } return fid; } } @@ -892,6 +1000,7 @@ frame_info (char *addr_exp, int from_tty) const char *pc_regname; int selected_frame_p; struct gdbarch *gdbarch; + struct cleanup *back_to = make_cleanup (null_cleanup, NULL); fi = parse_frame_specification_1 (addr_exp, "No stack.", &selected_frame_p); gdbarch = get_frame_arch (fi); @@ -917,29 +1026,21 @@ frame_info (char *addr_exp, int from_tty) s = find_pc_symtab (get_frame_pc (fi)); if (func) { - /* It seems appropriate to use SYMBOL_PRINT_NAME() here, to - display the demangled name that we already have stored in the - symbol table, but we stored a version with DMGL_PARAMS turned - on, and here we don't want to display parameters. So call the - demangler again, with DMGL_ANSI only. - - Yes, printf_symbol_filtered() will again try to demangle the - name on the fly, but the issue is that if cplus_demangle() - fails here, it will fail there too. So we want to catch the - failure (where DEMANGLED is NULL below) here, while we still - have our hands on the function symbol.) */ - funname = DEPRECATED_SYMBOL_NAME (func); + funname = SYMBOL_PRINT_NAME (func); funlang = SYMBOL_LANGUAGE (func); if (funlang == language_cplus) { - char *demangled = cplus_demangle (funname, DMGL_ANSI); - /* If the demangler fails, try the demangled name from the - symbol table. That'll have parameters, but that's - preferable to displaying a mangled name. */ - if (demangled == NULL) - funname = SYMBOL_PRINT_NAME (func); - else - xfree (demangled); + /* It seems appropriate to use SYMBOL_PRINT_NAME() here, + to display the demangled name that we already have + stored in the symbol table, but we stored a version + with DMGL_PARAMS turned on, and here we don't want to + display parameters. So remove the parameters. */ + char *func_only = cp_remove_params (funname); + if (func_only) + { + funname = func_only; + make_cleanup (xfree, func_only); + } } } else @@ -949,7 +1050,7 @@ frame_info (char *addr_exp, int from_tty) msymbol = lookup_minimal_symbol_by_pc (get_frame_pc (fi)); if (msymbol != NULL) { - funname = DEPRECATED_SYMBOL_NAME (msymbol); + funname = SYMBOL_PRINT_NAME (msymbol); funlang = SYMBOL_LANGUAGE (msymbol); } } @@ -964,10 +1065,10 @@ frame_info (char *addr_exp, int from_tty) { printf_filtered (_("Stack frame at ")); } - deprecated_print_address_numeric (get_frame_base (fi), 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, get_frame_base (fi)), gdb_stdout); printf_filtered (":\n"); printf_filtered (" %s = ", pc_regname); - deprecated_print_address_numeric (get_frame_pc (fi), 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, get_frame_pc (fi)), gdb_stdout); wrap_here (" "); if (funname) @@ -982,7 +1083,7 @@ frame_info (char *addr_exp, int from_tty) puts_filtered ("; "); wrap_here (" "); printf_filtered ("saved %s ", pc_regname); - deprecated_print_address_numeric (frame_pc_unwind (fi), 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, frame_unwind_caller_pc (fi)), gdb_stdout); printf_filtered ("\n"); if (calling_frame_info == NULL) @@ -994,12 +1095,14 @@ frame_info (char *addr_exp, int from_tty) printf_filtered (_(" Outermost frame: %s\n"), frame_stop_reason_string (reason)); } - - if (calling_frame_info) + else if (get_frame_type (fi) == INLINE_FRAME) + printf_filtered (" inlined into frame %d", + frame_relative_level (get_prev_frame (fi))); + else { printf_filtered (" called by frame at "); - deprecated_print_address_numeric (get_frame_base (calling_frame_info), - 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, get_frame_base (calling_frame_info)), + gdb_stdout); } if (get_next_frame (fi) && calling_frame_info) puts_filtered (","); @@ -1007,8 +1110,8 @@ frame_info (char *addr_exp, int from_tty) if (get_next_frame (fi)) { printf_filtered (" caller of frame at "); - deprecated_print_address_numeric (get_frame_base (get_next_frame (fi)), 1, - gdb_stdout); + fputs_filtered (paddress (gdbarch, get_frame_base (get_next_frame (fi))), + gdb_stdout); } if (get_next_frame (fi) || calling_frame_info) puts_filtered ("\n"); @@ -1028,7 +1131,7 @@ frame_info (char *addr_exp, int from_tty) else { printf_filtered (" Arglist at "); - deprecated_print_address_numeric (arg_list, 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); printf_filtered (","); if (!gdbarch_frame_num_args_p (gdbarch)) @@ -1060,7 +1163,7 @@ frame_info (char *addr_exp, int from_tty) else { printf_filtered (" Locals at "); - deprecated_print_address_numeric (arg_list, 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, arg_list), gdb_stdout); printf_filtered (","); } } @@ -1090,6 +1193,8 @@ frame_info (char *addr_exp, int from_tty) &realnum, NULL); if (!optimized && lval == not_lval) { + enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + int sp_size = register_size (gdbarch, gdbarch_sp_regnum (gdbarch)); gdb_byte value[MAX_REGISTER_SIZE]; CORE_ADDR sp; frame_register_unwind (fi, gdbarch_sp_regnum (gdbarch), @@ -1098,18 +1203,16 @@ frame_info (char *addr_exp, int from_tty) /* NOTE: cagney/2003-05-22: This is assuming that the stack pointer was packed as an unsigned integer. That may or may not be valid. */ - sp = extract_unsigned_integer (value, - register_size (gdbarch, - gdbarch_sp_regnum (gdbarch))); + sp = extract_unsigned_integer (value, sp_size, byte_order); printf_filtered (" Previous frame's sp is "); - deprecated_print_address_numeric (sp, 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, sp), gdb_stdout); printf_filtered ("\n"); need_nl = 0; } else if (!optimized && lval == lval_memory) { printf_filtered (" Previous frame's sp at "); - deprecated_print_address_numeric (addr, 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, addr), gdb_stdout); printf_filtered ("\n"); need_nl = 0; } @@ -1144,13 +1247,15 @@ frame_info (char *addr_exp, int from_tty) wrap_here (" "); printf_filtered (" %s at ", gdbarch_register_name (gdbarch, i)); - deprecated_print_address_numeric (addr, 1, gdb_stdout); + fputs_filtered (paddress (gdbarch, addr), gdb_stdout); count++; } } if (count || need_nl) puts_filtered ("\n"); } + + do_cleanups (back_to); } /* Print briefly all stack frames or just the innermost COUNT_EXP @@ -1174,11 +1279,6 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) of frames which we should print, or -1 if all of them. */ trailing = get_current_frame (); - /* The target can be in a state where there is no valid frames - (e.g., just connected). */ - if (trailing == NULL) - error (_("No stack.")); - trailing_level = 0; if (count_exp) { @@ -1224,10 +1324,10 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty) i = count; for (fi = trailing; fi != NULL && i--; fi = get_prev_frame (fi)) { + CORE_ADDR pc; QUIT; - ps = find_pc_psymtab (get_frame_address_in_block (fi)); - if (ps) - PSYMTAB_TO_SYMTAB (ps); /* Force syms to come in. */ + pc = get_frame_address_in_block (fi); + find_pc_sect_symtab_via_partial (pc, find_pc_mapped_section (pc)); } } @@ -1293,7 +1393,7 @@ backtrace_command (char *arg, int from_tty) char **argv; int i; - argv = buildargv (arg); + argv = gdb_buildargv (arg); old_chain = make_cleanup_freeargv (argv); argc = 0; for (i = 0; argv[i]; i++) @@ -1355,17 +1455,16 @@ backtrace_full_command (char *arg, int from_tty) } -/* Print the local variables of a block B active in FRAME on STREAM. - Return 1 if any variables were printed; 0 otherwise. */ +/* Iterate over the local variables of a block B, calling CB with + CB_DATA. */ -static int -print_block_frame_locals (struct block *b, struct frame_info *frame, - int num_tabs, struct ui_file *stream) +static void +iterate_over_block_locals (struct block *b, + iterate_over_block_arg_local_vars_cb cb, + void *cb_data) { struct dict_iterator iter; struct symbol *sym; - int values_printed = 0; - int j; ALL_BLOCK_SYMBOLS (b, iter, sym) { @@ -1374,15 +1473,10 @@ print_block_frame_locals (struct block *b, struct frame_info *frame, case LOC_LOCAL: case LOC_REGISTER: case LOC_STATIC: - case LOC_BASEREG: case LOC_COMPUTED: - values_printed = 1; - for (j = 0; j < num_tabs; j++) - fputs_filtered ("\t", stream); - fputs_filtered (SYMBOL_PRINT_NAME (sym), stream); - fputs_filtered (" = ", stream); - print_variable_value (sym, frame, stream); - fprintf_filtered (stream, "\n"); + if (SYMBOL_IS_ARGUMENT (sym)) + break; + (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data); break; default: @@ -1390,15 +1484,21 @@ print_block_frame_locals (struct block *b, struct frame_info *frame, break; } } - - return values_printed; } + /* Same, but print labels. */ +#if 0 +/* Commented out, as the code using this function has also been + commented out. FIXME:brobecker/2009-01-13: Find out why the code + was commented out in the first place. The discussion introducing + this change (2007-12-04: Support lexical blocks and function bodies + that occupy non-contiguous address ranges) did not explain why + this change was made. */ static int -print_block_frame_labels (struct block *b, int *have_default, - struct ui_file *stream) +print_block_frame_labels (struct gdbarch *gdbarch, struct block *b, + int *have_default, struct ui_file *stream) { struct dict_iterator iter; struct symbol *sym; @@ -1406,7 +1506,7 @@ print_block_frame_labels (struct block *b, int *have_default, ALL_BLOCK_SYMBOLS (b, iter, sym) { - if (strcmp (DEPRECATED_SYMBOL_NAME (sym), "default") == 0) + if (strcmp (SYMBOL_LINKAGE_NAME (sym), "default") == 0) { if (*have_default) continue; @@ -1415,13 +1515,16 @@ print_block_frame_labels (struct block *b, int *have_default, if (SYMBOL_CLASS (sym) == LOC_LABEL) { struct symtab_and_line sal; + struct value_print_options opts; sal = find_pc_line (SYMBOL_VALUE_ADDRESS (sym), 0); values_printed = 1; fputs_filtered (SYMBOL_PRINT_NAME (sym), stream); - if (addressprint) + get_user_print_options (&opts); + if (opts.addressprint) { fprintf_filtered (stream, " "); - deprecated_print_address_numeric (SYMBOL_VALUE_ADDRESS (sym), 1, stream); + fputs_filtered (paddress (gdbarch, SYMBOL_VALUE_ADDRESS (sym)), + stream); } fprintf_filtered (stream, " in file %s, line %d\n", sal.symtab->filename, sal.line); @@ -1430,38 +1533,77 @@ print_block_frame_labels (struct block *b, int *have_default, return values_printed; } +#endif -/* Print on STREAM all the local variables in frame FRAME, including - all the blocks active in that frame at its current PC. +/* Iterate over all the local variables in block B, including all its + superblocks, stopping when the top-level block is reached. */ - Returns 1 if the job was done, or 0 if nothing was printed because - we have no info on the function running in FRAME. */ +void +iterate_over_block_local_vars (struct block *block, + iterate_over_block_arg_local_vars_cb cb, + void *cb_data) +{ + while (block) + { + iterate_over_block_locals (block, cb, cb_data); + /* After handling the function's top-level block, stop. Don't + continue to its superblock, the block of per-file + symbols. */ + if (BLOCK_FUNCTION (block)) + break; + block = BLOCK_SUPERBLOCK (block); + } +} + +/* Data to be passed around in the calls to the locals and args + iterators. */ + +struct print_variable_and_value_data +{ + struct frame_info *frame; + int num_tabs; + struct ui_file *stream; + int values_printed; +}; + +/* The callback for the locals and args iterators */ + +static void +do_print_variable_and_value (const char *print_name, + struct symbol *sym, + void *cb_data) +{ + struct print_variable_and_value_data *p = cb_data; + + print_variable_and_value (print_name, sym, + p->frame, p->stream, p->num_tabs); + p->values_printed = 1; +} static void print_frame_local_vars (struct frame_info *frame, int num_tabs, struct ui_file *stream) { - struct block *block = get_frame_block (frame, 0); - int values_printed = 0; + struct print_variable_and_value_data cb_data; + struct block *block; + block = get_frame_block (frame, 0); if (block == 0) { fprintf_filtered (stream, "No symbol table info available.\n"); return; } - while (block) - { - if (print_block_frame_locals (block, frame, num_tabs, stream)) - values_printed = 1; - /* After handling the function's top-level block, stop. Don't - continue to its superblock, the block of per-file symbols. */ - if (BLOCK_FUNCTION (block)) - break; - block = BLOCK_SUPERBLOCK (block); - } + cb_data.frame = frame; + cb_data.num_tabs = 4 * num_tabs; + cb_data.stream = stream; + cb_data.values_printed = 0; - if (!values_printed) + iterate_over_block_local_vars (block, + do_print_variable_and_value, + &cb_data); + + if (!cb_data.values_printed) fprintf_filtered (stream, _("No locals.\n")); } @@ -1471,8 +1613,12 @@ static void print_frame_label_vars (struct frame_info *frame, int this_level_only, struct ui_file *stream) { +#if 1 + fprintf_filtered (stream, "print_frame_label_vars disabled.\n"); +#else struct blockvector *bl; struct block *block = get_frame_block (frame, 0); + struct gdbarch *gdbarch = get_frame_arch (frame); int values_printed = 0; int index, have_default = 0; char *blocks_printed; @@ -1510,7 +1656,8 @@ print_frame_label_vars (struct frame_info *frame, int this_level_only, { if (blocks_printed[index] == 0) { - if (print_block_frame_labels (BLOCKVECTOR_BLOCK (bl, index), + if (print_block_frame_labels (gdbarch, + BLOCKVECTOR_BLOCK (bl, index), &have_default, stream)) values_printed = 1; blocks_printed[index] = 1; @@ -1523,7 +1670,9 @@ print_frame_label_vars (struct frame_info *frame, int this_level_only, return; /* After handling the function's top-level block, stop. Don't - continue to its superblock, the block of per-file symbols. */ + continue to its superblock, the block of per-file symbols. + Also do not continue to the containing function of an inlined + function. */ if (BLOCK_FUNCTION (block)) break; block = BLOCK_SUPERBLOCK (block); @@ -1531,6 +1680,7 @@ print_frame_label_vars (struct frame_info *frame, int this_level_only, if (!values_printed && !this_level_only) fprintf_filtered (stream, _("No catches.\n")); +#endif } void @@ -1545,55 +1695,28 @@ catch_info (char *ignore, int from_tty) { struct symtab_and_line *sal; - /* Check for target support for exception handling */ - sal = target_enable_exception_callback (EX_EVENT_CATCH, 1); - if (sal) - { - /* Currently not handling this. Ideally, here we should - interact with the C++ runtime system to find the list of - active handlers, etc. */ - fprintf_filtered (gdb_stdout, _("\ -Info catch not supported with this target/compiler combination.\n")); - } - else - { - /* Assume g++ compiled code; old GDB 4.16 behaviour. */ - print_frame_label_vars (get_selected_frame (_("No frame selected.")), - 0, gdb_stdout); - } + /* Assume g++ compiled code; old GDB 4.16 behaviour. */ + print_frame_label_vars (get_selected_frame (_("No frame selected.")), + 0, gdb_stdout); } -static void -print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) +/* Iterate over all the argument variables in block B. + + Returns 1 if any argument was walked; 0 otherwise. */ + +void +iterate_over_block_arg_vars (struct block *b, + iterate_over_block_arg_local_vars_cb cb, + void *cb_data) { - struct symbol *func = get_frame_function (frame); - struct block *b; struct dict_iterator iter; struct symbol *sym, *sym2; - int values_printed = 0; - if (func == 0) - { - fprintf_filtered (stream, _("No symbol table info available.\n")); - return; - } - - b = SYMBOL_BLOCK_VALUE (func); ALL_BLOCK_SYMBOLS (b, iter, sym) { - switch (SYMBOL_CLASS (sym)) + /* Don't worry about things which aren't arguments. */ + if (SYMBOL_IS_ARGUMENT (sym)) { - case LOC_ARG: - case LOC_LOCAL_ARG: - case LOC_REF_ARG: - case LOC_REGPARM: - case LOC_REGPARM_ADDR: - case LOC_BASEREG_ARG: - case LOC_COMPUTED_ARG: - values_printed = 1; - fputs_filtered (SYMBOL_PRINT_NAME (sym), stream); - fputs_filtered (" = ", stream); - /* We have to look up the symbol because arguments can have two entries (one a parameter, one a local) and the one we want is the local, which lookup_symbol will find for us. @@ -1605,19 +1728,35 @@ print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) float). There are also LOC_ARG/LOC_REGISTER pairs which are not combined in symbol-reading. */ - sym2 = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym), - b, VAR_DOMAIN, NULL, NULL); - print_variable_value (sym2, frame, stream); - fprintf_filtered (stream, "\n"); - break; - - default: - /* Don't worry about things which aren't arguments. */ - break; + sym2 = lookup_symbol (SYMBOL_LINKAGE_NAME (sym), + b, VAR_DOMAIN, NULL); + (*cb) (SYMBOL_PRINT_NAME (sym), sym2, cb_data); } } +} - if (!values_printed) +static void +print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) +{ + struct print_variable_and_value_data cb_data; + struct symbol *func; + + func = get_frame_function (frame); + if (func == NULL) + { + fprintf_filtered (stream, _("No symbol table info available.\n")); + return; + } + + cb_data.frame = frame; + cb_data.num_tabs = 0; + cb_data.stream = gdb_stdout; + cb_data.values_printed = 0; + + iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func), + do_print_variable_and_value, &cb_data); + + if (!cb_data.values_printed) fprintf_filtered (stream, _("No arguments.\n")); } @@ -1657,7 +1796,7 @@ select_and_print_frame (struct frame_info *frame) struct block * get_selected_block (CORE_ADDR *addr_in_block) { - if (!target_has_stack) + if (!has_stack_frames ()) return 0; return get_frame_block (get_selected_frame (NULL), addr_in_block); @@ -1804,11 +1943,18 @@ down_command (char *count_exp, int from_tty) void return_command (char *retval_exp, int from_tty) { + struct frame_info *thisframe; + struct gdbarch *gdbarch; struct symbol *thisfun; struct value *return_value = NULL; const char *query_prefix = ""; - thisfun = get_frame_function (get_selected_frame ("No selected frame.")); + thisframe = get_selected_frame ("No selected frame."); + thisfun = get_frame_function (thisframe); + gdbarch = get_frame_arch (thisframe); + + if (get_frame_type (get_current_frame ()) == INLINE_FRAME) + error (_("Can not force return from an inlined function.")); /* Compute the return value. If the computation triggers an error, let it bail. If the return type can't be handled, set @@ -1816,18 +1962,27 @@ return_command (char *retval_exp, int from_tty) message. */ if (retval_exp) { + struct expression *retval_expr = parse_expression (retval_exp); + struct cleanup *old_chain = make_cleanup (xfree, retval_expr); struct type *return_type = NULL; /* Compute the return value. Should the computation fail, this call throws an error. */ - return_value = parse_and_eval (retval_exp); + return_value = evaluate_expression (retval_expr); /* Cast return value to the return type of the function. Should the cast fail, this call throws an error. */ if (thisfun != NULL) return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); if (return_type == NULL) - return_type = builtin_type_int; + { + if (retval_expr->elts[0].opcode != UNOP_CAST) + error (_("Return value type not available for selected " + "stack frame.\n" + "Please use an explicit cast of the value to return.")); + return_type = value_type (return_value); + } + do_cleanups (old_chain); CHECK_TYPEDEF (return_type); return_value = value_cast (return_type, return_value); @@ -1843,7 +1998,9 @@ return_command (char *retval_exp, int from_tty) is discarded, side effects such as "return i++" still occur. */ return_value = NULL; - else if (using_struct_return (return_type)) + else if (thisfun != NULL + && using_struct_return (gdbarch, + SYMBOL_TYPE (thisfun), return_type)) { query_prefix = "\ The location at which to store the function's return value is unknown.\n\ @@ -1868,38 +2025,20 @@ If you continue, the return value that you specified will be ignored.\n"; error (_("Not confirmed")); } - /* NOTE: cagney/2003-01-18: Is this silly? Rather than pop each - frame in turn, should this code just go straight to the relevant - frame and pop that? */ - - /* First discard all frames inner-to the selected frame (making the - selected frame current). */ - { - struct frame_id selected_id = get_frame_id (get_selected_frame (NULL)); - while (!frame_id_eq (selected_id, get_frame_id (get_current_frame ()))) - { - struct frame_info *frame = get_current_frame (); - if (frame_id_inner (get_frame_arch (frame), selected_id, - get_frame_id (frame))) - /* Caught in the safety net, oops! We've gone way past the - selected frame. */ - error (_("Problem while popping stack frames (corrupt stack?)")); - frame_pop (get_current_frame ()); - } - } - - /* Second discard the selected frame (which is now also the current - frame). */ - frame_pop (get_current_frame ()); + /* Discard the selected frame and all frames inner-to it. */ + frame_pop (get_selected_frame (NULL)); /* Store RETURN_VALUE in the just-returned register set. */ if (return_value != NULL) { struct type *return_type = value_type (return_value); struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ()); - gdb_assert (gdbarch_return_value (gdbarch, return_type, NULL, NULL, NULL) + struct type *func_type = thisfun == NULL ? NULL : SYMBOL_TYPE (thisfun); + + gdb_assert (gdbarch_return_value (gdbarch, func_type, return_type, NULL, + NULL, NULL) == RETURN_VALUE_REGISTER_CONVENTION); - gdbarch_return_value (gdbarch, return_type, + gdbarch_return_value (gdbarch, func_type, return_type, get_current_regcache (), NULL /*read*/, value_contents (return_value) /*write*/); } @@ -2099,6 +2238,24 @@ Usage: func \n")); _("Show printing of non-scalar frame arguments"), NULL, NULL, NULL, &setprintlist, &showprintlist); + add_setshow_auto_boolean_cmd ("disassemble-next-line", class_stack, + &disassemble_next_line, _("\ +Set whether to disassemble next source line or insn when execution stops."), _("\ +Show whether to disassemble next source line or insn when execution stops."), _("\ +If ON, GDB will display disassembly of the next source line, in addition\n\ +to displaying the source line itself. If the next source line cannot\n\ +be displayed (e.g., source is unavailable or there's no line info), GDB\n\ +will display disassembly of next instruction instead of showing the\n\ +source line.\n\ +If AUTO, display disassembly of next instruction only if the source line\n\ +cannot be displayed.\n\ +If OFF (which is the default), never display the disassembly of the next\n\ +source line."), + NULL, + show_disassemble_next_line, + &setlist, &showlist); + disassemble_next_line = AUTO_BOOLEAN_FALSE; + #if 0 add_cmd ("backtrace-limit", class_stack, set_backtrace_limit_command, _(\ "Specify maximum number of frames for \"backtrace\" to print by default."),