X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fstack.c;h=a1a7696562b5fed67c96587ebceef3c00ceef402;hb=5a7c5e86304d6298cbeee81f07b626b194980073;hp=ab2f7f13fb3988b505ccbcea3f40c82b4e9fd0f2;hpb=ed49a04fe1bc299bc4b22c01a15c1f46ae21a294;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/stack.c b/gdb/stack.c index ab2f7f13fb..a1a7696562 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, 2008 - Free Software Foundation, Inc. + 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, + 2009 Free Software Foundation, Inc. This file is part of GDB. @@ -43,6 +43,8 @@ #include "regcache.h" #include "solib.h" #include "valprint.h" +#include "gdbthread.h" +#include "cp-support.h" #include "gdb_assert.h" #include @@ -115,7 +117,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 @@ -200,9 +202,9 @@ print_this_frame_argument_p (struct symbol *sym) 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, @@ -235,6 +237,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 +267,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 +288,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 @@ -365,8 +367,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; + common_val_print (val, stb->stream, 2, + &opts, language); ui_out_field_stream (uiout, "value", stb); } else @@ -535,6 +550,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,7 +560,7 @@ 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_text (uiout, "\t"); @@ -572,6 +589,7 @@ print_frame (struct frame_info *frame, int print_level, 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); @@ -607,12 +625,12 @@ 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); + funname = SYMBOL_PRINT_NAME (msymbol); funlang = SYMBOL_LANGUAGE (msymbol); } else { - funname = DEPRECATED_SYMBOL_NAME (func); + funname = SYMBOL_PRINT_NAME (func); funlang = SYMBOL_LANGUAGE (func); if (funlang == language_cplus) { @@ -620,23 +638,13 @@ print_frame (struct frame_info *frame, int print_level, 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,7 +655,7 @@ print_frame (struct frame_info *frame, int print_level, if (msymbol != NULL) { - funname = DEPRECATED_SYMBOL_NAME (msymbol); + funname = SYMBOL_PRINT_NAME (msymbol); funlang = SYMBOL_LANGUAGE (msymbol); } } @@ -663,7 +671,8 @@ 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) + get_user_print_options (&opts); + if (opts.addressprint) if (get_frame_pc (frame) != sal.pc || !sal.symtab || print_what == LOC_AND_ADDRESS) { @@ -688,7 +697,7 @@ print_frame (struct frame_info *frame, int print_level, args.func = func; 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. */ @@ -738,14 +747,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 +832,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 @@ -892,6 +893,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 +919,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 +943,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); } } @@ -1151,6 +1145,8 @@ frame_info (char *addr_exp, int from_tty) if (count || need_nl) puts_filtered ("\n"); } + + do_cleanups (back_to); } /* Print briefly all stack frames or just the innermost COUNT_EXP @@ -1293,7 +1289,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++) @@ -1374,15 +1370,11 @@ 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: + if (SYMBOL_IS_ARGUMENT (sym)) + break; 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"); + print_variable_and_value (NULL, sym, frame, stream, 4 * num_tabs); break; default: @@ -1406,7 +1398,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,10 +1407,12 @@ 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, " "); fputs_filtered (paddress (SYMBOL_VALUE_ADDRESS (sym)), stream); @@ -1572,18 +1566,10 @@ print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream) 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 @@ -1596,15 +1582,10 @@ 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); + print_variable_and_value (SYMBOL_PRINT_NAME (sym), sym2, + frame, stream, 0); } } @@ -1651,6 +1632,12 @@ get_selected_block (CORE_ADDR *addr_in_block) if (!target_has_stack) return 0; + if (is_exited (inferior_ptid)) + return 0; + + if (is_executing (inferior_ptid)) + return 0; + return get_frame_block (get_selected_frame (NULL), addr_in_block); } @@ -1795,11 +1782,13 @@ down_command (char *count_exp, int from_tty) void return_command (char *retval_exp, int from_tty) { + struct frame_info *thisframe; 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); /* Compute the return value. If the computation triggers an error, let it bail. If the return type can't be handled, set @@ -1818,7 +1807,7 @@ return_command (char *retval_exp, int from_tty) if (thisfun != NULL) return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun)); if (return_type == NULL) - return_type = builtin_type_int; + return_type = builtin_type (get_frame_arch (thisframe))->builtin_int; CHECK_TYPEDEF (return_type); return_value = value_cast (return_type, return_value); @@ -1834,7 +1823,7 @@ 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 (using_struct_return (SYMBOL_TYPE (thisfun), return_type)) { query_prefix = "\ The location at which to store the function's return value is unknown.\n\ @@ -1859,38 +1848,18 @@ 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) + gdb_assert (gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun), + return_type, NULL, NULL, NULL) == RETURN_VALUE_REGISTER_CONVENTION); - gdbarch_return_value (gdbarch, return_type, + gdbarch_return_value (gdbarch, SYMBOL_TYPE (thisfun), return_type, get_current_regcache (), NULL /*read*/, value_contents (return_value) /*write*/); }