Subversion Repositories openrisc

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

   2009, 2010 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 "gdbthread.h"

#include "cp-support.h"

#include "disasm.h"

#include "inline-frame.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 = "scalars";

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

}

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

   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)

{

  struct gdbarch *gdbarch = get_frame_arch (frame);

  enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);

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

      if (!first)

        fprintf_filtered (stream, ", ");

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

      first = 0;

      start += sizeof (int);

    }

}

/* 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 arguments according to the

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

   ints of arguments 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;

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

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

          if (!SYMBOL_IS_ARGUMENT (sym))

            continue;

          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_REGISTER:

            case LOC_REGPARM_ADDR:

            case LOC_COMPUTED:

            case LOC_OPTIMIZED_OUT:

            default:

              break;

            }

          /* 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 (*SYMBOL_LINKAGE_NAME (sym))

            {

              struct symbol *nsym;

              nsym = lookup_symbol (SYMBOL_LINKAGE_NAME (sym),

                                    b, VAR_DOMAIN, NULL);

              gdb_assert (nsym != NULL);

              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

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

            {

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

                {

                  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

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

    }

}

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

   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 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) == 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,

                            gdbarch, 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",

                                  gdbarch, 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>");

        }

      else if (get_frame_type (frame) == ARCH_FRAME)

        {

          ui_out_field_string (uiout, "func", "<cross-architecture call>");

        }

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

                           && frame_show_address (frame, sal));

      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

            {

              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,

                 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 (opts.addressprint && mid_statement)

                {

                  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, sal.pspace,

                            get_frame_pc (frame), sal.symtab, sal.line);

  annotate_frame_end ();

  gdb_flush (gdb_stdout);

}

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

  *funname = NULL;

  *funlang = language_unknown;

  func = get_frame_function (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 = 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)

              > BLOCK_START (SYMBOL_BLOCK_VALUE (func))))

        {

          /* We also don't know anything about the function besides

             its address and name.  */

          func = 0;

          *funname = SYMBOL_PRINT_NAME (msymbol);

          *funlang = SYMBOL_LANGUAGE (msymbol);

        }

      else

        {

          *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 remove the parameters.  */

              char *func_only = cp_remove_params (*funname);

              if (func_only)

                {

                  *funname = func_only;

                  make_cleanup (xfree, func_only);

                }