Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / stack.c
index b15b5fc..ea5a306 100644 (file)
@@ -1,6 +1,6 @@
 /* Print and select stack frames for GDB, the GNU debugger.
 
-   Copyright (C) 1986-2005, 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 1986-2013 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -46,6 +46,7 @@
 #include "disasm.h"
 #include "inline-frame.h"
 #include "linespec.h"
+#include "cli/cli-utils.h"
 
 #include "gdb_assert.h"
 #include <ctype.h>
@@ -59,7 +60,7 @@ 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[] =
+static const char *const print_frame_arguments_choices[] =
   {"all", "scalars", "none", NULL};
 static const char *print_frame_arguments = "scalars";
 
@@ -73,7 +74,7 @@ const char print_entry_values_if_needed[] = "if-needed";
 const char print_entry_values_both[] = "both";
 const char print_entry_values_compact[] = "compact";
 const char print_entry_values_default[] = "default";
-static const char *print_entry_values_choices[] =
+static const char *const print_entry_values_choices[] =
 {
   print_entry_values_no,
   print_entry_values_only,
@@ -210,10 +211,10 @@ print_frame_arg (const struct frame_arg *arg)
   struct ui_out *uiout = current_uiout;
   volatile struct gdb_exception except;
   struct cleanup *old_chain;
-  struct ui_stream *stb;
+  struct ui_file *stb;
 
-  stb = ui_out_stream_new (uiout);
-  old_chain = make_cleanup_ui_out_stream_delete (stb);
+  stb = mem_fileopen ();
+  old_chain = make_cleanup_ui_file_delete (stb);
 
   gdb_assert (!arg->val || !arg->error);
   gdb_assert (arg->entry_kind == print_entry_values_no
@@ -224,21 +225,21 @@ print_frame_arg (const struct frame_arg *arg)
   annotate_arg_begin ();
 
   make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
-  fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (arg->sym),
+  fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
                           SYMBOL_LANGUAGE (arg->sym), DMGL_PARAMS | DMGL_ANSI);
   if (arg->entry_kind == print_entry_values_compact)
     {
       /* It is OK to provide invalid MI-like stream as with
         PRINT_ENTRY_VALUE_COMPACT we never use MI.  */
-      fputs_filtered ("=", stb->stream);
+      fputs_filtered ("=", stb);
 
-      fprintf_symbol_filtered (stb->stream, SYMBOL_PRINT_NAME (arg->sym),
+      fprintf_symbol_filtered (stb, SYMBOL_PRINT_NAME (arg->sym),
                               SYMBOL_LANGUAGE (arg->sym),
                               DMGL_PARAMS | DMGL_ANSI);
     }
   if (arg->entry_kind == print_entry_values_only
       || arg->entry_kind == print_entry_values_compact)
-    fputs_filtered ("@entry", stb->stream);
+    fputs_filtered ("@entry", stb);
   ui_out_field_stream (uiout, "name", stb);
   annotate_arg_name_end ();
   ui_out_text (uiout, "=");
@@ -279,22 +280,43 @@ print_frame_arg (const struct frame_arg *arg)
              /* True in "summary" mode, false otherwise.  */
              opts.summary = !strcmp (print_frame_arguments, "scalars");
 
-             common_val_print (arg->val, stb->stream, 2, &opts, language);
+             common_val_print (arg->val, stb, 2, &opts, language);
            }
        }
       if (except.message)
-       fprintf_filtered (stb->stream, _("<error reading variable: %s>"),
+       fprintf_filtered (stb, _("<error reading variable: %s>"),
                          except.message);
     }
 
   ui_out_field_stream (uiout, "value", stb);
 
-  /* Aleo invoke ui_out_tuple_end.  */
+  /* Also invoke ui_out_tuple_end.  */
   do_cleanups (old_chain);
 
   annotate_arg_end ();
 }
 
+/* Read in inferior function local SYM at FRAME into ARGP.  Caller is
+   responsible for xfree of ARGP->ERROR.  This function never throws an
+   exception.  */
+
+void
+read_frame_local (struct symbol *sym, struct frame_info *frame,
+                 struct frame_arg *argp)
+{
+  volatile struct gdb_exception except;
+  struct value *val = NULL;
+
+  TRY_CATCH (except, RETURN_MASK_ERROR)
+    {
+      val = read_var_value (sym, frame);
+    }
+
+  argp->error = (val == NULL) ? xstrdup (except.message) : NULL;
+  argp->sym = sym;
+  argp->val = val;
+}
+
 /* Read in inferior function parameter SYM at FRAME into ARGP.  Caller is
    responsible for xfree of ARGP->ERROR.  This function never throws an
    exception.  */
@@ -354,14 +376,15 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
 
          if (val && entryval && !ui_out_is_mi_like_p (current_uiout))
            {
-             unsigned len = TYPE_LENGTH (value_type (val));
+             struct type *type = value_type (val);
 
              if (!value_optimized_out (val) && value_lazy (val))
                value_fetch_lazy (val);
              if (!value_optimized_out (val) && value_lazy (entryval))
                value_fetch_lazy (entryval);
              if (!value_optimized_out (val)
-                 && value_available_contents_eq (val, 0, entryval, 0, len))
+                 && value_available_contents_eq (val, 0, entryval, 0,
+                                                 TYPE_LENGTH (type)))
                {
                  /* Initialize it just to avoid a GCC false warning.  */
                  struct value *val_deref = NULL, *entryval_deref;
@@ -373,12 +396,12 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
 
                  TRY_CATCH (except, RETURN_MASK_ERROR)
                    {
-                     unsigned len_deref;
+                     struct type *type_deref;
 
                      val_deref = coerce_ref (val);
                      if (value_lazy (val_deref))
                        value_fetch_lazy (val_deref);
-                     len_deref = TYPE_LENGTH (value_type (val_deref));
+                     type_deref = value_type (val_deref);
 
                      entryval_deref = coerce_ref (entryval);
                      if (value_lazy (entryval_deref))
@@ -389,7 +412,7 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
                      if (val != val_deref
                          && value_available_contents_eq (val_deref, 0,
                                                          entryval_deref, 0,
-                                                         len_deref))
+                                                     TYPE_LENGTH (type_deref)))
                        val_equal = 1;
                    }
 
@@ -499,20 +522,18 @@ print_frame_args (struct symbol *func, struct frame_info *frame,
   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;
+  struct cleanup *old_chain;
+  struct ui_file *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);
+  stb = mem_fileopen ();
+  old_chain = make_cleanup_ui_file_delete (stb);
 
   if (func)
     {
       struct block *b = SYMBOL_BLOCK_VALUE (func);
-      struct dict_iterator iter;
+      struct block_iterator iter;
       struct symbol *sym;
 
       ALL_BLOCK_SYMBOLS (b, iter, sym)
@@ -909,6 +930,12 @@ set_last_displayed_sal (int valid, struct program_space *pspace,
   last_displayed_addr = addr;
   last_displayed_symtab = symtab;
   last_displayed_line = line;
+  if (valid && pspace == NULL)
+    {
+      clear_last_displayed_sal ();
+      internal_error (__FILE__, __LINE__,
+                     _("Trying to set NULL pspace."));
+    }
 }
 
 /* Forget the last sal we displayed.  */
@@ -999,7 +1026,7 @@ get_last_displayed_sal (struct symtab_and_line *sal)
    corresponding to FRAME.  */
 
 void
-find_frame_funname (struct frame_info *frame, char **funname,
+find_frame_funname (struct frame_info *frame, const char **funname,
                    enum language *funlang, struct symbol **funcp)
 {
   struct symbol *func;
@@ -1095,9 +1122,9 @@ print_frame (struct frame_info *frame, int print_level,
 {
   struct gdbarch *gdbarch = get_frame_arch (frame);
   struct ui_out *uiout = current_uiout;
-  char *funname = NULL;
+  const char *funname = NULL;
   enum language funlang = language_unknown;
-  struct ui_stream *stb;
+  struct ui_file *stb;
   struct cleanup *old_chain, *list_chain;
   struct value_print_options opts;
   struct symbol *func;
@@ -1106,8 +1133,8 @@ print_frame (struct frame_info *frame, int print_level,
 
   pc_p = get_frame_pc_if_available (frame, &pc);
 
-  stb = ui_out_stream_new (uiout);
-  old_chain = make_cleanup_ui_out_stream_delete (stb);
+  stb = mem_fileopen ();
+  old_chain = make_cleanup_ui_file_delete (stb);
 
   find_frame_funname (frame, &funname, &funlang, &func);
 
@@ -1137,7 +1164,7 @@ print_frame (struct frame_info *frame, int print_level,
        ui_out_text (uiout, " in ");
       }
   annotate_frame_function_name ();
-  fprintf_symbol_filtered (stb->stream, funname ? funname : "??",
+  fprintf_symbol_filtered (stb, funname ? funname : "??",
                           funlang, DMGL_ANSI);
   ui_out_field_stream (uiout, "func", stb);
   ui_out_wrap_hint (uiout, "   ");
@@ -1171,19 +1198,21 @@ print_frame (struct frame_info *frame, int print_level,
       QUIT;
     }
   ui_out_text (uiout, ")");
-  if (sal.symtab && sal.symtab->filename)
+  if (sal.symtab)
     {
+      const char *filename_display;
+      
+      filename_display = symtab_to_filename_for_display (sal.symtab);
       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);
+      ui_out_field_string (uiout, "file", filename_display);
       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);
+         ui_out_field_string (uiout, "fullname", fullname);
        }
       annotate_frame_source_file_end ();
       ui_out_text (uiout, ":");
@@ -1192,7 +1221,7 @@ print_frame (struct frame_info *frame, int print_level,
       annotate_frame_source_end ();
     }
 
-  if (pc_p && (!funname || (!sal.symtab || !sal.symtab->filename)))
+  if (pc_p && (funname == NULL || sal.symtab == NULL))
     {
 #ifdef PC_SOLIB
       char *lib = PC_SOLIB (get_frame_pc (frame));
@@ -1242,8 +1271,7 @@ parse_frame_specification_1 (const char *frame_exp, const char *message,
          const char *p;
 
          /* Skip leading white space, bail of EOL.  */
-         while (isspace (*frame_exp))
-           frame_exp++;
+         frame_exp = skip_spaces_const (frame_exp);
          if (!*frame_exp)
            break;
 
@@ -1363,7 +1391,7 @@ frame_info (char *addr_exp, int from_tty)
   struct symtab *s;
   struct frame_info *calling_frame_info;
   int numregs;
-  char *funname = 0;
+  const char *funname = 0;
   enum language funlang = language_unknown;
   const char *pc_regname;
   int selected_frame_p;
@@ -1453,7 +1481,8 @@ frame_info (char *addr_exp, int from_tty)
     }
   wrap_here ("   ");
   if (sal.symtab)
-    printf_filtered (" (%s:%d)", sal.symtab->filename, sal.line);
+    printf_filtered (" (%s:%d)", symtab_to_filename_for_display (sal.symtab),
+                    sal.line);
   puts_filtered ("; ");
   wrap_here ("    ");
   printf_filtered ("saved %s ", pc_regname);
@@ -1721,7 +1750,20 @@ backtrace_command_1 (char *count_exp, int show_locals, int from_tty)
          the frame->prev field gets set to NULL in that case).  */
       print_frame_info (fi, 1, LOCATION, 1);
       if (show_locals)
-       print_frame_local_vars (fi, 1, gdb_stdout);
+       {
+         struct frame_id frame_id = get_frame_id (fi);
+
+         print_frame_local_vars (fi, 1, gdb_stdout);
+
+         /* print_frame_local_vars invalidates FI.  */
+         fi = frame_find_by_id (frame_id);
+         if (fi == NULL)
+           {
+             trailing = NULL;
+             warning (_("Unable to restore previously selected frame."));
+             break;
+           }
+       }
 
       /* Save the last frame to check for error conditions.  */
       trailing = fi;
@@ -1815,7 +1857,7 @@ iterate_over_block_locals (struct block *b,
                           iterate_over_block_arg_local_vars_cb cb,
                           void *cb_data)
 {
-  struct dict_iterator iter;
+  struct block_iterator iter;
   struct symbol *sym;
 
   ALL_BLOCK_SYMBOLS (b, iter, sym)
@@ -1828,6 +1870,8 @@ iterate_over_block_locals (struct block *b,
        case LOC_COMPUTED:
          if (SYMBOL_IS_ARGUMENT (sym))
            break;
+         if (SYMBOL_DOMAIN (sym) == COMMON_BLOCK_DOMAIN)
+           break;
          (*cb) (SYMBOL_PRINT_NAME (sym), sym, cb_data);
          break;
 
@@ -1852,7 +1896,7 @@ static int
 print_block_frame_labels (struct gdbarch *gdbarch, struct block *b,
                          int *have_default, struct ui_file *stream)
 {
-  struct dict_iterator iter;
+  struct block_iterator iter;
   struct symbol *sym;
   int values_printed = 0;
 
@@ -1913,7 +1957,7 @@ iterate_over_block_local_vars (struct block *block,
 
 struct print_variable_and_value_data
 {
-  struct frame_info *frame;
+  struct frame_id frame_id;
   int num_tabs;
   struct ui_file *stream;
   int values_printed;
@@ -1927,12 +1971,28 @@ do_print_variable_and_value (const char *print_name,
                             void *cb_data)
 {
   struct print_variable_and_value_data *p = cb_data;
+  struct frame_info *frame;
+
+  frame = frame_find_by_id (p->frame_id);
+  if (frame == NULL)
+    {
+      warning (_("Unable to restore previously selected frame."));
+      return;
+    }
+
+  print_variable_and_value (print_name, sym, frame, p->stream, p->num_tabs);
+
+  /* print_variable_and_value invalidates FRAME.  */
+  frame = NULL;
 
-  print_variable_and_value (print_name, sym,
-                           p->frame, p->stream, p->num_tabs);
   p->values_printed = 1;
 }
 
+/* Print all variables from the innermost up to the function block of FRAME.
+   Print them with values to STREAM indented by NUM_TABS.
+
+   This function will invalidate FRAME.  */
+
 static void
 print_frame_local_vars (struct frame_info *frame, int num_tabs,
                        struct ui_file *stream)
@@ -1955,7 +2015,7 @@ print_frame_local_vars (struct frame_info *frame, int num_tabs,
       return;
     }
 
-  cb_data.frame = frame;
+  cb_data.frame_id = get_frame_id (frame);
   cb_data.num_tabs = 4 * num_tabs;
   cb_data.stream = stream;
   cb_data.values_printed = 0;
@@ -1964,86 +2024,13 @@ print_frame_local_vars (struct frame_info *frame, int num_tabs,
                                 do_print_variable_and_value,
                                 &cb_data);
 
+  /* do_print_variable_and_value invalidates FRAME.  */
+  frame = NULL;
+
   if (!cb_data.values_printed)
     fprintf_filtered (stream, _("No locals.\n"));
 }
 
-/* Same, but print labels.  */
-
-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;
-  CORE_ADDR pc = get_frame_pc (frame);
-
-  if (block == 0)
-    {
-      fprintf_filtered (stream, "No symbol table info available.\n");
-      return;
-    }
-
-  bl = blockvector_for_pc (BLOCK_END (block) - 4, &index);
-  blocks_printed = alloca (BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
-  memset (blocks_printed, 0, BLOCKVECTOR_NBLOCKS (bl) * sizeof (char));
-
-  while (block != 0)
-    {
-      CORE_ADDR end = BLOCK_END (block) - 4;
-      int last_index;
-
-      if (bl != blockvector_for_pc (end, &index))
-       error (_("blockvector blotch"));
-      if (BLOCKVECTOR_BLOCK (bl, index) != block)
-       error (_("blockvector botch"));
-      last_index = BLOCKVECTOR_NBLOCKS (bl);
-      index += 1;
-
-      /* Don't print out blocks that have gone by.  */
-      while (index < last_index
-            && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < pc)
-       index++;
-
-      while (index < last_index
-            && BLOCK_END (BLOCKVECTOR_BLOCK (bl, index)) < end)
-       {
-         if (blocks_printed[index] == 0)
-           {
-             if (print_block_frame_labels (gdbarch,
-                                           BLOCKVECTOR_BLOCK (bl, index),
-                                           &have_default, stream))
-               values_printed = 1;
-             blocks_printed[index] = 1;
-           }
-         index++;
-       }
-      if (have_default)
-       return;
-      if (values_printed && 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.
-         Also do not continue to the containing function of an inlined
-         function.  */
-      if (BLOCK_FUNCTION (block))
-       break;
-      block = BLOCK_SUPERBLOCK (block);
-    }
-
-  if (!values_printed && !this_level_only)
-    fprintf_filtered (stream, _("No catches.\n"));
-#endif
-}
-
 void
 locals_info (char *args, int from_tty)
 {
@@ -2051,14 +2038,6 @@ locals_info (char *args, int from_tty)
                          0, gdb_stdout);
 }
 
-static void
-catch_info (char *ignore, int from_tty)
-{
-  /* Assume g++ compiled code; old GDB 4.16 behaviour.  */
-  print_frame_label_vars (get_selected_frame (_("No frame selected.")),
-                          0, gdb_stdout);
-}
-
 /* Iterate over all the argument variables in block B.
 
    Returns 1 if any argument was walked; 0 otherwise.  */
@@ -2068,7 +2047,7 @@ iterate_over_block_arg_vars (struct block *b,
                             iterate_over_block_arg_local_vars_cb cb,
                             void *cb_data)
 {
-  struct dict_iterator iter;
+  struct block_iterator iter;
   struct symbol *sym, *sym2;
 
   ALL_BLOCK_SYMBOLS (b, iter, sym)
@@ -2094,6 +2073,11 @@ iterate_over_block_arg_vars (struct block *b,
     }
 }
 
+/* Print all argument variables of the function of FRAME.
+   Print them with values to STREAM.
+
+   This function will invalidate FRAME.  */
+
 static void
 print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
 {
@@ -2114,7 +2098,7 @@ print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
       return;
     }
 
-  cb_data.frame = frame;
+  cb_data.frame_id = get_frame_id (frame);
   cb_data.num_tabs = 0;
   cb_data.stream = gdb_stdout;
   cb_data.values_printed = 0;
@@ -2122,6 +2106,9 @@ print_frame_arg_vars (struct frame_info *frame, struct ui_file *stream)
   iterate_over_block_arg_vars (SYMBOL_BLOCK_VALUE (func),
                               do_print_variable_and_value, &cb_data);
 
+  /* do_print_variable_and_value invalidates FRAME.  */
+  frame = NULL;
+
   if (!cb_data.values_printed)
     fprintf_filtered (stream, _("No arguments.\n"));
 }
@@ -2312,10 +2299,13 @@ down_command (char *count_exp, int from_tty)
 void
 return_command (char *retval_exp, int from_tty)
 {
+  /* Initialize it just to avoid a GCC false warning.  */
+  enum return_value_convention rv_conv = RETURN_VALUE_STRUCT_CONVENTION;
   struct frame_info *thisframe;
   struct gdbarch *gdbarch;
   struct symbol *thisfun;
   struct value *return_value = NULL;
+  struct value *function = NULL;
   const char *query_prefix = "";
 
   thisframe = get_selected_frame ("No selected frame.");
@@ -2345,7 +2335,8 @@ return_command (char *retval_exp, int from_tty)
        return_type = TYPE_TARGET_TYPE (SYMBOL_TYPE (thisfun));
       if (return_type == NULL)
        {
-         if (retval_expr->elts[0].opcode != UNOP_CAST)
+         if (retval_expr->elts[0].opcode != UNOP_CAST
+             && retval_expr->elts[0].opcode != UNOP_CAST_TYPE)
            error (_("Return value type not available for selected "
                     "stack frame.\n"
                     "Please use an explicit cast of the value to return."));
@@ -2360,6 +2351,10 @@ return_command (char *retval_exp, int from_tty)
       if (value_lazy (return_value))
        value_fetch_lazy (return_value);
 
+      if (thisfun != NULL)
+       function = read_var_value (thisfun, thisframe);
+
+      rv_conv = RETURN_VALUE_REGISTER_CONVENTION;
       if (TYPE_CODE (return_type) == TYPE_CODE_VOID)
        /* If the return-type is "void", don't try to find the
            return-value's location.  However, do still evaluate the
@@ -2367,15 +2362,18 @@ return_command (char *retval_exp, int from_tty)
            is discarded, side effects such as "return i++" still
            occur.  */
        return_value = NULL;
-      else if (thisfun != NULL
-              && using_struct_return (gdbarch,
-                                      SYMBOL_TYPE (thisfun), return_type))
+      else if (thisfun != NULL)
        {
-         query_prefix = "The location at which to store the "
-           "function's return value is unknown.\n"
-           "If you continue, the return value "
-           "that you specified will be ignored.\n";
-         return_value = NULL;
+         rv_conv = struct_return_convention (gdbarch, function, return_type);
+         if (rv_conv == RETURN_VALUE_STRUCT_CONVENTION
+             || rv_conv == RETURN_VALUE_ABI_RETURNS_ADDRESS)
+           {
+             query_prefix = "The location at which to store the "
+               "function's return value is unknown.\n"
+               "If you continue, the return value "
+               "that you specified will be ignored.\n";
+             return_value = NULL;
+           }
        }
     }
 
@@ -2404,12 +2402,10 @@ return_command (char *retval_exp, int from_tty)
     {
       struct type *return_type = value_type (return_value);
       struct gdbarch *gdbarch = get_regcache_arch (get_current_regcache ());
-      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, func_type, return_type,
+      gdb_assert (rv_conv != RETURN_VALUE_STRUCT_CONVENTION
+                 && rv_conv != RETURN_VALUE_ABI_RETURNS_ADDRESS);
+      gdbarch_return_value (gdbarch, function, return_type,
                            get_current_regcache (), NULL /*read*/,
                            value_contents (return_value) /*write*/);
     }
@@ -2449,7 +2445,7 @@ func_command (char *arg, int from_tty)
     return;
 
   frame = parse_frame_specification ("0");
-  sals = decode_line_spec (arg, DECODE_LINE_FUNFIRSTLINE);
+  sals = decode_line_with_current_source (arg, DECODE_LINE_FUNFIRSTLINE);
   cleanups = make_cleanup (xfree, sals.sals);
   func_bounds = (struct function_bounds *) xmalloc (
                              sizeof (struct function_bounds) * sals.nelts);
@@ -2615,9 +2611,6 @@ Usage: T <count>\n"));
 Select the stack frame that contains <func>.\n\
 Usage: func <name>\n"));
 
-  add_info ("catch", catch_info,
-           _("Exceptions that can be caught in the current stack frame."));
-
   add_setshow_enum_cmd ("frame-arguments", class_stack,
                        print_frame_arguments_choices, &print_frame_arguments,
                        _("Set printing of non-scalar frame arguments"),