* ax-gdb.c (gen_var_ref): Unconditionally call via computed ops,

	if possible.
	* dwarf2read.c (read_func_scope): Remove old FIXME.
	* eval.c (evaluate_subexp_standard): Check SYMBOL_COMPUTED_OPS,
	not LOC_COMPUTED.
	* findvar.c (symbol_read_needs_frame, default_read_var_value):
	Unconditionally call via computed ops, if possible.
	* printcmd.c (address_info): Unconditionally call via computed ops,
	if possible.
	* stack.c (read_frame_arg): Unconditionally call via computed ops,
	if possible.
	* symtab.c (register_symbol_computed_impl): Sanity check 'ops'.
	* tracepoint.c (scope_info): Unconditionally call via computed ops,
	if possible.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 875f6e071a7b810cd216973d6c18083bf8bfb19f..aee132ee83b7581024166fd0e52ede87ab0f1e6e 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,20 @@
+2013-03-20  Tom Tromey  <tromey@redhat.com>
+
+       * ax-gdb.c (gen_var_ref): Unconditionally call via computed ops,
+       if possible.
+       * dwarf2read.c (read_func_scope): Remove old FIXME.
+       * eval.c (evaluate_subexp_standard): Check SYMBOL_COMPUTED_OPS,
+       not LOC_COMPUTED.
+       * findvar.c (symbol_read_needs_frame, default_read_var_value):
+       Unconditionally call via computed ops, if possible.
+       * printcmd.c (address_info): Unconditionally call via computed ops,
+       if possible.
+       * stack.c (read_frame_arg): Unconditionally call via computed ops,
+       if possible.
+       * symtab.c (register_symbol_computed_impl): Sanity check 'ops'.
+       * tracepoint.c (scope_info): Unconditionally call via computed ops,
+       if possible.
+
 2013-03-20  Jan Kratochvil  <jan.kratochvil@redhat.com>
            Tom Tromey  <tromey@redhat.com>
 

diff --git a/gdb/ax-gdb.c b/gdb/ax-gdb.c
index 93c87e7e396aa0018e8b9ba9378c0992d09bc92f..25179ad91db4621c4eda7be47d226cb497b40b2e 100644 (file)
--- a/gdb/ax-gdb.c
+++ b/gdb/ax-gdb.c
@@ -662,6 +662,12 @@ gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
   value->type = check_typedef (SYMBOL_TYPE (var));
   value->optimized_out = 0;
 
+  if (SYMBOL_COMPUTED_OPS (var) != NULL)
+    {
+      SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, gdbarch, ax, value);
+      return;
+    }
+
   /* I'm imitating the code in read_var_value.  */
   switch (SYMBOL_CLASS (var))
     {
@@ -750,13 +756,7 @@ gen_var_ref (struct gdbarch *gdbarch, struct agent_expr *ax,
       break;
 
     case LOC_COMPUTED:
-      /* FIXME: cagney/2004-01-26: It should be possible to
-        unconditionally call the SYMBOL_COMPUTED_OPS method when available.
-        Unfortunately DWARF 2 stores the frame-base (instead of the
-        function) location in a function's symbol.  Oops!  For the
-        moment enable this when/where applicable.  */
-      SYMBOL_COMPUTED_OPS (var)->tracepoint_var_ref (var, gdbarch, ax, value);
-      break;
+      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 
     case LOC_OPTIMIZED_OUT:
       /* Flag this, but don't say anything; leave it up to callers to

diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c
index 9c99a887e8865d62fcb979ed443c6ed1209991a5..4c244622ef4ff36ee2ce739ee898604c41185c21 100644 (file)
--- a/gdb/dwarf2read.c
+++ b/gdb/dwarf2read.c
@@ -9522,15 +9522,6 @@ read_func_scope (struct die_info *die, struct dwarf2_cu *cu)
      it.  */
   attr = dwarf2_attr (die, DW_AT_frame_base, cu);
   if (attr)
-    /* FIXME: cagney/2004-01-26: The DW_AT_frame_base's location
-       expression is being recorded directly in the function's symbol
-       and not in a separate frame-base object.  I guess this hack is
-       to avoid adding some sort of frame-base adjunct/annex to the
-       function's symbol :-(.  The problem with doing this is that it
-       results in a function symbol with a location expression that
-       has nothing to do with the location of the function, ouch!  The
-       relationship should be: a function's symbol has-a frame base; a
-       frame-base has-a location expression.  */
     dwarf2_symbol_mark_computed (attr, new->name, cu, 1);
 
   cu->list_in_scope = &local_symbols;

diff --git a/gdb/eval.c b/gdb/eval.c
index 58c9e15a57dbfed5b6a6360a0928d8a7d67354cc..146840e7843d61a8bf7d3fe2f4ccc38f436eb6ff 100644 (file)
--- a/gdb/eval.c
+++ b/gdb/eval.c
@@ -792,7 +792,7 @@ evaluate_subexp_standard (struct type *expect_type,
        if (noside == EVAL_AVOID_SIDE_EFFECTS)
          return value_zero (SYMBOL_TYPE (sym), not_lval);
 
-       if (SYMBOL_CLASS (sym) != LOC_COMPUTED
+       if (SYMBOL_COMPUTED_OPS (sym) == NULL
            || SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry == NULL)
          error (_("Symbol \"%s\" does not have any specific entry value"),
                 SYMBOL_PRINT_NAME (sym));

diff --git a/gdb/findvar.c b/gdb/findvar.c
index fb66e0fa29d0627a5e79d94fd43fbb50c2a38b17..22be47a887c0ea02b7826fe6d2945888c3e33f67 100644 (file)
--- a/gdb/findvar.c
+++ b/gdb/findvar.c
@@ -367,17 +367,15 @@ address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type,
 int
 symbol_read_needs_frame (struct symbol *sym)
 {
+  if (SYMBOL_COMPUTED_OPS (sym) != NULL)
+    return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
+
   switch (SYMBOL_CLASS (sym))
     {
       /* All cases listed explicitly so that gcc -Wall will detect it if
          we failed to consider one.  */
     case LOC_COMPUTED:
-      /* FIXME: cagney/2004-01-26: It should be possible to
-        unconditionally call the SYMBOL_COMPUTED_OPS method when available.
-        Unfortunately DWARF 2 stores the frame-base (instead of the
-        function) location in a function's symbol.  Oops!  For the
-        moment enable this when/where applicable.  */
-      return SYMBOL_COMPUTED_OPS (sym)->read_needs_frame (sym);
+      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 
     case LOC_REGISTER:
     case LOC_ARG:
@@ -456,6 +454,9 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
   if (symbol_read_needs_frame (var))
     gdb_assert (frame);
 
+  if (SYMBOL_COMPUTED_OPS (var) != NULL)
+    return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
+
   switch (SYMBOL_CLASS (var))
     {
     case LOC_CONST:
@@ -578,12 +579,7 @@ default_read_var_value (struct symbol *var, struct frame_info *frame)
       break;
 
     case LOC_COMPUTED:
-      /* FIXME: cagney/2004-01-26: It should be possible to
-        unconditionally call the SYMBOL_COMPUTED_OPS method when available.
-        Unfortunately DWARF 2 stores the frame-base (instead of the
-        function) location in a function's symbol.  Oops!  For the
-        moment enable this when/where applicable.  */
-      return SYMBOL_COMPUTED_OPS (var)->read_variable (var, frame);
+      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 
     case LOC_UNRESOLVED:
       {

diff --git a/gdb/printcmd.c b/gdb/printcmd.c
index 3e1d0265356bba584faeeaf275225fbd35d09577..7decc397a7a6790633343a659391dcd8188ab5d0 100644 (file)
--- a/gdb/printcmd.c
+++ b/gdb/printcmd.c
@@ -1251,6 +1251,14 @@ address_info (char *exp, int from_tty)
   section = SYMBOL_OBJ_SECTION (sym);
   gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
 
+  if (SYMBOL_COMPUTED_OPS (sym) != NULL)
+    {
+      SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
+                                                   gdb_stdout);
+      printf_filtered (".\n");
+      return;
+    }
+
   switch (SYMBOL_CLASS (sym))
     {
     case LOC_CONST:
@@ -1273,14 +1281,7 @@ address_info (char *exp, int from_tty)
       break;
 
     case LOC_COMPUTED:
-      /* FIXME: cagney/2004-01-26: It should be possible to
-        unconditionally call the SYMBOL_COMPUTED_OPS method when available.
-        Unfortunately DWARF 2 stores the frame-base (instead of the
-        function) location in a function's symbol.  Oops!  For the
-        moment enable this when/where applicable.  */
-      SYMBOL_COMPUTED_OPS (sym)->describe_location (sym, context_pc,
-                                                   gdb_stdout);
-      break;
+      gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
 
     case LOC_REGISTER:
       /* GDBARCH is the architecture associated with the objfile the symbol

diff --git a/gdb/stack.c b/gdb/stack.c
index f2aeb101bf90a3c2fc619b48d1cbe0acf9753e51..9ac3123f7610e6a89689618e98dd45496d6ff885 100644 (file)
--- a/gdb/stack.c
+++ b/gdb/stack.c
@@ -323,7 +323,8 @@ read_frame_arg (struct symbol *sym, struct frame_info *frame,
        }
     }
 
-  if (SYMBOL_CLASS (sym) == LOC_COMPUTED
+  if (SYMBOL_COMPUTED_OPS (sym) != NULL
+      && SYMBOL_COMPUTED_OPS (sym)->read_variable_at_entry != NULL
       && print_entry_values != print_entry_values_no
       && (print_entry_values != print_entry_values_if_needed
          || !val || value_optimized_out (val)))

diff --git a/gdb/symtab.c b/gdb/symtab.c
index a46cdb81f1e9eae2b91dbc5b36c3d3e633e8f3a0..51e920ee88addd51eb7e6941e5e820f23cf1c4ba 100644 (file)
--- a/gdb/symtab.c
+++ b/gdb/symtab.c
@@ -5053,6 +5053,13 @@ register_symbol_computed_impl (enum address_class aclass,
   symbol_impl[result].aclass = aclass;
   symbol_impl[result].ops_computed = ops;
 
+  /* Sanity check OPS.  */
+  gdb_assert (ops != NULL);
+  gdb_assert (ops->tracepoint_var_ref != NULL);
+  gdb_assert (ops->describe_location != NULL);
+  gdb_assert (ops->read_needs_frame != NULL);
+  gdb_assert (ops->read_variable != NULL);
+
   return result;
 }
 

diff --git a/gdb/tracepoint.c b/gdb/tracepoint.c
index a33905a479c86229782561b5a9d7007a69319002..66533f72c4326e256d3c1704814f4b6aeabedfef 100644 (file)
--- a/gdb/tracepoint.c
+++ b/gdb/tracepoint.c
@@ -2678,101 +2678,107 @@ scope_info (char *args, int from_tty)
          gdbarch = get_objfile_arch (SYMBOL_SYMTAB (sym)->objfile);
 
          printf_filtered ("Symbol %s is ", symname);
-         switch (SYMBOL_CLASS (sym))
+
+         if (SYMBOL_COMPUTED_OPS (sym) != NULL)
+           SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
+                                                         BLOCK_START (block),
+                                                         gdb_stdout);
+         else
            {
-           default:
-           case LOC_UNDEF:     /* Messed up symbol?  */
-             printf_filtered ("a bogus symbol, class %d.\n",
-                              SYMBOL_CLASS (sym));
-             count--;          /* Don't count this one.  */
-             continue;
-           case LOC_CONST:
-             printf_filtered ("a constant with value %s (%s)",
-                              plongest (SYMBOL_VALUE (sym)),
-                              hex_string (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_CONST_BYTES:
-             printf_filtered ("constant bytes: ");
-             if (SYMBOL_TYPE (sym))
-               for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
-                 fprintf_filtered (gdb_stdout, " %02x",
-                                   (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
-             break;
-           case LOC_STATIC:
-             printf_filtered ("in static storage at address ");
-             printf_filtered ("%s", paddress (gdbarch,
-                                              SYMBOL_VALUE_ADDRESS (sym)));
-             break;
-           case LOC_REGISTER:
-             /* GDBARCH is the architecture associated with the objfile
-                the symbol is defined in; the target architecture may be
-                different, and may provide additional registers.  However,
-                we do not know the target architecture at this point.
-                We assume the objfile architecture will contain all the
-                standard registers that occur in debug info in that
-                objfile.  */
-             regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
-                                                                 gdbarch);
-
-             if (SYMBOL_IS_ARGUMENT (sym))
-               printf_filtered ("an argument in register $%s",
-                                gdbarch_register_name (gdbarch, regno));
-             else
-               printf_filtered ("a local variable in register $%s",
-                                gdbarch_register_name (gdbarch, regno));
-             break;
-           case LOC_ARG:
-             printf_filtered ("an argument at stack/frame offset %s",
-                              plongest (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_LOCAL:
-             printf_filtered ("a local variable at frame offset %s",
-                              plongest (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_REF_ARG:
-             printf_filtered ("a reference argument at offset %s",
-                              plongest (SYMBOL_VALUE (sym)));
-             break;
-           case LOC_REGPARM_ADDR:
-             /* Note comment at LOC_REGISTER.  */
-             regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
-                                                                 gdbarch);
-             printf_filtered ("the address of an argument, in register $%s",
-                              gdbarch_register_name (gdbarch, regno));
-             break;
-           case LOC_TYPEDEF:
-             printf_filtered ("a typedef.\n");
-             continue;
-           case LOC_LABEL:
-             printf_filtered ("a label at address ");
-             printf_filtered ("%s", paddress (gdbarch,
-                                              SYMBOL_VALUE_ADDRESS (sym)));
-             break;
-           case LOC_BLOCK:
-             printf_filtered ("a function at address ");
-             printf_filtered ("%s",
-               paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
-             break;
-           case LOC_UNRESOLVED:
-             msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
-                                           NULL, NULL);
-             if (msym == NULL)
-               printf_filtered ("Unresolved Static");
-             else
+             switch (SYMBOL_CLASS (sym))
                {
-                 printf_filtered ("static storage at address ");
+               default:
+               case LOC_UNDEF: /* Messed up symbol?  */
+                 printf_filtered ("a bogus symbol, class %d.\n",
+                                  SYMBOL_CLASS (sym));
+                 count--;              /* Don't count this one.  */
+                 continue;
+               case LOC_CONST:
+                 printf_filtered ("a constant with value %s (%s)",
+                                  plongest (SYMBOL_VALUE (sym)),
+                                  hex_string (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_CONST_BYTES:
+                 printf_filtered ("constant bytes: ");
+                 if (SYMBOL_TYPE (sym))
+                   for (j = 0; j < TYPE_LENGTH (SYMBOL_TYPE (sym)); j++)
+                     fprintf_filtered (gdb_stdout, " %02x",
+                                       (unsigned) SYMBOL_VALUE_BYTES (sym)[j]);
+                 break;
+               case LOC_STATIC:
+                 printf_filtered ("in static storage at address ");
+                 printf_filtered ("%s", paddress (gdbarch,
+                                                  SYMBOL_VALUE_ADDRESS (sym)));
+                 break;
+               case LOC_REGISTER:
+                 /* GDBARCH is the architecture associated with the objfile
+                    the symbol is defined in; the target architecture may be
+                    different, and may provide additional registers.  However,
+                    we do not know the target architecture at this point.
+                    We assume the objfile architecture will contain all the
+                    standard registers that occur in debug info in that
+                    objfile.  */
+                 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
+                                                                     gdbarch);
+
+                 if (SYMBOL_IS_ARGUMENT (sym))
+                   printf_filtered ("an argument in register $%s",
+                                    gdbarch_register_name (gdbarch, regno));
+                 else
+                   printf_filtered ("a local variable in register $%s",
+                                    gdbarch_register_name (gdbarch, regno));
+                 break;
+               case LOC_ARG:
+                 printf_filtered ("an argument at stack/frame offset %s",
+                                  plongest (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_LOCAL:
+                 printf_filtered ("a local variable at frame offset %s",
+                                  plongest (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_REF_ARG:
+                 printf_filtered ("a reference argument at offset %s",
+                                  plongest (SYMBOL_VALUE (sym)));
+                 break;
+               case LOC_REGPARM_ADDR:
+                 /* Note comment at LOC_REGISTER.  */
+                 regno = SYMBOL_REGISTER_OPS (sym)->register_number (sym,
+                                                                     gdbarch);
+                 printf_filtered ("the address of an argument, in register $%s",
+                                  gdbarch_register_name (gdbarch, regno));
+                 break;
+               case LOC_TYPEDEF:
+                 printf_filtered ("a typedef.\n");
+                 continue;
+               case LOC_LABEL:
+                 printf_filtered ("a label at address ");
+                 printf_filtered ("%s", paddress (gdbarch,
+                                                  SYMBOL_VALUE_ADDRESS (sym)));
+                 break;
+               case LOC_BLOCK:
+                 printf_filtered ("a function at address ");
                  printf_filtered ("%s",
-                   paddress (gdbarch, SYMBOL_VALUE_ADDRESS (msym)));
+                                  paddress (gdbarch, BLOCK_START (SYMBOL_BLOCK_VALUE (sym))));
+                 break;
+               case LOC_UNRESOLVED:
+                 msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym),
+                                               NULL, NULL);
+                 if (msym == NULL)
+                   printf_filtered ("Unresolved Static");
+                 else
+                   {
+                     printf_filtered ("static storage at address ");
+                     printf_filtered ("%s",
+                                      paddress (gdbarch,
+                                                SYMBOL_VALUE_ADDRESS (msym)));
+                   }
+                 break;
+               case LOC_OPTIMIZED_OUT:
+                 printf_filtered ("optimized out.\n");
+                 continue;
+               case LOC_COMPUTED:
+                 gdb_assert_not_reached (_("LOC_COMPUTED variable missing a method"));
                }
-             break;
-           case LOC_OPTIMIZED_OUT:
-             printf_filtered ("optimized out.\n");
-             continue;
-           case LOC_COMPUTED:
-             SYMBOL_COMPUTED_OPS (sym)->describe_location (sym,
-                                                           BLOCK_START (block),
-                                                           gdb_stdout);
-             break;
            }
          if (SYMBOL_TYPE (sym))
            printf_filtered (", length %d.\n",