gdb
authorTom Tromey <tromey@redhat.com>
Mon, 29 Nov 2010 21:18:16 +0000 (21:18 +0000)
committerTom Tromey <tromey@redhat.com>
Mon, 29 Nov 2010 21:18:16 +0000 (21:18 +0000)
* opencl-lang.c (lval_func_check_synthetic_pointer): New
function.
* value.h (struct lval_funcs) <indirect, check_synthetic_pointer>:
New fields.
(value_bits_synthetic_pointer): Declare.
* value.c (value_bits_synthetic_pointer): New function.
* valprint.c (valprint_check_validity): Handle synthetic
pointers.
* valops.c (value_ind): Use new 'indirect' lval_funcs method.
* valarith.c (value_ptradd): Use set_value_component_location.
* p-valprint.c (pascal_object_print_value_fields): Handle
synthetic pointers.
* jv-valprint.c (java_print_value_fields): Handle synthetic
pointers.
* dwarf2read.c (dwarf_stack_op_name): Add
DW_OP_GNU_implicit_pointer.
(dwarf2_fetch_die_location_block): Add get_frame_pc, baton
arguments.  Handle location lists.
(fill_in_loclist_baton): New function.
(dwarf2_symbol_mark_computed): Use it.
* dwarf2loc.h (dwarf2_find_location_expression): Declare.
(dwarf2_fetch_die_location_block): Add get_frame_pc, baton
arguments.
* dwarf2loc.c (dwarf2_find_location_expression): Rename from
find_location_expression.  No longer static.  Update all callers.
(dwarf_expr_frame_pc): New function.
(per_cu_dwarf_call): Add get_frame_pc, baton arguments.  Update
all callers.
(struct piece_closure) <per_cu>: New field.
(allocate_piece_closure): Add per_cu argument.
(read_pieced_value): Handle DWARF_VALUE_IMPLICIT_POINTER.
(check_pieced_value_bits): Remove validity argument, add check_for
argument.  Handle DWARF_VALUE_IMPLICIT_POINTER.
(check_pieced_value_validity, check_pieced_value_invalid):
Update.
(check_pieced_synthetic_pointer): New function.
(get_frame_address_in_block_wrapper): New function.
(indirect_pieced_value): New function.
(pieced_value_funcs): Update.
(invalid_synthetic_pointer): New function.
(dwarf2_evaluate_loc_desc_full): Rename from
dwarf2_evaluate_loc_desc.  Add byte_offset argument.
(dwarf2_evaluate_loc_desc): Rewrite.
(dwarf2_loc_desc_needs_frame): Set new field on context.
(get_ax_pc): New function.
(disassemble_dwarf_expression): Handle
DW_OP_GNU_implicit_pointer.
* dwarf2expr.h (enum dwarf_value_location)
<DWARF_VALUE_IMPLICIT_POINTER>: New constant.
(struct dwarf_expr_context) <get_frame_pc>: New field.
(struct dwarf_expr_piece) <v.ptr>: New field.
* dwarf2expr.c (add_piece): Handle DWARF_VALUE_IMPLICIT_POINTER.
(execute_stack_op): Handle DW_OP_GNU_implicit_pointer.
* dwarf2-frame.c (no_get_frame_pc): New function.
(execute_stack_op): Set new field on context.
* cp-valprint.c (cp_print_value_fields): Handle synthetic
pointers.
gdb/testsuite
* gdb.dwarf2/implptr.exp: New file.
* gdb.dwarf2/implptr.c: New file.
* gdb.dwarf2/implptr.S: New file.

20 files changed:
gdb/ChangeLog
gdb/cp-valprint.c
gdb/dwarf2-frame.c
gdb/dwarf2expr.c
gdb/dwarf2expr.h
gdb/dwarf2loc.c
gdb/dwarf2loc.h
gdb/dwarf2read.c
gdb/jv-valprint.c
gdb/opencl-lang.c
gdb/p-valprint.c
gdb/testsuite/ChangeLog
gdb/testsuite/gdb.dwarf2/implptr.S [new file with mode: 0644]
gdb/testsuite/gdb.dwarf2/implptr.c [new file with mode: 0644]
gdb/testsuite/gdb.dwarf2/implptr.exp [new file with mode: 0644]
gdb/valarith.c
gdb/valops.c
gdb/valprint.c
gdb/value.c
gdb/value.h

index 51961a3952ffffdfa878fd2a7ac0c156c782c565..d5a283bae66776c22a48d91a2a59063834adf746 100644 (file)
@@ -1,3 +1,63 @@
+2010-11-29  Tom Tromey  <tromey@redhat.com>
+
+       * opencl-lang.c (lval_func_check_synthetic_pointer): New
+       function.
+       * value.h (struct lval_funcs) <indirect, check_synthetic_pointer>:
+       New fields.
+       (value_bits_synthetic_pointer): Declare.
+       * value.c (value_bits_synthetic_pointer): New function.
+       * valprint.c (valprint_check_validity): Handle synthetic
+       pointers.
+       * valops.c (value_ind): Use new 'indirect' lval_funcs method.
+       * valarith.c (value_ptradd): Use set_value_component_location.
+       * p-valprint.c (pascal_object_print_value_fields): Handle
+       synthetic pointers.
+       * jv-valprint.c (java_print_value_fields): Handle synthetic
+       pointers.
+       * dwarf2read.c (dwarf_stack_op_name): Add
+       DW_OP_GNU_implicit_pointer.
+       (dwarf2_fetch_die_location_block): Add get_frame_pc, baton
+       arguments.  Handle location lists.
+       (fill_in_loclist_baton): New function.
+       (dwarf2_symbol_mark_computed): Use it.
+       * dwarf2loc.h (dwarf2_find_location_expression): Declare.
+       (dwarf2_fetch_die_location_block): Add get_frame_pc, baton
+       arguments.
+       * dwarf2loc.c (dwarf2_find_location_expression): Rename from
+       find_location_expression.  No longer static.  Update all callers.
+       (dwarf_expr_frame_pc): New function.
+       (per_cu_dwarf_call): Add get_frame_pc, baton arguments.  Update
+       all callers.
+       (struct piece_closure) <per_cu>: New field.
+       (allocate_piece_closure): Add per_cu argument.
+       (read_pieced_value): Handle DWARF_VALUE_IMPLICIT_POINTER.
+       (check_pieced_value_bits): Remove validity argument, add check_for
+       argument.  Handle DWARF_VALUE_IMPLICIT_POINTER.
+       (check_pieced_value_validity, check_pieced_value_invalid):
+       Update.
+       (check_pieced_synthetic_pointer): New function.
+       (get_frame_address_in_block_wrapper): New function.
+       (indirect_pieced_value): New function.
+       (pieced_value_funcs): Update.
+       (invalid_synthetic_pointer): New function.
+       (dwarf2_evaluate_loc_desc_full): Rename from
+       dwarf2_evaluate_loc_desc.  Add byte_offset argument.
+       (dwarf2_evaluate_loc_desc): Rewrite.
+       (dwarf2_loc_desc_needs_frame): Set new field on context.
+       (get_ax_pc): New function.
+       (disassemble_dwarf_expression): Handle
+       DW_OP_GNU_implicit_pointer.
+       * dwarf2expr.h (enum dwarf_value_location)
+       <DWARF_VALUE_IMPLICIT_POINTER>: New constant.
+       (struct dwarf_expr_context) <get_frame_pc>: New field.
+       (struct dwarf_expr_piece) <v.ptr>: New field.
+       * dwarf2expr.c (add_piece): Handle DWARF_VALUE_IMPLICIT_POINTER.
+       (execute_stack_op): Handle DW_OP_GNU_implicit_pointer.
+       * dwarf2-frame.c (no_get_frame_pc): New function.
+       (execute_stack_op): Set new field on context.
+       * cp-valprint.c (cp_print_value_fields): Handle synthetic
+       pointers.
+
 2010-11-29  Phil Muldoon  <pmuldoon@redhat.com>
 
         PR python/12199
index 5f47ec4d9100d26b3e69bd6f843df177a8d192b2..e65c12bbd7f2b612887500bc2e8589349bf8120d 100644 (file)
@@ -289,6 +289,14 @@ cp_print_value_fields (struct type *type, struct type *real_type,
                {
                  fputs_filtered ("<optimized out or zero length>", stream);
                }
+             else if (value_bits_synthetic_pointer (val,
+                                                    TYPE_FIELD_BITPOS (type,
+                                                                       i),
+                                                    TYPE_FIELD_BITSIZE (type,
+                                                                        i)))
+               {
+                 fputs_filtered (_("<synthetic pointer>"), stream);
+               }
              else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
                                          TYPE_FIELD_BITSIZE (type, i)))
                {
index d7d8b9734e77c6e4d1cce1636d27527366076afa..d09a3772bd1be6188980905e67a12d6fcc3c9e50 100644 (file)
@@ -325,6 +325,15 @@ no_get_frame_cfa (void *baton)
                  _("Support for DW_OP_call_frame_cfa is unimplemented"));
 }
 
+/* Helper function for execute_stack_op.  */
+
+static CORE_ADDR
+no_get_frame_pc (void *baton)
+{
+  internal_error (__FILE__, __LINE__,
+                 _("Support for DW_OP_GNU_implicit_pointer is unimplemented"));
+}
+
 static CORE_ADDR
 no_get_tls_address (void *baton, CORE_ADDR offset)
 {
@@ -391,6 +400,7 @@ execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
   ctx->read_mem = read_mem;
   ctx->get_frame_base = no_get_frame_base;
   ctx->get_frame_cfa = no_get_frame_cfa;
+  ctx->get_frame_pc = no_get_frame_pc;
   ctx->get_tls_address = no_get_tls_address;
   ctx->dwarf_call = no_dwarf_call;
 
index b9ae108c5ffecd3a943711d5a52d1de66363e433..29bfcf40884bd10d376ada2b422cb7d63580b6d8 100644 (file)
@@ -233,6 +233,11 @@ add_piece (struct dwarf_expr_context *ctx, ULONGEST size, ULONGEST offset)
       p->v.mem.addr = dwarf_expr_fetch_address (ctx, 0);
       p->v.mem.in_stack_memory = dwarf_expr_fetch_in_stack_memory (ctx, 0);
     }
+  else if (p->location == DWARF_VALUE_IMPLICIT_POINTER)
+    {
+      p->v.ptr.die = ctx->len;
+      p->v.ptr.offset = (LONGEST) dwarf_expr_fetch (ctx, 0);
+    }
   else
     {
       p->v.value = dwarf_expr_fetch (ctx, 0);
@@ -527,6 +532,26 @@ execute_stack_op (struct dwarf_expr_context *ctx,
          dwarf_expr_require_composition (op_ptr, op_end, "DW_OP_stack_value");
          goto no_push;
 
+       case DW_OP_GNU_implicit_pointer:
+         {
+           ULONGEST die;
+           LONGEST len;
+
+           /* The referred-to DIE.  */
+           ctx->len = extract_unsigned_integer (op_ptr, ctx->addr_size,
+                                                byte_order);
+           op_ptr += ctx->addr_size;
+
+           /* The byte offset into the data.  */
+           op_ptr = read_sleb128 (op_ptr, op_end, &len);
+           result = (ULONGEST) len;
+
+           ctx->location = DWARF_VALUE_IMPLICIT_POINTER;
+           dwarf_expr_require_composition (op_ptr, op_end,
+                                           "DW_OP_GNU_implicit_pointer");
+         }
+         break;
+
        case DW_OP_breg0:
        case DW_OP_breg1:
        case DW_OP_breg2:
@@ -884,6 +909,12 @@ execute_stack_op (struct dwarf_expr_context *ctx,
     no_push:;
     }
 
+  /* To simplify our main caller, if the result is an implicit
+     pointer, then make a pieced value.  This is ok because we can't
+     have implicit pointers in contexts where pieces are invalid.  */
+  if (ctx->location == DWARF_VALUE_IMPLICIT_POINTER)
+    add_piece (ctx, 8 * ctx->addr_size, 0);
+
   ctx->recursion_depth--;
   gdb_assert (ctx->recursion_depth >= 0);
 #undef sign_ext
index 61b8f003303eba6640f23475fb06cb4dce397457..68cc667ff9e1f1a074c9fccbb2125fd4690354d0 100644 (file)
@@ -41,7 +41,10 @@ enum dwarf_value_location
   DWARF_VALUE_LITERAL,
 
   /* The piece was optimized out.  */
-  DWARF_VALUE_OPTIMIZED_OUT
+  DWARF_VALUE_OPTIMIZED_OUT,
+
+  /* The piece is an implicit pointer.  */
+  DWARF_VALUE_IMPLICIT_POINTER
 };
 
 /* The dwarf expression stack.  */
@@ -96,6 +99,9 @@ struct dwarf_expr_context
   /* Return the CFA for the frame.  */
   CORE_ADDR (*get_frame_cfa) (void *baton);
 
+  /* Return the PC for the frame.  */
+  CORE_ADDR (*get_frame_pc) (void *baton);
+
   /* Return the thread-local storage address for
      DW_OP_GNU_push_tls_address.  */
   CORE_ADDR (*get_tls_address) (void *baton, CORE_ADDR offset);
@@ -120,8 +126,9 @@ struct dwarf_expr_context
   /* Location of the value.  */
   enum dwarf_value_location location;
 
-  /* For VALUE_LITERAL, a the current literal value's length and
-     data.  */
+  /* For DWARF_VALUE_LITERAL, a the current literal value's length and
+     data.  For DWARF_VALUE_IMPLICIT_POINTER, LEN is the offset of the
+     target DIE.  */
   ULONGEST len;
   const gdb_byte *data;
 
@@ -185,6 +192,15 @@ struct dwarf_expr_piece
       /* The length of the available data.  */
       ULONGEST length;
     } literal;
+
+    /* Used for DWARF_VALUE_IMPLICIT_POINTER.  */
+    struct
+    {
+      /* The referent DIE from DW_OP_GNU_implicit_pointer.  */
+      ULONGEST die;
+      /* The byte offset into the resulting data.  */
+      LONGEST offset;
+    } ptr;
   } v;
 
   /* The length of the piece, in bits.  */
index b2aecf253396caee15184bc0d3509230dc5b1d35..f0e08c778ed691083b782b48a63de43c9d7458de 100644 (file)
@@ -48,7 +48,13 @@ static void
 dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
                         const gdb_byte **start, size_t *length);
 
-/* A helper function for dealing with location lists.  Given a
+static struct value *
+dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
+                              const gdb_byte *data, unsigned short size,
+                              struct dwarf2_per_cu_data *per_cu,
+                              LONGEST byte_offset);
+
+/* A function for dealing with location lists.  Given a
    symbol baton (BATON) and a pc value (PC), find the appropriate
    location expression, set *LOCEXPR_LENGTH, and return a pointer
    to the beginning of the expression.  Returns NULL on failure.
@@ -56,9 +62,9 @@ dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
    For now, only return the first matching location expression; there
    can be more than one in the list.  */
 
-static const gdb_byte *
-find_location_expression (struct dwarf2_loclist_baton *baton,
-                         size_t *locexpr_length, CORE_ADDR pc)
+const gdb_byte *
+dwarf2_find_location_expression (struct dwarf2_loclist_baton *baton,
+                                size_t *locexpr_length, CORE_ADDR pc)
 {
   CORE_ADDR low, high;
   const gdb_byte *loc_ptr, *buf_end;
@@ -79,7 +85,7 @@ find_location_expression (struct dwarf2_loclist_baton *baton,
   while (1)
     {
       if (buf_end - loc_ptr < 2 * addr_size)
-       error (_("find_location_expression: Corrupted DWARF expression."));
+       error (_("dwarf2_find_location_expression: Corrupted DWARF expression."));
 
       if (signed_addr_p)
        low = extract_signed_integer (loc_ptr, addr_size, byte_order);
@@ -193,7 +199,7 @@ dwarf_expr_frame_base_1 (struct symbol *framefunc, CORE_ADDR pc,
       struct dwarf2_loclist_baton *symbaton;
 
       symbaton = SYMBOL_LOCATION_BATON (framefunc);
-      *start = find_location_expression (symbaton, length, pc);
+      *start = dwarf2_find_location_expression (symbaton, length, pc);
     }
   else
     {
@@ -225,6 +231,17 @@ dwarf_expr_frame_cfa (void *baton)
   return dwarf2_frame_cfa (debaton->frame);
 }
 
+/* Helper function for dwarf2_evaluate_loc_desc.  Computes the PC for
+   the frame in BATON.  */
+
+static CORE_ADDR
+dwarf_expr_frame_pc (void *baton)
+{
+  struct dwarf_expr_baton *debaton = (struct dwarf_expr_baton *) baton;
+
+  return get_frame_address_in_block (debaton->frame);
+}
+
 /* Using the objfile specified in BATON, find the address for the
    current thread's thread-local storage with offset OFFSET.  */
 static CORE_ADDR
@@ -241,11 +258,14 @@ dwarf_expr_tls_address (void *baton, CORE_ADDR offset)
 
 static void
 per_cu_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset,
-                  struct dwarf2_per_cu_data *per_cu)
+                  struct dwarf2_per_cu_data *per_cu,
+                  CORE_ADDR (*get_frame_pc) (void *baton),
+                  void *baton)
 {
   struct dwarf2_locexpr_baton block;
 
-  block = dwarf2_fetch_die_location_block (die_offset, per_cu);
+  block = dwarf2_fetch_die_location_block (die_offset, per_cu,
+                                          get_frame_pc, baton);
 
   /* DW_OP_call_ref is currently not supported.  */
   gdb_assert (block.per_cu == per_cu);
@@ -260,7 +280,8 @@ dwarf_expr_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
 {
   struct dwarf_expr_baton *debaton = ctx->baton;
 
-  return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu);
+  return per_cu_dwarf_call (ctx, die_offset, debaton->per_cu,
+                           ctx->get_frame_pc, ctx->baton);
 }
 
 struct piece_closure
@@ -268,6 +289,9 @@ struct piece_closure
   /* Reference count.  */
   int refc;
 
+  /* The CU from which this closure's expression came.  */
+  struct dwarf2_per_cu_data *per_cu;
+
   /* The number of pieces used to describe this variable.  */
   int n_pieces;
 
@@ -282,12 +306,14 @@ struct piece_closure
    PIECES.  */
 
 static struct piece_closure *
-allocate_piece_closure (int n_pieces, struct dwarf_expr_piece *pieces,
+allocate_piece_closure (struct dwarf2_per_cu_data *per_cu,
+                       int n_pieces, struct dwarf_expr_piece *pieces,
                        int addr_size)
 {
   struct piece_closure *c = XZALLOC (struct piece_closure);
 
   c->refc = 1;
+  c->per_cu = per_cu;
   c->n_pieces = n_pieces;
   c->addr_size = addr_size;
   c->pieces = XCALLOC (n_pieces, struct dwarf_expr_piece);
@@ -622,6 +648,11 @@ read_pieced_value (struct value *v)
          }
          break;
 
+         /* These bits show up as zeros -- but do not cause the value
+            to be considered optimized-out.  */
+       case DWARF_VALUE_IMPLICIT_POINTER:
+         break;
+
        case DWARF_VALUE_OPTIMIZED_OUT:
          set_value_optimized_out (v, 1);
          break;
@@ -630,7 +661,8 @@ read_pieced_value (struct value *v)
          internal_error (__FILE__, __LINE__, _("invalid location type"));
        }
 
-      if (p->location != DWARF_VALUE_OPTIMIZED_OUT)
+      if (p->location != DWARF_VALUE_OPTIMIZED_OUT
+         && p->location != DWARF_VALUE_IMPLICIT_POINTER)
        copy_bitwise (contents, dest_offset_bits,
                      intermediate_buffer, source_offset_bits % 8,
                      this_size_bits, bits_big_endian);
@@ -785,13 +817,24 @@ write_pieced_value (struct value *to, struct value *from)
   do_cleanups (cleanup);
 }
 
+/* A helper function that checks bit validity in a pieced value.
+   CHECK_FOR indicates the kind of validity checking.
+   DWARF_VALUE_MEMORY means to check whether any bit is valid.
+   DWARF_VALUE_OPTIMIZED_OUT means to check whether any bit is
+   optimized out.
+   DWARF_VALUE_IMPLICIT_POINTER means to check whether the bits are an
+   implicit pointer.  */
+
 static int
 check_pieced_value_bits (const struct value *value, int bit_offset,
-                        int bit_length, int validity)
+                        int bit_length,
+                        enum dwarf_value_location check_for)
 {
   struct piece_closure *c
     = (struct piece_closure *) value_computed_closure (value);
   int i;
+  int validity = (check_for == DWARF_VALUE_MEMORY
+                 || check_for == DWARF_VALUE_IMPLICIT_POINTER);
 
   bit_offset += 8 * value_offset (value);
   if (value_bitsize (value))
@@ -816,7 +859,13 @@ check_pieced_value_bits (const struct value *value, int bit_offset,
       else
        bit_length -= this_size_bits;
 
-      if (p->location == DWARF_VALUE_OPTIMIZED_OUT)
+      if (check_for == DWARF_VALUE_IMPLICIT_POINTER)
+       {
+         if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
+           return 0;
+       }
+      else if (p->location == DWARF_VALUE_OPTIMIZED_OUT
+              || p->location == DWARF_VALUE_IMPLICIT_POINTER)
        {
          if (validity)
            return 0;
@@ -835,14 +884,103 @@ static int
 check_pieced_value_validity (const struct value *value, int bit_offset,
                             int bit_length)
 {
-  return check_pieced_value_bits (value, bit_offset, bit_length, 1);
+  return check_pieced_value_bits (value, bit_offset, bit_length,
+                                 DWARF_VALUE_MEMORY);
 }
 
 static int
 check_pieced_value_invalid (const struct value *value)
 {
   return check_pieced_value_bits (value, 0,
-                                 8 * TYPE_LENGTH (value_type (value)), 0);
+                                 8 * TYPE_LENGTH (value_type (value)),
+                                 DWARF_VALUE_OPTIMIZED_OUT);
+}
+
+/* An implementation of an lval_funcs method to see whether a value is
+   a synthetic pointer.  */
+
+static int
+check_pieced_synthetic_pointer (const struct value *value, int bit_offset,
+                               int bit_length)
+{
+  return check_pieced_value_bits (value, bit_offset, bit_length,
+                                 DWARF_VALUE_IMPLICIT_POINTER);
+}
+
+/* A wrapper function for get_frame_address_in_block.  */
+
+static CORE_ADDR
+get_frame_address_in_block_wrapper (void *baton)
+{
+  return get_frame_address_in_block (baton);
+}
+
+/* An implementation of an lval_funcs method to indirect through a
+   pointer.  This handles the synthetic pointer case when needed.  */
+
+static struct value *
+indirect_pieced_value (struct value *value)
+{
+  struct piece_closure *c
+    = (struct piece_closure *) value_computed_closure (value);
+  struct type *type;
+  struct frame_info *frame;
+  struct dwarf2_locexpr_baton baton;
+  int i, bit_offset, bit_length;
+  struct dwarf_expr_piece *piece = NULL;
+  struct value *result;
+  LONGEST byte_offset;
+
+  type = value_type (value);
+  if (TYPE_CODE (type) != TYPE_CODE_PTR)
+    return NULL;
+
+  bit_length = 8 * TYPE_LENGTH (type);
+  bit_offset = 8 * value_offset (value);
+  if (value_bitsize (value))
+    bit_offset += value_bitpos (value);
+
+  for (i = 0; i < c->n_pieces && bit_length > 0; i++)
+    {
+      struct dwarf_expr_piece *p = &c->pieces[i];
+      size_t this_size_bits = p->size;
+
+      if (bit_offset > 0)
+       {
+         if (bit_offset >= this_size_bits)
+           {
+             bit_offset -= this_size_bits;
+             continue;
+           }
+
+         bit_length -= this_size_bits - bit_offset;
+         bit_offset = 0;
+       }
+      else
+       bit_length -= this_size_bits;
+
+      if (p->location != DWARF_VALUE_IMPLICIT_POINTER)
+       return NULL;
+
+      if (bit_length != 0)
+       error (_("Invalid use of DW_OP_GNU_implicit_pointer"));
+
+      piece = p;
+      break;
+    }
+
+  frame = get_selected_frame (_("No frame selected."));
+  byte_offset = value_as_address (value);
+
+  baton = dwarf2_fetch_die_location_block (piece->v.ptr.die, c->per_cu,
+                                          get_frame_address_in_block_wrapper,
+                                          frame);
+
+  result = dwarf2_evaluate_loc_desc_full (TYPE_TARGET_TYPE (type), frame,
+                                         baton.data, baton.size, baton.per_cu,
+                                         byte_offset);
+
+  return result;
 }
 
 static void *
@@ -873,18 +1011,31 @@ static struct lval_funcs pieced_value_funcs = {
   write_pieced_value,
   check_pieced_value_validity,
   check_pieced_value_invalid,
+  indirect_pieced_value,
+  check_pieced_synthetic_pointer,
   copy_pieced_value_closure,
   free_pieced_value_closure
 };
 
+/* Helper function which throws an error if a synthetic pointer is
+   invalid.  */
+
+static void
+invalid_synthetic_pointer (void)
+{
+  error (_("access outside bounds of object referenced via synthetic pointer"));
+}
+
 /* Evaluate a location description, starting at DATA and with length
-   SIZE, to find the current location of variable of TYPE in the context
-   of FRAME.  */
+   SIZE, to find the current location of variable of TYPE in the
+   context of FRAME.  BYTE_OFFSET is applied after the contents are
+   computed.  */
 
-struct value *
-dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
-                         const gdb_byte *data, unsigned short size,
-                         struct dwarf2_per_cu_data *per_cu)
+static struct value *
+dwarf2_evaluate_loc_desc_full (struct type *type, struct frame_info *frame,
+                              const gdb_byte *data, unsigned short size,
+                              struct dwarf2_per_cu_data *per_cu,
+                              LONGEST byte_offset)
 {
   struct value *retval;
   struct dwarf_expr_baton baton;
@@ -892,6 +1043,9 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
   struct cleanup *old_chain;
   struct objfile *objfile = dwarf2_per_cu_objfile (per_cu);
 
+  if (byte_offset < 0)
+    invalid_synthetic_pointer ();
+
   if (size == 0)
     {
       retval = allocate_value (type);
@@ -914,6 +1068,7 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
   ctx->read_mem = dwarf_expr_read_mem;
   ctx->get_frame_base = dwarf_expr_frame_base;
   ctx->get_frame_cfa = dwarf_expr_frame_cfa;
+  ctx->get_frame_pc = dwarf_expr_frame_pc;
   ctx->get_tls_address = dwarf_expr_tls_address;
   ctx->dwarf_call = dwarf_expr_dwarf_call;
 
@@ -922,11 +1077,19 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
     {
       struct piece_closure *c;
       struct frame_id frame_id = get_frame_id (frame);
+      ULONGEST bit_size = 0;
+      int i;
 
-      c = allocate_piece_closure (ctx->num_pieces, ctx->pieces,
+      for (i = 0; i < ctx->num_pieces; ++i)
+       bit_size += ctx->pieces[i].size;
+      if (8 * (byte_offset + TYPE_LENGTH (type)) > bit_size)
+       invalid_synthetic_pointer ();
+
+      c = allocate_piece_closure (per_cu, ctx->num_pieces, ctx->pieces,
                                  ctx->addr_size);
       retval = allocate_computed_value (type, &pieced_value_funcs, c);
       VALUE_FRAME_ID (retval) = frame_id;
+      set_value_offset (retval, byte_offset);
     }
   else
     {
@@ -938,6 +1101,8 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
            ULONGEST dwarf_regnum = dwarf_expr_fetch (ctx, 0);
            int gdb_regnum = gdbarch_dwarf2_reg_to_regnum (arch, dwarf_regnum);
 
+           if (byte_offset != 0)
+             error (_("cannot use offset on synthetic pointer to register"));
            if (gdb_regnum != -1)
              retval = value_from_register (type, gdb_regnum, frame);
            else
@@ -956,39 +1121,59 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
            set_value_lazy (retval, 1);
            if (in_stack_memory)
              set_value_stack (retval, 1);
-           set_value_address (retval, address);
+           set_value_address (retval, address + byte_offset);
          }
          break;
 
        case DWARF_VALUE_STACK:
          {
            ULONGEST value = dwarf_expr_fetch (ctx, 0);
-           bfd_byte *contents;
+           bfd_byte *contents, *tem;
            size_t n = ctx->addr_size;
 
+           if (byte_offset + TYPE_LENGTH (type) > n)
+             invalid_synthetic_pointer ();
+
+           tem = alloca (n);
+           store_unsigned_integer (tem, n,
+                                   gdbarch_byte_order (ctx->gdbarch),
+                                   value);
+
+           tem += byte_offset;
+           n -= byte_offset;
+
            retval = allocate_value (type);
            contents = value_contents_raw (retval);
            if (n > TYPE_LENGTH (type))
              n = TYPE_LENGTH (type);
-           store_unsigned_integer (contents, n,
-                                   gdbarch_byte_order (ctx->gdbarch),
-                                   value);
+           memcpy (contents, tem, n);
          }
          break;
 
        case DWARF_VALUE_LITERAL:
          {
            bfd_byte *contents;
+           const bfd_byte *data;
            size_t n = ctx->len;
 
+           if (byte_offset + TYPE_LENGTH (type) > n)
+             invalid_synthetic_pointer ();
+
            retval = allocate_value (type);
            contents = value_contents_raw (retval);
+
+           data = ctx->data + byte_offset;
+           n -= byte_offset;
+
            if (n > TYPE_LENGTH (type))
              n = TYPE_LENGTH (type);
-           memcpy (contents, ctx->data, n);
+           memcpy (contents, data, n);
          }
          break;
 
+         /* DWARF_VALUE_IMPLICIT_POINTER was converted to a pieced
+            operation by execute_stack_op.  */
+       case DWARF_VALUE_IMPLICIT_POINTER:
          /* DWARF_VALUE_OPTIMIZED_OUT can't occur in this context --
             it can only be encountered when making a piece.  */
        case DWARF_VALUE_OPTIMIZED_OUT:
@@ -1003,6 +1188,18 @@ dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
 
   return retval;
 }
+
+/* The exported interface to dwarf2_evaluate_loc_desc_full; it always
+   passes 0 as the byte_offset.  */
+
+struct value *
+dwarf2_evaluate_loc_desc (struct type *type, struct frame_info *frame,
+                         const gdb_byte *data, unsigned short size,
+                         struct dwarf2_per_cu_data *per_cu)
+{
+  return dwarf2_evaluate_loc_desc_full (type, frame, data, size, per_cu, 0);
+}
+
 \f
 /* Helper functions and baton for dwarf2_loc_desc_needs_frame.  */
 
@@ -1070,7 +1267,8 @@ needs_frame_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
 {
   struct needs_frame_baton *nf_baton = ctx->baton;
 
-  return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu);
+  return per_cu_dwarf_call (ctx, die_offset, nf_baton->per_cu,
+                           ctx->get_frame_pc, ctx->baton);
 }
 
 /* Return non-zero iff the location expression at DATA (length SIZE)
@@ -1100,6 +1298,7 @@ dwarf2_loc_desc_needs_frame (const gdb_byte *data, unsigned short size,
   ctx->read_mem = needs_frame_read_mem;
   ctx->get_frame_base = needs_frame_frame_base;
   ctx->get_frame_cfa = needs_frame_frame_cfa;
+  ctx->get_frame_pc = needs_frame_frame_cfa;
   ctx->get_tls_address = needs_frame_tls_address;
   ctx->dwarf_call = needs_frame_dwarf_call;
 
@@ -1191,6 +1390,16 @@ access_memory (struct gdbarch *arch, struct agent_expr *expr, ULONGEST nbits)
     }
 }
 
+/* A helper function to return the frame's PC.  */
+
+static CORE_ADDR
+get_ax_pc (void *baton)
+{
+  struct agent_expr *expr = baton;
+
+  return expr->scope;
+}
+
 /* Compile a DWARF location expression to an agent expression.
    
    EXPR is the agent expression we are building.
@@ -1839,7 +2048,8 @@ compile_dwarf_to_ax (struct agent_expr *expr, struct axs_value *loc,
            uoffset = extract_unsigned_integer (op_ptr, size, byte_order);
            op_ptr += size;
 
-           block = dwarf2_fetch_die_location_block (uoffset, per_cu);
+           block = dwarf2_fetch_die_location_block (uoffset, per_cu,
+                                                    get_ax_pc, expr);
 
            /* DW_OP_call_ref is currently not supported.  */
            gdb_assert (block.per_cu == per_cu);
@@ -2305,6 +2515,20 @@ disassemble_dwarf_expression (struct ui_file *stream,
                              pulongest (ul), pulongest (offset));
          }
          break;
+
+       case DW_OP_GNU_implicit_pointer:
+         {
+           ul = extract_unsigned_integer (data, offset_size,
+                                          gdbarch_byte_order (arch));
+           data += offset_size;
+
+           data = read_sleb128 (data, end, &l);
+
+           fprintf_filtered (stream, " DIE %s offset %s",
+                             phex_nz (ul, offset_size),
+                             plongest (l));
+         }
+         break;
        }
 
       fprintf_filtered (stream, "\n");
@@ -2456,10 +2680,9 @@ loclist_read_variable (struct symbol *symbol, struct frame_info *frame)
   struct value *val;
   const gdb_byte *data;
   size_t size;
+  CORE_ADDR pc = frame ? get_frame_address_in_block (frame) : 0;
 
-  data = find_location_expression (dlbaton, &size,
-                                  frame ? get_frame_address_in_block (frame)
-                                  : 0);
+  data = dwarf2_find_location_expression (dlbaton, &size, pc);
   if (data == NULL)
     {
       val = allocate_value (SYMBOL_TYPE (symbol));
@@ -2579,7 +2802,7 @@ loclist_tracepoint_var_ref (struct symbol *symbol, struct gdbarch *gdbarch,
   size_t size;
   unsigned int addr_size = dwarf2_per_cu_addr_size (dlbaton->per_cu);
 
-  data = find_location_expression (dlbaton, &size, ax->scope);
+  data = dwarf2_find_location_expression (dlbaton, &size, ax->scope);
   if (data == NULL || size == 0)
     value->optimized_out = 1;
   else
index a2cfe7fa955083bb37ab0b25d95cd62e0cdea2fe..e94346cea5fe32cd150a47212198ea8c0cc9bb97 100644 (file)
@@ -24,6 +24,7 @@
 struct symbol_computed_ops;
 struct objfile;
 struct dwarf2_per_cu_data;
+struct dwarf2_loclist_baton;
 
 /* This header is private to the DWARF-2 reader.  It is shared between
    dwarf2read.c and dwarf2loc.c.  */
@@ -45,8 +46,16 @@ int dwarf2_per_cu_offset_size (struct dwarf2_per_cu_data *cu);
    offset in the parent objfile.  */
 CORE_ADDR dwarf2_per_cu_text_offset (struct dwarf2_per_cu_data *cu);
 
+/* Find a particular location expression from a location list.  */
+const gdb_byte *dwarf2_find_location_expression
+  (struct dwarf2_loclist_baton *baton,
+   size_t *locexpr_length,
+   CORE_ADDR pc);
+
 struct dwarf2_locexpr_baton dwarf2_fetch_die_location_block
-  (unsigned int offset, struct dwarf2_per_cu_data *per_cu);
+  (unsigned int offset, struct dwarf2_per_cu_data *per_cu,
+   CORE_ADDR (*get_frame_pc) (void *baton),
+   void *baton);
 
 /* Evaluate a location description, starting at DATA and with length
    SIZE, to find the current location of variable of TYPE in the context
index ad8b109f1fab74ed936d7ad5eb42dec5ab1b4e7e..6087c3b3ac291ee038e3b8710f1064acdb467e96 100644 (file)
@@ -1221,6 +1221,10 @@ static int attr_form_is_section_offset (struct attribute *);
 
 static int attr_form_is_constant (struct attribute *);
 
+static void fill_in_loclist_baton (struct dwarf2_cu *cu,
+                                  struct dwarf2_loclist_baton *baton,
+                                  struct attribute *attr);
+
 static void dwarf2_symbol_mark_computed (struct attribute *attr,
                                         struct symbol *sym,
                                         struct dwarf2_cu *cu);
@@ -12572,6 +12576,8 @@ dwarf_stack_op_name (unsigned op, int def)
       return "DW_OP_GNU_push_tls_address";
     case DW_OP_GNU_uninit:
       return "DW_OP_GNU_uninit";
+    case DW_OP_GNU_implicit_pointer:
+      return "DW_OP_GNU_implicit_pointer";
     default:
       return def ? "OP_<unknown>" : NULL;
     }
@@ -13076,13 +13082,17 @@ follow_die_ref (struct die_info *src_die, struct attribute *attr,
 
 struct dwarf2_locexpr_baton
 dwarf2_fetch_die_location_block (unsigned int offset,
-                                struct dwarf2_per_cu_data *per_cu)
+                                struct dwarf2_per_cu_data *per_cu,
+                                CORE_ADDR (*get_frame_pc) (void *baton),
+                                void *baton)
 {
   struct dwarf2_cu *cu = per_cu->cu;
   struct die_info *die;
   struct attribute *attr;
   struct dwarf2_locexpr_baton retval;
 
+  dw2_setup (per_cu->objfile);
+
   die = follow_die_offset (offset, &cu);
   if (!die)
     error (_("Dwarf Error: Cannot find DIE at 0x%x referenced in module %s"),
@@ -13096,6 +13106,18 @@ dwarf2_fetch_die_location_block (unsigned int offset,
       retval.data = NULL;
       retval.size = 0;
     }
+  else if (attr_form_is_section_offset (attr))
+    {
+      struct dwarf2_loclist_baton loclist_baton;
+      CORE_ADDR pc = (*get_frame_pc) (baton);
+      size_t size;
+
+      fill_in_loclist_baton (cu, &loclist_baton, attr);
+
+      retval.data = dwarf2_find_location_expression (&loclist_baton,
+                                                    &size, pc);
+      retval.size = size;
+    }
   else
     {
       if (!attr_form_is_block (attr))
@@ -14119,6 +14141,25 @@ attr_form_is_constant (struct attribute *attr)
     }
 }
 
+/* A helper function that fills in a dwarf2_loclist_baton.  */
+
+static void
+fill_in_loclist_baton (struct dwarf2_cu *cu,
+                      struct dwarf2_loclist_baton *baton,
+                      struct attribute *attr)
+{
+  dwarf2_read_section (dwarf2_per_objfile->objfile,
+                      &dwarf2_per_objfile->loc);
+
+  baton->per_cu = cu->per_cu;
+  gdb_assert (baton->per_cu);
+  /* We don't know how long the location list is, but make sure we
+     don't run off the edge of the section.  */
+  baton->size = dwarf2_per_objfile->loc.size - DW_UNSND (attr);
+  baton->data = dwarf2_per_objfile->loc.buffer + DW_UNSND (attr);
+  baton->base_address = cu->base_address;
+}
+
 static void
 dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
                             struct dwarf2_cu *cu)
@@ -14133,17 +14174,9 @@ dwarf2_symbol_mark_computed (struct attribute *attr, struct symbol *sym,
 
       baton = obstack_alloc (&cu->objfile->objfile_obstack,
                             sizeof (struct dwarf2_loclist_baton));
-      baton->per_cu = cu->per_cu;
-      gdb_assert (baton->per_cu);
 
-      dwarf2_read_section (dwarf2_per_objfile->objfile,
-                          &dwarf2_per_objfile->loc);
+      fill_in_loclist_baton (cu, baton, attr);
 
-      /* We don't know how long the location list is, but make sure we
-        don't run off the edge of the section.  */
-      baton->size = dwarf2_per_objfile->loc.size - DW_UNSND (attr);
-      baton->data = dwarf2_per_objfile->loc.buffer + DW_UNSND (attr);
-      baton->base_address = cu->base_address;
       if (cu->base_known == 0)
        complaint (&symfile_complaints,
                   _("Location list used without specifying the CU base address."));
index 0a2cc538aa3b820ca809c9b67895d1fd95ce8ffb..eff396e0a4fee27f68b350fc8b1f1096236308d8 100644 (file)
@@ -394,6 +394,14 @@ java_print_value_fields (struct type *type, const gdb_byte *valaddr,
                {
                  fputs_filtered ("<optimized out or zero length>", stream);
                }
+             else if (value_bits_synthetic_pointer (val,
+                                                    TYPE_FIELD_BITPOS (type,
+                                                                       i),
+                                                    TYPE_FIELD_BITSIZE (type,
+                                                                        i)))
+               {
+                 fputs_filtered (_("<synthetic pointer>"), stream);
+               }
              else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
                                          TYPE_FIELD_BITSIZE (type, i)))
                {
index 088d49af32c28e6d2c23bbb1ff6a7899a0b508bc..ef0214c4b7910b8c5ed2952e6427c128f9a3331a 100644 (file)
@@ -327,6 +327,43 @@ lval_func_check_any_valid (const struct value *v)
   return 0;
 }
 
+/* Return nonzero if bits in V from OFFSET and LENGTH represent a
+   synthetic pointer.  */
+
+static int
+lval_func_check_synthetic_pointer (const struct value *v,
+                                  int offset, int length)
+{
+  struct lval_closure *c = (struct lval_closure *) value_computed_closure (v);
+  /* Size of the target type in bits.  */
+  int elsize =
+      TYPE_LENGTH (TYPE_TARGET_TYPE (check_typedef (value_type (c->val)))) * 8;
+  int startrest = offset % elsize;
+  int start = offset / elsize;
+  int endrest = (offset + length) % elsize;
+  int end = (offset + length) / elsize;
+  int i;
+
+  if (endrest)
+    end++;
+
+  if (end > c->n)
+    return 0;
+
+  for (i = start; i < end; i++)
+    {
+      int startoffset = (i == start) ? startrest : 0;
+      int length = (i == end) ? endrest : elsize;
+
+      if (!value_bits_synthetic_pointer (c->val,
+                                        c->indices[i] * elsize + startoffset,
+                                        length))
+       return 0;
+    }
+
+  return 1;
+}
+
 static void *
 lval_func_copy_closure (const struct value *v)
 {
@@ -358,6 +395,8 @@ static struct lval_funcs opencl_value_funcs =
     lval_func_write,
     lval_func_check_validity,
     lval_func_check_any_valid,
+    NULL,
+    lval_func_check_synthetic_pointer,
     lval_func_copy_closure,
     lval_func_free_closure
   };
index 44a2d72e5d5eab563fe1983ff98a3f212cf16f49..47663bd08497679225a680154436a97a24130066 100644 (file)
@@ -779,6 +779,14 @@ pascal_object_print_value_fields (struct type *type, const gdb_byte *valaddr,
                {
                  fputs_filtered ("<optimized out or zero length>", stream);
                }
+             else if (value_bits_synthetic_pointer (val,
+                                                    TYPE_FIELD_BITPOS (type,
+                                                                       i),
+                                                    TYPE_FIELD_BITSIZE (type,
+                                                                        i)))
+               {
+                 fputs_filtered (_("<synthetic pointer>"), stream);
+               }
              else if (!value_bits_valid (val, TYPE_FIELD_BITPOS (type, i),
                                          TYPE_FIELD_BITSIZE (type, i)))
                {
index 22c34768c1d8063383736c3abffa9b2c0e0c29a4..3564704c09063a96d0a278143622f2821423742d 100644 (file)
@@ -1,3 +1,9 @@
+2010-11-29  Tom Tromey  <tromey@redhat.com>
+
+       * gdb.dwarf2/implptr.exp: New file.
+       * gdb.dwarf2/implptr.c: New file.
+       * gdb.dwarf2/implptr.S: New file.
+
 2010-11-29  Phil Muldoon  <pmuldoon@redhat.com>
 
         PR python/12199
diff --git a/gdb/testsuite/gdb.dwarf2/implptr.S b/gdb/testsuite/gdb.dwarf2/implptr.S
new file mode 100644 (file)
index 0000000..8ea793c
--- /dev/null
@@ -0,0 +1,882 @@
+       .file   "implptr.c"
+       .text
+.Ltext0:
+       .p2align 4,,15
+       .globl  foo
+       .type   foo, @function
+foo:
+.LFB1:
+       .file 1 "implptr.c"
+       .loc 1 45 0
+       .cfi_startproc
+.LVL0:
+       .loc 1 45 0
+       movl    4(%esp), %eax
+.LVL1:
+.LBB6:
+.LBB7:
+       .loc 1 36 0
+       addl    $1, u
+.LVL2:
+       .loc 1 38 0
+       addl    $1, u+4
+.LVL3:
+       .loc 1 40 0
+       addl    $1, u+8
+.LVL4:
+.LBE7:
+.LBE6:
+.LBB8:
+.LBB9:
+       .loc 1 36 0
+       addl    $1, u+12
+.LVL5:
+       .loc 1 38 0
+       addl    $1, u+16
+.LVL6:
+       .loc 1 40 0
+       addl    $1, u+20
+.LBE9:
+.LBE8:
+       .loc 1 52 0
+       leal    (%eax,%eax,4), %eax
+       .loc 1 53 0
+       ret
+       .cfi_endproc
+.LFE1:
+       .size   foo, .-foo
+       .p2align 4,,15
+       .globl  bar
+       .type   bar, @function
+bar:
+.LFB2:
+       .loc 1 57 0
+       .cfi_startproc
+.LVL7:
+       .loc 1 61 0
+       movl    4(%esp), %eax
+       addl    $1, %eax
+       .loc 1 63 0
+       ret
+       .cfi_endproc
+.LFE2:
+       .size   bar, .-bar
+       .p2align 4,,15
+       .globl  main
+       .type   main, @function
+main:
+.LFB3:
+       .loc 1 66 0
+       .cfi_startproc
+       pushl   %ebx
+       .cfi_def_cfa_offset 8
+       .cfi_offset 3, -8
+       subl    $4, %esp
+       .cfi_def_cfa_offset 12
+       .loc 1 67 0
+       movl    $5, (%esp)
+       call    bar
+       movl    $23, (%esp)
+       movl    %eax, %ebx
+       call    foo
+       .loc 1 68 0
+       addl    $4, %esp
+       .cfi_def_cfa_offset 8
+       .loc 1 67 0
+       addl    %ebx, %eax
+       .loc 1 68 0
+       popl    %ebx
+       .cfi_def_cfa_offset 4
+       .cfi_restore 3
+       ret
+       .cfi_endproc
+.LFE3:
+       .size   main, .-main
+       .comm   u,24,4
+.Letext0:
+       .section        .debug_types,"G",@progbits,wt.ade46b36db7edab6,comdat
+       .long   0x46
+       .value  0x4
+       .long   .Ldebug_abbrev0
+       .byte   0x4
+       .byte   0xad
+       .byte   0xe4
+       .byte   0x6b
+       .byte   0x36
+       .byte   0xdb
+       .byte   0x7e
+       .byte   0xda
+       .byte   0xb6
+       .long   0x1d
+       .uleb128 0x1
+       .byte   0x1
+       .long   .Ldebug_line0
+       .uleb128 0x2
+       .string "S"
+       .byte   0x8
+       .byte   0x1
+       .byte   0x18
+       .long   0x3c
+       .uleb128 0x3
+       .string "x"
+       .byte   0x1
+       .byte   0x1a
+       .long   0x3c
+       .byte   0
+       .uleb128 0x3
+       .string "y"
+       .byte   0x1
+       .byte   0x1a
+       .long   0x42
+       .byte   0x4
+       .byte   0
+       .uleb128 0x4
+       .byte   0x4
+       .long   0x42
+       .uleb128 0x5
+       .byte   0x4
+       .byte   0x5
+       .string "int"
+       .byte   0
+       .section        .debug_info,"",@progbits
+.Ldebug_info0:
+       .long   0x1b6
+       .value  0x4
+       .long   .Ldebug_abbrev0
+       .byte   0x4
+       .uleb128 0x6
+       .long   .LASF1
+       .byte   0x1
+       .long   .LASF2
+       .long   .LASF3
+       .long   .Ltext0
+       .long   .Letext0
+       .long   .Ldebug_line0
+       .uleb128 0x4
+       .byte   0x4
+       .long   0x2b
+       .uleb128 0x5
+       .byte   0x4
+       .byte   0x5
+       .string "int"
+       .uleb128 0x7
+       .string "add"
+       .byte   0x1
+       .byte   0x20
+       .byte   0x3
+       .long   0x5a
+       .uleb128 0x8
+       .string "a"
+       .byte   0x1
+       .byte   0x20
+       .long   0x5a
+       .uleb128 0x8
+       .string "b"
+       .byte   0x1
+       .byte   0x20
+       .long   0x5a
+       .uleb128 0x8
+       .string "c"
+       .byte   0x1
+       .byte   0x20
+       .long   0x2b
+       .byte   0
+       .uleb128 0x9
+       .byte   0x4
+       .byte   0xad
+       .byte   0xe4
+       .byte   0x6b
+       .byte   0x36
+       .byte   0xdb
+       .byte   0x7e
+       .byte   0xda
+       .byte   0xb6
+       .uleb128 0xa
+       .string "foo"
+       .byte   0x1
+       .byte   0x2c
+       .long   0x2b
+       .long   .LFB1
+       .long   .LFE1
+       .uleb128 0x1
+       .byte   0x9c
+       .long   0xff
+       .uleb128 0xb
+       .string "i"
+       .byte   0x1
+       .byte   0x2c
+       .long   0x2b
+       .long   .LLST0
+       .uleb128 0xc
+       .string "j"
+       .byte   0x1
+       .byte   0x2e
+       .long   0x2b
+       .long   .LLST1
+       .uleb128 0xc
+       .string "p"
+       .byte   0x1
+       .byte   0x2f
+       .long   0xff
+       .long   .LLST2
+       .uleb128 0xd
+       .long   0x32
+       .long   .LBB6
+       .long   .LBE6
+       .byte   0x1
+       .byte   0x30
+       .long   0xd3
+       .uleb128 0xe
+       .long   0x50
+       .byte   0
+       .uleb128 0xf
+       .long   0x47
+       .uleb128 0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+151
+       .sleb128 8
+       .uleb128 0x10
+       .long   0x3e
+       .long   .LLST3
+       .byte   0
+       .uleb128 0x11
+       .long   0x32
+       .long   .LBB8
+       .long   .LBE8
+       .byte   0x1
+       .byte   0x33
+       .uleb128 0xe
+       .long   0x50
+       .byte   0x3
+       .uleb128 0xf
+       .long   0x47
+       .uleb128 0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+151
+       .sleb128 8
+       .uleb128 0x10
+       .long   0x3e
+       .long   .LLST4
+       .byte   0
+       .byte   0
+       .uleb128 0x12
+       .byte   0xad
+       .byte   0xe4
+       .byte   0x6b
+       .byte   0x36
+       .byte   0xdb
+       .byte   0x7e
+       .byte   0xda
+       .byte   0xb6
+       .long   0x113
+       .uleb128 0x13
+       .long   0x113
+       .byte   0x1
+       .byte   0
+       .uleb128 0x14
+       .byte   0x4
+       .byte   0x7
+       .long   .LASF0
+       .uleb128 0xa
+       .string "bar"
+       .byte   0x1
+       .byte   0x38
+       .long   0x2b
+       .long   .LFB2
+       .long   .LFE2
+       .uleb128 0x1
+       .byte   0x9c
+       .long   0x170
+       .uleb128 0x15
+       .string "i"
+       .byte   0x1
+       .byte   0x38
+       .long   0x2b
+       .uleb128 0x2
+       .byte   0x91
+       .sleb128 0
+       .uleb128 0x16
+       .string "j"
+       .byte   0x1
+       .byte   0x3a
+       .long   0x25
+       .uleb128 0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+307
+       .sleb128 0
+       .uleb128 0x16
+       .string "k"
+       .byte   0x1
+       .byte   0x3b
+       .long   0x170
+       .uleb128 0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+319
+       .sleb128 0
+       .uleb128 0x16
+       .string "l"
+       .byte   0x1
+       .byte   0x3c
+       .long   0x176
+       .uleb128 0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+335
+       .sleb128 0
+       .byte   0
+       .uleb128 0x4
+       .byte   0x4
+       .long   0x25
+       .uleb128 0x4
+       .byte   0x4
+       .long   0x170
+       .uleb128 0x17
+       .long   .LASF4
+       .byte   0x1
+       .byte   0x41
+       .long   0x2b
+       .long   .LFB3
+       .long   .LFE3
+       .uleb128 0x1
+       .byte   0x9c
+       .uleb128 0x18
+       .long   0x2b
+       .long   0x1a1
+       .uleb128 0x13
+       .long   0x113
+       .byte   0x5
+       .byte   0
+       .uleb128 0x19
+       .string "u"
+       .byte   0x1
+       .byte   0x1d
+       .long   0x191
+       .uleb128 0x1a
+       .string "u"
+       .byte   0x1
+       .byte   0x1d
+       .long   0x191
+       .uleb128 0x5
+       .byte   0x3
+       .long   u
+       .byte   0
+       .section        .debug_abbrev,"",@progbits
+.Ldebug_abbrev0:
+       .uleb128 0x1
+       .uleb128 0x41
+       .byte   0x1
+       .uleb128 0x13
+       .uleb128 0xb
+       .uleb128 0x10
+       .uleb128 0x17
+       .byte   0
+       .byte   0
+       .uleb128 0x2
+       .uleb128 0x13
+       .byte   0x1
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0xb
+       .uleb128 0xb
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x1
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0xd
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x38
+       .uleb128 0xb
+       .byte   0
+       .byte   0
+       .uleb128 0x4
+       .uleb128 0xf
+       .byte   0
+       .uleb128 0xb
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0x5
+       .uleb128 0x24
+       .byte   0
+       .uleb128 0xb
+       .uleb128 0xb
+       .uleb128 0x3e
+       .uleb128 0xb
+       .uleb128 0x3
+       .uleb128 0x8
+       .byte   0
+       .byte   0
+       .uleb128 0x6
+       .uleb128 0x11
+       .byte   0x1
+       .uleb128 0x25
+       .uleb128 0xe
+       .uleb128 0x13
+       .uleb128 0xb
+       .uleb128 0x3
+       .uleb128 0xe
+       .uleb128 0x1b
+       .uleb128 0xe
+       .uleb128 0x11
+       .uleb128 0x1
+       .uleb128 0x12
+       .uleb128 0x1
+       .uleb128 0x10
+       .uleb128 0x17
+       .byte   0
+       .byte   0
+       .uleb128 0x7
+       .uleb128 0x2e
+       .byte   0x1
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x27
+       .uleb128 0x19
+       .uleb128 0x20
+       .uleb128 0xb
+       .uleb128 0x1
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0x8
+       .uleb128 0x5
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0x9
+       .uleb128 0xf
+       .byte   0
+       .uleb128 0xb
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x20
+       .byte   0
+       .byte   0
+       .uleb128 0xa
+       .uleb128 0x2e
+       .byte   0x1
+       .uleb128 0x3f
+       .uleb128 0x19
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x27
+       .uleb128 0x19
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x11
+       .uleb128 0x1
+       .uleb128 0x12
+       .uleb128 0x1
+       .uleb128 0x40
+       .uleb128 0x18
+       .uleb128 0x1
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0xb
+       .uleb128 0x5
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x2
+       .uleb128 0x17
+       .byte   0
+       .byte   0
+       .uleb128 0xc
+       .uleb128 0x34
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x2
+       .uleb128 0x17
+       .byte   0
+       .byte   0
+       .uleb128 0xd
+       .uleb128 0x1d
+       .byte   0x1
+       .uleb128 0x31
+       .uleb128 0x13
+       .uleb128 0x11
+       .uleb128 0x1
+       .uleb128 0x12
+       .uleb128 0x1
+       .uleb128 0x58
+       .uleb128 0xb
+       .uleb128 0x59
+       .uleb128 0xb
+       .uleb128 0x1
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0xe
+       .uleb128 0x5
+       .byte   0
+       .uleb128 0x31
+       .uleb128 0x13
+       .uleb128 0x1c
+       .uleb128 0xb
+       .byte   0
+       .byte   0
+       .uleb128 0xf
+       .uleb128 0x5
+       .byte   0
+       .uleb128 0x31
+       .uleb128 0x13
+       .uleb128 0x2
+       .uleb128 0x18
+       .byte   0
+       .byte   0
+       .uleb128 0x10
+       .uleb128 0x5
+       .byte   0
+       .uleb128 0x31
+       .uleb128 0x13
+       .uleb128 0x2
+       .uleb128 0x17
+       .byte   0
+       .byte   0
+       .uleb128 0x11
+       .uleb128 0x1d
+       .byte   0x1
+       .uleb128 0x31
+       .uleb128 0x13
+       .uleb128 0x11
+       .uleb128 0x1
+       .uleb128 0x12
+       .uleb128 0x1
+       .uleb128 0x58
+       .uleb128 0xb
+       .uleb128 0x59
+       .uleb128 0xb
+       .byte   0
+       .byte   0
+       .uleb128 0x12
+       .uleb128 0x1
+       .byte   0x1
+       .uleb128 0x49
+       .uleb128 0x20
+       .uleb128 0x1
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0x13
+       .uleb128 0x21
+       .byte   0
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x2f
+       .uleb128 0xb
+       .byte   0
+       .byte   0
+       .uleb128 0x14
+       .uleb128 0x24
+       .byte   0
+       .uleb128 0xb
+       .uleb128 0xb
+       .uleb128 0x3e
+       .uleb128 0xb
+       .uleb128 0x3
+       .uleb128 0xe
+       .byte   0
+       .byte   0
+       .uleb128 0x15
+       .uleb128 0x5
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x2
+       .uleb128 0x18
+       .byte   0
+       .byte   0
+       .uleb128 0x16
+       .uleb128 0x34
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x2
+       .uleb128 0x18
+       .byte   0
+       .byte   0
+       .uleb128 0x17
+       .uleb128 0x2e
+       .byte   0
+       .uleb128 0x3f
+       .uleb128 0x19
+       .uleb128 0x3
+       .uleb128 0xe
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x11
+       .uleb128 0x1
+       .uleb128 0x12
+       .uleb128 0x1
+       .uleb128 0x40
+       .uleb128 0x18
+       .byte   0
+       .byte   0
+       .uleb128 0x18
+       .uleb128 0x1
+       .byte   0x1
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x1
+       .uleb128 0x13
+       .byte   0
+       .byte   0
+       .uleb128 0x19
+       .uleb128 0x34
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x3f
+       .uleb128 0x19
+       .uleb128 0x3c
+       .uleb128 0x19
+       .byte   0
+       .byte   0
+       .uleb128 0x1a
+       .uleb128 0x34
+       .byte   0
+       .uleb128 0x3
+       .uleb128 0x8
+       .uleb128 0x3a
+       .uleb128 0xb
+       .uleb128 0x3b
+       .uleb128 0xb
+       .uleb128 0x49
+       .uleb128 0x13
+       .uleb128 0x3f
+       .uleb128 0x19
+       .uleb128 0x2
+       .uleb128 0x18
+       .byte   0
+       .byte   0
+       .byte   0
+       .section        .debug_loc,"",@progbits
+.Ldebug_loc0:
+.LLST0:
+       .long   .LVL0-.Ltext0
+       .long   .LVL1-.Ltext0
+       .value  0x2
+       .byte   0x91
+       .sleb128 0
+       .long   .LVL1-.Ltext0
+       .long   .LFE1-.Ltext0
+       .value  0x6
+       .byte   0x91
+       .sleb128 0
+       .byte   0x6
+       .byte   0x31
+       .byte   0x24
+       .byte   0x9f
+       .long   0
+       .long   0
+.LLST1:
+       .long   .LVL1-.Ltext0
+       .long   .LVL4-.Ltext0
+       .value  0x2
+       .byte   0x91
+       .sleb128 0
+       .long   .LVL4-.Ltext0
+       .long   .LFE1-.Ltext0
+       .value  0x6
+       .byte   0x91
+       .sleb128 0
+       .byte   0x6
+       .byte   0x33
+       .byte   0x1e
+       .byte   0x9f
+       .long   0
+       .long   0
+.LLST2:
+       .long   .LVL1-.Ltext0
+       .long   .LVL4-.Ltext0
+       .value  0x20
+       .byte   0xf2
+       .long   .Ldebug_info0+125
+       .sleb128 0
+       .byte   0x93
+       .uleb128 0x4
+       .byte   0x91
+       .sleb128 0
+       .byte   0x6
+       .byte   0x32
+       .byte   0x24
+       .byte   0x9f
+       .byte   0x93
+       .uleb128 0x4
+       .byte   0xf2
+       .long   .Ldebug_info0+138
+       .sleb128 0
+       .byte   0x93
+       .uleb128 0x4
+       .byte   0x91
+       .sleb128 0
+       .byte   0x6
+       .byte   0x31
+       .byte   0x24
+       .byte   0x9f
+       .byte   0x93
+       .uleb128 0x4
+       .long   .LVL4-.Ltext0
+       .long   .LFE1-.Ltext0
+       .value  0x20
+       .byte   0xf2
+       .long   .Ldebug_info0+138
+       .sleb128 0
+       .byte   0x93
+       .uleb128 0x4
+       .byte   0x91
+       .sleb128 0
+       .byte   0x6
+       .byte   0x36
+       .byte   0x1e
+       .byte   0x9f
+       .byte   0x93
+       .uleb128 0x4
+       .byte   0xf2
+       .long   .Ldebug_info0+125
+       .sleb128 0
+       .byte   0x93
+       .uleb128 0x4
+       .byte   0x91
+       .sleb128 0
+       .byte   0x6
+       .byte   0x31
+       .byte   0x24
+       .byte   0x9f
+       .byte   0x93
+       .uleb128 0x4
+       .long   0
+       .long   0
+.LLST3:
+       .long   .LVL1-.Ltext0
+       .long   .LVL2-.Ltext0
+       .value  0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+151
+       .sleb128 0
+       .long   .LVL2-.Ltext0
+       .long   .LVL3-.Ltext0
+       .value  0x2
+       .byte   0x30
+       .byte   0x9f
+       .long   .LVL3-.Ltext0
+       .long   .LFE1-.Ltext0
+       .value  0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+151
+       .sleb128 8
+       .long   0
+       .long   0
+.LLST4:
+       .long   .LVL4-.Ltext0
+       .long   .LVL5-.Ltext0
+       .value  0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+151
+       .sleb128 0
+       .long   .LVL5-.Ltext0
+       .long   .LVL6-.Ltext0
+       .value  0x2
+       .byte   0x30
+       .byte   0x9f
+       .long   .LVL6-.Ltext0
+       .long   .LFE1-.Ltext0
+       .value  0x6
+       .byte   0xf2
+       .long   .Ldebug_info0+151
+       .sleb128 8
+       .long   0
+       .long   0
+       .section        .debug_aranges,"",@progbits
+       .long   0x1c
+       .value  0x2
+       .long   .Ldebug_info0
+       .byte   0x4
+       .byte   0
+       .value  0
+       .value  0
+       .long   .Ltext0
+       .long   .Letext0-.Ltext0
+       .long   0
+       .long   0
+       .section        .debug_line,"",@progbits
+.Ldebug_line0:
+       .section        .debug_str,"MS",@progbits,1
+.LASF0:
+       .string "unsigned int"
+.LASF3:
+       .string "/home/tromey/gnu/archer/archer/gdb/testsuite/gdb.dwarf2"
+.LASF4:
+       .string "main"
+.LASF2:
+       .string "implptr.c"
+.LASF1:
+       .string "GNU C 4.6.0 20101116 (experimental) [trunk revision 166803]"
+       .ident  "GCC: (GNU) 4.6.0 20101116 (experimental) [trunk revision 166803]"
+       .section        .note.GNU-stack,"",@progbits
diff --git a/gdb/testsuite/gdb.dwarf2/implptr.c b/gdb/testsuite/gdb.dwarf2/implptr.c
new file mode 100644 (file)
index 0000000..640be80
--- /dev/null
@@ -0,0 +1,68 @@
+/* Copyright (C) 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/>.  */
+
+/* The original program corresponding to implptr.S.
+   This came from Jakub's gcc-patches email implementing
+   DW_OP_GNU_implicit_pointer.
+   Note that it is not ever compiled, implptr.S is used instead.
+   However, it is used to extract breakpoint line numbers.  */
+
+struct S
+{
+  int *x, y;
+};
+
+int u[6];
+
+static inline void
+add (struct S *a, struct S *b, int c)
+{
+  *a->x += *b->x;
+  a->y += b->y;
+  u[c + 0]++;
+  a = (struct S *) 0;
+  u[c + 1]++;
+  a = b;
+  u[c + 2]++;
+}
+
+int
+foo (int i)
+{
+  int j = i;
+  struct S p[2] = { {&i, i * 2}, {&j, j * 2} };
+  add (&p[0], &p[1], 0);
+  p[0].x = &j;
+  p[1].x = &i;
+  add (&p[0], &p[1], 3);
+  return i + j;                        /* foo breakpoint */
+}
+
+int __attribute__ ((noinline, used, noclone)) 
+bar (int i) 
+{
+  int *j = &i;
+  int **k = &j;
+  int ***l = &k;
+  i++;                         /* bar breakpoint */
+  return i;
+}
+
+int main ()
+{
+  return bar(5) + foo (23);
+}
diff --git a/gdb/testsuite/gdb.dwarf2/implptr.exp b/gdb/testsuite/gdb.dwarf2/implptr.exp
new file mode 100644 (file)
index 0000000..fa39908
--- /dev/null
@@ -0,0 +1,80 @@
+# Copyright 2010 Free Software Foundation, Inc.
+
+# 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/>.
+
+# Test DW_OP_GNU_implicit_pointer.
+
+# This test can only be run on targets which support DWARF-2 and use gas.
+# For now pick a sampling of likely targets.
+if {![istarget *-*-linux*]
+    && ![istarget *-*-gnu*]
+    && ![istarget *-*-elf*]
+    && ![istarget *-*-openbsd*]
+    && ![istarget arm-*-eabi*]
+    && ![istarget powerpc-*-eabi*]} {
+    return 0  
+}
+# This test can only be run on x86 targets.
+if {![istarget i?86-*]} {
+    return 0  
+}
+
+set testfile "implptr"
+set srcfile ${testfile}.S
+set csrcfile ${testfile}.c
+set binfile ${objdir}/${subdir}/${testfile}.x
+
+if {[prepare_for_testing ${testfile}.exp ${testfile}.x $srcfile]} {
+    return -1
+}
+
+if ![runto_main] {
+    return -1
+}
+
+# Test various pointer depths in bar.
+proc implptr_test_bar {} {
+    global csrcfile
+    set line [gdb_get_line_number "bar breakpoint" $csrcfile]
+    gdb_test "break implptr.c:$line" "Breakpoint 2.*" \
+       "set bar breakpoint for implptr"
+    gdb_continue_to_breakpoint "continue to bar breakpoint for implptr"
+    gdb_test "print j" " = .int .. <synthetic pointer>" "print j in implptr:bar"
+    gdb_test "print *j" " = 5" "print *j in implptr:bar"
+    gdb_test "print **k" " = 5" "print **k in implptr:bar"
+    gdb_test "print ***l" " = 5" "print ***l in implptr:bar"
+}
+
+# Test some values in foo.
+proc implptr_test_foo {} {
+    global csrcfile
+    set line [gdb_get_line_number "foo breakpoint" $csrcfile]
+    gdb_test "break implptr.c:$line" "Breakpoint 3.*" \
+       "set foo breakpoint for implptr"
+    gdb_continue_to_breakpoint "continue to foo breakpoint for implptr"
+    gdb_test "print p\[0].x" " = .int .. <synthetic pointer>" \
+       "print p\[0].x in implptr:foo"
+    gdb_test "print *p\[0].x" " = 69" \
+       "print *p\[0].x in implptr:foo"
+    gdb_test "print/d *(((char *) p\[0].x) + 1)" " = 0" \
+       "print byte inside *p\[0].x in implptr:foo"
+    gdb_test "print *(p\[0].x + 10)" \
+       "access outside bounds of object referenced via synthetic pointer" \
+       "print invalid offset from *p\[0].x in implptr:foo"
+    gdb_test "print j" " = 69" \
+       "print j in implptr:foo"
+}
+
+implptr_test_bar
+implptr_test_foo
index 7c553d1ca4a2db618b5932dafa6ad6ac43a9ac2a..36e937dcc56ca1bf8d393096380a00b48b5b4cff 100644 (file)
@@ -90,13 +90,17 @@ value_ptradd (struct value *arg1, LONGEST arg2)
 {
   struct type *valptrtype;
   LONGEST sz;
+  struct value *result;
 
   arg1 = coerce_array (arg1);
   valptrtype = check_typedef (value_type (arg1));
   sz = find_size_for_pointer_math (valptrtype);
 
-  return value_from_pointer (valptrtype,
-                            value_as_address (arg1) + sz * arg2);
+  result = value_from_pointer (valptrtype,
+                              value_as_address (arg1) + sz * arg2);
+  if (VALUE_LVAL (result) != lval_internalvar)
+    set_value_component_location (result, arg1);
+  return result;
 }
 
 /* Given two compatible pointer values ARG1 and ARG2, return the
index 932e31166bb27694f33f8bae64e478499bed263a..e115b311302344f9d3d83dcd8332ec9df5d26ec5 100644 (file)
@@ -1618,6 +1618,19 @@ value_ind (struct value *arg1)
 
   base_type = check_typedef (value_type (arg1));
 
+  if (VALUE_LVAL (arg1) == lval_computed)
+    {
+      struct lval_funcs *funcs = value_computed_funcs (arg1);
+
+      if (funcs->indirect)
+       {
+         struct value *result = funcs->indirect (arg1);
+
+         if (result)
+           return result;
+       }
+    }
+
   if (TYPE_CODE (base_type) == TYPE_CODE_PTR)
     {
       struct type *enc_type;
index ddb16e4847c4cf9aa6734d132fb71335202ccbcb..5cba023c10bfc859431d349e99601fe5fe2ac252 100644 (file)
@@ -273,6 +273,13 @@ valprint_check_validity (struct ui_file *stream,
          fprintf_filtered (stream, _("<value optimized out>"));
          return 0;
        }
+
+      if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * offset,
+                                       TARGET_CHAR_BIT * TYPE_LENGTH (type)))
+       {
+         fputs_filtered (_("<synthetic pointer>"), stream);
+         return 0;
+       }
     }
 
   return 1;
index d1ca3dc336395f541e82b76c901a767c52a83e08..aa8384cdc8277b65aca5b8e448245804e59b7e2b 100644 (file)
@@ -536,6 +536,18 @@ value_bits_valid (const struct value *value, int offset, int length)
                                                         length);
 }
 
+int
+value_bits_synthetic_pointer (const struct value *value,
+                             int offset, int length)
+{
+  if (value == NULL || value->lval != lval_computed
+      || !value->location.computed.funcs->check_synthetic_pointer)
+    return 0;
+  return value->location.computed.funcs->check_synthetic_pointer (value,
+                                                                 offset,
+                                                                 length);
+}
+
 int
 value_embedded_offset (struct value *value)
 {
index ef2cb4fa1dd2c5b1587fde4c9f3a7942a056e15e..cf089be562fd74a9356b6024e11fc9d5001dfe29 100644 (file)
@@ -173,6 +173,16 @@ struct lval_funcs
   /* Return 1 if any bit in VALUE is valid, 0 if they are all invalid.  */
   int (*check_any_valid) (const struct value *value);
 
+  /* If non-NULL, this is used to implement pointer indirection for
+     this value.  This method may return NULL, in which case value_ind
+     will fall back to ordinary indirection.  */
+  struct value *(*indirect) (struct value *value);
+
+  /* If non-NULL, this is used to determine whether the indicated bits
+     of VALUE are a synthetic pointer.  */
+  int (*check_synthetic_pointer) (const struct value *value,
+                                 int offset, int length);
+
   /* Return a duplicate of VALUE's closure, for use in a new value.
      This may simply return the same closure, if VALUE's is
      reference-counted or statically allocated.
@@ -338,6 +348,12 @@ extern struct value *coerce_array (struct value *value);
 extern int value_bits_valid (const struct value *value,
                             int offset, int length);
 
+/* Given a value, determine whether the bits starting at OFFSET and
+   extending for LENGTH bits are a synthetic pointer.  */
+
+extern int value_bits_synthetic_pointer (const struct value *value,
+                                        int offset, int length);
+
 \f
 
 #include "symtab.h"