Subversion Repositories openrisc_me

/* 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.

   This file is part of GDB.

   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 "defs.h"

#include "value.h"

#include "symtab.h"

#include "gdbtypes.h"

#include "expression.h"

#include "language.h"

#include "frame.h"

#include "gdbcmd.h"

#include "gdbcore.h"

#include "target.h"

#include "source.h"

#include "breakpoint.h"

#include "demangle.h"

#include "inferior.h"

#include "annotate.h"

#include "ui-out.h"

#include "block.h"

#include "stack.h"

#include "dictionary.h"

#include "exceptions.h"

#include "reggroups.h"

#include "regcache.h"

#include "solib.h"

#include "valprint.h"

#include "gdb_assert.h"

#include <ctype.h>

#include "gdb_string.h"

void (*deprecated_selected_frame_level_changed_hook) (int);

/* The possible choices of "set print frame-arguments, and the value

   of this setting.  */

static const char *print_frame_arguments_choices[] =

  {"all", "scalars", "none", NULL};

static const char *print_frame_arguments = "all";

/* Prototypes for local functions. */

static void print_frame_local_vars (struct frame_info *, int,

                                    struct ui_file *);

static void print_frame (struct frame_info *frame, int print_level,

                         enum print_what print_what,  int print_args,

                         struct symtab_and_line sal);

/* Zero means do things normally; we are interacting directly with the

   user.  One means print the full filename and linenumber when a

   frame is printed, and do so in a format emacs18/emacs19.22 can

   parse.  Two means print similar annotations, but in many more

   cases and in a slightly different syntax.  */

int annotation_level = 0;

struct print_stack_frame_args

{

  struct frame_info *frame;

  int print_level;

  enum print_what print_what;

  int print_args;

};

/* Show or print the frame arguments; stub for catch_errors.  */

static int

print_stack_frame_stub (void *args)

{

  struct print_stack_frame_args *p = args;

  int center = (p->print_what == SRC_LINE || p->print_what == SRC_AND_LOC);

  print_frame_info (p->frame, p->print_level, p->print_what, p->print_args);

  set_current_sal_from_frame (p->frame, center);

  return 0;

}

/* 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

   line number.  If the frame's PC is not at the beginning of the

   source line, the actual PC is printed at the beginning.  */

void

print_stack_frame (struct frame_info *frame, int print_level,

                   enum print_what print_what)

{

  struct print_stack_frame_args args;

  args.frame = frame;

  args.print_level = print_level;

  args.print_what = print_what;

  /* For mi, alway print location and address.  */

  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_ERROR);

}

struct print_args_args

{

  struct symbol *func;

  struct frame_info *frame;

  struct ui_file *stream;

};

static int print_args_stub (void *args);

/* Print nameless arguments of frame FRAME on STREAM, where START is

   the offset of the first nameless argument, and NUM is the number of

   nameless arguments to print.  FIRST is nonzero if this is the first

   argument (not just the first nameless argument).  */

static void

print_frame_nameless_args (struct frame_info *frame, long start, int num,

                           int first, struct ui_file *stream)

{

  int i;

  CORE_ADDR argsaddr;

  long arg_value;

  for (i = 0; i < num; i++)

    {

      QUIT;

      argsaddr = get_frame_args_address (frame);

      if (!argsaddr)

        return;

      arg_value = read_memory_integer (argsaddr + start, sizeof (int));

      if (!first)

        fprintf_filtered (stream, ", ");

      fprintf_filtered (stream, "%ld", arg_value);

      first = 0;

      start += sizeof (int);

    }

}

/* 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

   stack frame" is only known on VAX where i refers to the "number of

   ints of argumentss according to the stack frame".  */

static void

print_frame_args (struct symbol *func, struct frame_info *frame,

                  int num, struct ui_file *stream)

{

  int first = 1;

  /* Offset of next stack argument beyond the one we have seen that is

     at the highest offset, or -1 if we haven't come to a stack

     argument yet.  */

  long highest_offset = -1;

  /* Number of ints of arguments that we have printed so far.  */

  int args_printed = 0;

  struct cleanup *old_chain, *list_chain;

  struct ui_stream *stb;

  stb = ui_out_stream_new (uiout);

  old_chain = make_cleanup_ui_out_stream_delete (stb);

  if (func)

    {

      struct block *b = SYMBOL_BLOCK_VALUE (func);

      struct dict_iterator iter;

      struct symbol *sym;

      struct value *val;

      ALL_BLOCK_SYMBOLS (b, iter, sym)

        {

          QUIT;

          /* Keep track of the highest stack argument offset seen, and

             skip over any kinds of symbols we don't care about.  */

          switch (SYMBOL_CLASS (sym))

            {

            case LOC_ARG:

            case LOC_REF_ARG:

              {

                long current_offset = SYMBOL_VALUE (sym);

                int arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));

                /* Compute address of next argument by adding the size of

                   this argument and rounding to an int boundary.  */

                current_offset =

                  ((current_offset + arg_size + sizeof (int) - 1)

                   & ~(sizeof (int) - 1));

                /* If this is the highest offset seen yet, set

                   highest_offset.  */

                if (highest_offset == -1

                    || (current_offset > highest_offset))

                  highest_offset = current_offset;

                /* Add the number of ints we're about to print to

                   args_printed.  */

                args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);

              }

              /* We care about types of symbols, but don't need to

                 keep track of stack offsets in them.  */

            case LOC_REGPARM:

            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.  */

            default:

              continue;

            }

          /* 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.

             This includes gcc1 (not gcc2) on SPARC when passing a

             small structure and gcc2 when the argument type is float

             and it is passed as a double and converted to float by

             the prologue (in the latter case the type of the LOC_ARG

             symbol is double and the type of the LOC_LOCAL symbol is

             float).  */

          /* But if the parameter name is null, don't try it.  Null

             parameter names occur on the RS/6000, for traceback

             tables.  FIXME, should we even print them?  */

          if (*DEPRECATED_SYMBOL_NAME (sym))

            {

              struct symbol *nsym;

              nsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (sym),

                                    b, VAR_DOMAIN, NULL, NULL);

              gdb_assert (nsym != NULL);

              if (SYMBOL_CLASS (nsym) == LOC_REGISTER)

                {

                  /* There is a LOC_ARG/LOC_REGISTER pair.  This means

                     that it was passed on the stack and loaded into a

                     register, or passed in a register and stored in a

                     stack slot.  GDB 3.x used the LOC_ARG; GDB

                     4.0-4.11 used the LOC_REGISTER.

                     Reasons for using the LOC_ARG:

                     (1) Because find_saved_registers may be slow for

                         remote debugging.

                     (2) Because registers are often re-used and stack

                         slots rarely (never?) are.  Therefore using

                         the stack slot is much less likely to print

                         garbage.

                     Reasons why we might want to use the LOC_REGISTER:

                     (1) So that the backtrace prints the same value

                         as "print foo".  I see no compelling reason

                         why this needs to be the case; having the

                         backtrace print the value which was passed

                         in, and "print foo" print the value as

                         modified within the called function, makes

                         perfect sense to me.

                     Additional note: It might be nice if "info args"

                     displayed both values.

                     One more note: There is a case with SPARC

                     structure passing where we need to use the

                     LOC_REGISTER, but this is dealt with by creating

                     a single LOC_REGPARM in symbol reading.  */

                  /* Leave sym (the LOC_ARG) alone.  */

                  ;

                }

              else

                sym = nsym;

            }

          /* Print the current arg.  */

          if (!first)

            ui_out_text (uiout, ", ");

          ui_out_wrap_hint (uiout, "    ");

          annotate_arg_begin ();

          list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);

          fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (sym),

                                   SYMBOL_LANGUAGE (sym),

                                   DMGL_PARAMS | DMGL_ANSI);

          ui_out_field_stream (uiout, "name", stb);

          annotate_arg_name_end ();

          ui_out_text (uiout, "=");

          if (print_this_frame_argument_p (sym))

            {

              /* Avoid value_print because it will deref ref parameters.

                 We just want to print their addresses.  Print ??? for

                 args whose address we do not know.  We pass 2 as

                 "recurse" to val_print because our standard indentation

                 here is 4 spaces, and val_print indents 2 for each

                 recurse.  */

              val = read_var_value (sym, frame);

              annotate_arg_value (val == NULL ? NULL : value_type (val));

              if (val)

                {

                  common_val_print (val, stb->stream, 0, 0, 2,

                                    Val_no_prettyprint);

                  ui_out_field_stream (uiout, "value", stb);

                }

              else

                ui_out_text (uiout, "???");

            }

          else

            ui_out_text (uiout, "...");

          /* Invoke ui_out_tuple_end.  */

          do_cleanups (list_chain);

          annotate_arg_end ();

          first = 0;

        }

    }

  /* Don't print nameless args in situations where we don't know

     enough about the stack to find them.  */

  if (num != -1)

    {

      long start;

      if (highest_offset == -1)

        start = gdbarch_frame_args_skip (get_frame_arch (frame));

      else

        start = highest_offset;

      print_frame_nameless_args (frame, start, num - args_printed,

                                 first, stream);

    }

  do_cleanups (old_chain);

}

/* Stub for catch_errors.  */

static int

print_args_stub (void *args)

{

  struct print_args_args *p = args;

  struct gdbarch *gdbarch = get_frame_arch (p->frame);

  int numargs;

  if (gdbarch_frame_num_args_p (gdbarch))

    {

      numargs = gdbarch_frame_num_args (gdbarch, p->frame);

      gdb_assert (numargs >= 0);

    }

  else

    numargs = -1;

  print_frame_args (p->func, p->frame, numargs, p->stream);

  return 0;

}

/* Set the current source and line to the location given by frame

   FRAME, if possible.  When CENTER is true, adjust so the relevant

   line is in the center of the next 'list'.  */

void

set_current_sal_from_frame (struct frame_info *frame, int center)

{

  struct symtab_and_line sal;

  find_frame_sal (frame, &sal);

  if (sal.symtab)

    {

      if (center)

        sal.line = max (sal.line - get_lines_to_list () / 2, 1);

      set_current_source_symtab_and_line (&sal);

    }

}

/* 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:

   SRC_LINE: Print only source line.

   LOCATION: Print only location.

   LOC_AND_SRC: Print location and source line.

   Used in "where" output, and to emit breakpoint or step

   messages.  */

void

print_frame_info (struct frame_info *frame, int print_level,

                  enum print_what print_what, int print_args)

{

  struct symtab_and_line sal;

  int source_print;

  int location_print;

  if (get_frame_type (frame) == DUMMY_FRAME

      || get_frame_type (frame) == SIGTRAMP_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));

      /* Do this regardless of SOURCE because we don't have any source

         to list for this frame.  */

      if (print_level)

        {

          ui_out_text (uiout, "#");

          ui_out_field_fmt_int (uiout, 2, ui_left, "level",

                                frame_relative_level (frame));

        }

      if (ui_out_is_mi_like_p (uiout))

        {

          annotate_frame_address ();

          ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));

          annotate_frame_address_end ();

        }

      if (get_frame_type (frame) == DUMMY_FRAME)

        {

          annotate_function_call ();

          ui_out_field_string (uiout, "func", "<function called from gdb>");

        }

      else if (get_frame_type (frame) == SIGTRAMP_FRAME)

        {

          annotate_signal_handler_caller ();

          ui_out_field_string (uiout, "func", "<signal handler called>");

        }

      ui_out_text (uiout, "\n");

      annotate_frame_end ();

      do_cleanups (uiout_cleanup);

      return;

    }

  /* If FRAME is not the innermost frame, that normally means that

     FRAME->pc points to *after* the call instruction, and we want to

     get the line containing the call, never the next line.  But if

     the next frame is a SIGTRAMP_FRAME or a DUMMY_FRAME, then the

     next frame was not entered as the result of a call, and we want

     to get the line containing FRAME->pc.  */

  find_frame_sal (frame, &sal);

  location_print = (print_what == LOCATION

                    || print_what == LOC_AND_ADDRESS

                    || print_what == SRC_AND_LOC);

  if (location_print || !sal.symtab)

    print_frame (frame, print_level, print_what, print_args, sal);

  source_print = (print_what == SRC_LINE || print_what == SRC_AND_LOC);

  if (source_print && sal.symtab)

    {

      int done = 0;

      int mid_statement = ((print_what == SRC_LINE)

                           && (get_frame_pc (frame) != sal.pc));

      if (annotation_level)

        done = identify_source_line (sal.symtab, sal.line, mid_statement,

                                     get_frame_pc (frame));

      if (!done)

        {

          if (deprecated_print_frame_info_listing_hook)

            deprecated_print_frame_info_listing_hook (sal.symtab,

                                                      sal.line,

                                                      sal.line + 1, 0);

          else

            {

              /* 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,

                 which uses this to print out the current PC

                 when we stepi/nexti into the middle of a source

                 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)

                {

                  ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));

                  ui_out_text (uiout, "\t");

                }

              print_source_lines (sal.symtab, sal.line, sal.line + 1, 0);

            }

        }

    }

  if (print_what != LOCATION)

    set_default_breakpoint (1, 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)

{

  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);

  func = find_pc_function (get_frame_address_in_block (frame));

  if (func)

    {

      /* In certain pathological cases, the symtabs give the wrong

         function (when we are in the first function in a file which

         is compiled without debugging symbols, the previous function

         is compiled with debugging symbols, and the "foo.o" symbol

         that is supposed to tell us where the file with debugging

         symbols ends has been truncated by ar because it is longer

         than 15 characters).  This also occurs if the user uses asm()

         to create a function but not stabs for it (in a file compiled

         with -g).

         So look in the minimal symbol tables as well, and if it comes

         up with a larger address for the function use that instead.

         I don't think this can ever cause any problems; there

         shouldn't be any minimal symbols in the middle of a function;

         if this is ever changed many parts of GDB will need to be

         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));

      if (msymbol != NULL

          && (SYMBOL_VALUE_ADDRESS (msymbol)

              > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))

        {

          /* 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);

        }

      else

        {

          funname = DEPRECATED_SYMBOL_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);

            }

        }

    }

  else

    {

      struct minimal_symbol *msymbol =

        lookup_minimal_symbol_by_pc (get_frame_address_in_block (frame));

      if (msymbol != NULL)

        {

          funname = DEPRECATED_SYMBOL_NAME (msymbol);

          funlang = SYMBOL_LANGUAGE (msymbol);

        }

    }

  annotate_frame_begin (print_level ? frame_relative_level (frame) : 0,

                        get_frame_pc (frame));

  list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, "frame");

  if (print_level)

    {

      ui_out_text (uiout, "#");

      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

        || print_what == LOC_AND_ADDRESS)

      {

        annotate_frame_address ();

        ui_out_field_core_addr (uiout, "addr", get_frame_pc (frame));

        annotate_frame_address_end ();

        ui_out_text (uiout, " in ");

      }

  annotate_frame_function_name ();

  fprintf_symbol_filtered (stb->stream, funname ? funname : "??",

                           funlang, DMGL_ANSI);

  ui_out_field_stream (uiout, "func", stb);

  ui_out_wrap_hint (uiout, "   ");

  annotate_frame_args ();

  ui_out_text (uiout, " (");

  if (print_args)

    {

      struct print_args_args args;

      struct cleanup *args_list_chain;

      args.frame = frame;

      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_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.  */

      do_cleanups (args_list_chain);

      QUIT;

    }

  ui_out_text (uiout, ")");

  if (sal.symtab && sal.symtab->filename)

    {

      annotate_frame_source_begin ();

      ui_out_wrap_hint (uiout, "   ");

      ui_out_text (uiout, " at ");

      annotate_frame_source_file ();

      ui_out_field_string (uiout, "file", sal.symtab->filename);

      if (ui_out_is_mi_like_p (uiout))

        {

          const char *fullname = symtab_to_fullname (sal.symtab);

          if (fullname != NULL)

            ui_out_field_string (uiout, "fullname", fullname);

        }

      annotate_frame_source_file_end ();

      ui_out_text (uiout, ":");

      annotate_frame_source_line ();

      ui_out_field_int (uiout, "line", sal.line);

      annotate_frame_source_end ();

    }

  if (!funname || (!sal.symtab || !sal.symtab->filename))