From patchwork Wed Jun 4 05:54:05 2014 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Keven Boell X-Patchwork-Id: 1284 Received: (qmail 27439 invoked by alias); 4 Jun 2014 05:54:41 -0000 Mailing-List: contact gdb-patches-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: gdb-patches-owner@sourceware.org Delivered-To: mailing list gdb-patches@sourceware.org Received: (qmail 27157 invoked by uid 89); 4 Jun 2014 05:54:39 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.7 required=5.0 tests=AWL, BAYES_00, RP_MATCHES_RCVD autolearn=ham version=3.3.2 X-HELO: mga11.intel.com Received: from mga11.intel.com (HELO mga11.intel.com) (192.55.52.93) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Wed, 04 Jun 2014 05:54:37 +0000 Received: from fmsmga001.fm.intel.com ([10.253.24.23]) by fmsmga102.fm.intel.com with ESMTP; 03 Jun 2014 22:54:32 -0700 X-ExtLoop1: 1 Received: from irvmail001.ir.intel.com ([163.33.26.43]) by fmsmga001.fm.intel.com with ESMTP; 03 Jun 2014 22:54:31 -0700 Received: from ullecvh004g04.iul.intel.com (ullecvh004g04.iul.intel.com [172.28.50.14]) by irvmail001.ir.intel.com (8.14.3/8.13.6/MailSET/Hub) with ESMTP id s545sUV2020251; Wed, 4 Jun 2014 06:54:30 +0100 Received: from ullecvh004g04.iul.intel.com (ullecvh004g04.iul.intel.com [127.0.0.1]) by ullecvh004g04.iul.intel.com (8.13.8/8.13.8) with ESMTP id s545sUlY006279; Wed, 4 Jun 2014 07:54:30 +0200 Received: (from kboell@localhost) by ullecvh004g04.iul.intel.com (8.13.8/8.13.8/Submit) id s545sTmg006278; Wed, 4 Jun 2014 07:54:29 +0200 From: Keven Boell To: gdb-patches@sourceware.org Cc: sanimir.agovic@intel.com, keven.boell@intel.com Subject: [PATCH 02/23] dwarf: add DW_AT_data_location support Date: Wed, 4 Jun 2014 07:54:05 +0200 Message-Id: <1401861266-6240-3-git-send-email-keven.boell@intel.com> In-Reply-To: <1401861266-6240-1-git-send-email-keven.boell@intel.com> References: <1401861266-6240-1-git-send-email-keven.boell@intel.com> An object might have a descriptor proceeding the actual value. To point the debugger to the actually value of an object DW_AT_data_location is used for. For example the compile may emit for this entity: 1| int foo[N]; the following descriptor: struct array { size_t size; void* data; // DW_AT_data_location describes this location } This allows GDB to print the actual data of an type. 2014-05-28 Sanimir Agovic Keven Boell * dwarf2read.c (set_die_type): Parse and save DW_AT_data_location attribute. * gdbtypes.c (is_dynamic_type): Consider a type being dynamic if the data location has not yet been resolved. (resolve_dynamic_type): Evaluate data location baton if present and save its value. * gdbtypes.h : Add data_location. (TYPE_DATA_LOCATION): New macro. (TYPE_DATA_LOCATION_ADDR): New macro. (TYPE_DATA_LOCATION_IS_ADDRESS): New macro. * value.c: Include dwarf2loc.h. (value_fetch_lazy): Use data location addres to read value from memory. (coerce_ref): Construct new value from data location. Change-Id: Ic633fa125efdb5e438204e4f80bb3a1c97758b12 Signed-off-by: Keven Boell --- gdb/dwarf2read.c | 15 +++++++++++++++ gdb/gdbtypes.c | 29 +++++++++++++++++++++++++++-- gdb/gdbtypes.h | 14 ++++++++++++++ gdb/value.c | 8 +++++++- 4 files changed, 63 insertions(+), 3 deletions(-) diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index 6ebfffc..7a0f7f4 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -21499,6 +21499,7 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) { struct dwarf2_per_cu_offset_and_type **slot, ofs; struct objfile *objfile = cu->objfile; + struct attribute *attr; /* For Ada types, make sure that the gnat-specific data is always initialized (if not already set). There are a few types where @@ -21513,6 +21514,20 @@ set_die_type (struct die_info *die, struct type *type, struct dwarf2_cu *cu) && !HAVE_GNAT_AUX_INFO (type)) INIT_GNAT_SPECIFIC (type); + /* Read DW_AT_data_location and set in type. */ + attr = dwarf2_attr (die, DW_AT_data_location, cu); + if (attr_form_is_block (attr)) + { + struct dynamic_prop prop; + + if (attr_to_dynamic_prop (attr, die, cu, &prop)) + { + TYPE_DATA_LOCATION (type) + = obstack_alloc (&objfile->objfile_obstack, sizeof (prop)); + *TYPE_DATA_LOCATION (type) = prop; + } + } + if (dwarf2_per_objfile->die_type_hash == NULL) { dwarf2_per_objfile->die_type_hash = diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index 2a0cfe4..c12c159 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -1635,8 +1635,12 @@ is_dynamic_type (struct type *type) or the elements it contains have a dynamic contents. */ if (is_dynamic_type (TYPE_INDEX_TYPE (type))) return 1; - else - return is_dynamic_type (TYPE_TARGET_TYPE (type)); + else if (TYPE_DATA_LOCATION (type) != NULL + && (TYPE_DATA_LOCATION_KIND (type) == PROP_LOCEXPR + || TYPE_DATA_LOCATION_KIND (type) == PROP_LOCLIST)) + return 1; + else + return is_dynamic_type (TYPE_TARGET_TYPE (type)); break; } default: @@ -1728,6 +1732,8 @@ resolve_dynamic_type (struct type *type, CORE_ADDR addr) { struct type *real_type = check_typedef (type); struct type *resolved_type = type; + const struct dynamic_prop *prop; + CORE_ADDR value; if (!is_dynamic_type (real_type)) return type; @@ -1759,6 +1765,18 @@ resolve_dynamic_type (struct type *type, CORE_ADDR addr) break; } + type = resolved_type; + + /* Resolve data_location attribute. */ + prop = TYPE_DATA_LOCATION (type); + if (dwarf2_evaluate_property (prop, addr, &value)) + { + TYPE_DATA_LOCATION_ADDR (type) = value; + TYPE_DATA_LOCATION_KIND (type) = PROP_CONST; + } + else + TYPE_DATA_LOCATION (type) = NULL; + return resolved_type; } @@ -3968,6 +3986,13 @@ copy_type_recursive (struct objfile *objfile, *TYPE_RANGE_DATA (new_type) = *TYPE_RANGE_DATA (type); } + /* Copy the data location information. */ + if (TYPE_DATA_LOCATION (type) != NULL) + { + TYPE_DATA_LOCATION (new_type) = xmalloc (sizeof (struct dynamic_prop)); + *TYPE_DATA_LOCATION (new_type) = *TYPE_DATA_LOCATION (type); + } + /* Copy pointers to other types. */ if (TYPE_TARGET_TYPE (type)) TYPE_TARGET_TYPE (new_type) = diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 86b1d62..c6d14d2 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -722,6 +722,10 @@ struct main_type struct func_type *func_stuff; } type_specific; + + /* * Indirection to actual data. */ + + struct dynamic_prop *data_location; }; /* * A ``struct type'' describes a particular instance of a type, with @@ -1201,6 +1205,16 @@ extern void allocate_gnat_aux_type (struct type *); #define TYPE_LOW_BOUND_KIND(range_type) \ TYPE_RANGE_DATA(range_type)->low.kind +/* Attribute accessors for VLA support. */ +#define TYPE_DATA_LOCATION(thistype) \ + TYPE_MAIN_TYPE(thistype)->data_location +#define TYPE_DATA_LOCATION_BATON(thistype) \ + TYPE_DATA_LOCATION (thistype)->data.baton +#define TYPE_DATA_LOCATION_ADDR(thistype) \ + TYPE_DATA_LOCATION (thistype)->data.const_val +#define TYPE_DATA_LOCATION_KIND(thistype) \ + TYPE_DATA_LOCATION (thistype)->kind + /* Moto-specific stuff for FORTRAN arrays. */ #define TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED(arraytype) \ diff --git a/gdb/value.c b/gdb/value.c index d125a09..1c88dfd 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -3635,8 +3635,14 @@ value_fetch_lazy (struct value *val) } else if (VALUE_LVAL (val) == lval_memory) { - CORE_ADDR addr = value_address (val); struct type *type = check_typedef (value_enclosing_type (val)); + CORE_ADDR addr; + + if (TYPE_DATA_LOCATION (type) != NULL + && TYPE_DATA_LOCATION_KIND (type) == PROP_CONST) + addr = TYPE_DATA_LOCATION_ADDR (type); + else + addr = value_address (val); if (TYPE_LENGTH (type)) read_value_memory (val, 0, value_stack (val),