From patchwork Thu Jul 16 18:51:20 2015 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Simon Marchi X-Patchwork-Id: 7723 Received: (qmail 121021 invoked by alias); 16 Jul 2015 18:51:40 -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 119161 invoked by uid 89); 16 Jul 2015 18:51:38 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=-1.9 required=5.0 tests=AWL, BAYES_00, SPF_PASS autolearn=ham version=3.3.2 X-HELO: usevmg21.ericsson.net Received: from usevmg21.ericsson.net (HELO usevmg21.ericsson.net) (198.24.6.65) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with (AES256-SHA encrypted) ESMTPS; Thu, 16 Jul 2015 18:51:37 +0000 Received: from EUSAAHC003.ericsson.se (Unknown_Domain [147.117.188.81]) by usevmg21.ericsson.net (Symantec Mail Security) with SMTP id 2B.63.07675.77597A55; Thu, 16 Jul 2015 13:28:55 +0200 (CEST) Received: from elxcz23q12-y4.dyn.mo.ca.am.ericsson.se (147.117.188.8) by smtps-am.internal.ericsson.com (147.117.188.81) with Microsoft SMTP Server (TLS) id 14.3.210.2; Thu, 16 Jul 2015 14:51:34 -0400 From: Simon Marchi To: CC: Simon Marchi Subject: [PATCH 1/5] Update comment for struct type's length field, introduce type_length_units Date: Thu, 16 Jul 2015 14:51:20 -0400 Message-ID: <1437072684-26565-1-git-send-email-simon.marchi@ericsson.com> MIME-Version: 1.0 X-IsSubscribed: yes This patch tries to clean up a bit the blur around the length field in struct type, regarding its use with architectures with non-8-bits addressable memory. It clarifies that the field is expressed in bytes, which is what is the closest to the current reality. It also introduces a new function to get the length of the type in addressable memory units. gdb/ChangeLog: * gdbtypes.c (type_length_units): New function. * gdbtypes.h (type_length_units): New declaration. (struct type): Update LENGTH's comment. --- gdb/gdbtypes.c | 11 +++++++++++ gdb/gdbtypes.h | 45 +++++++++++++++++++++------------------------ 2 files changed, 32 insertions(+), 24 deletions(-) diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index e44fd4f..b94bc7b 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -252,6 +252,17 @@ get_target_type (struct type *type) return type; } +/* See gdbtypes.h. */ + +unsigned int +type_length_units (struct type *type) +{ + struct gdbarch *arch = get_type_arch (type); + int unit_size = gdbarch_addressable_memory_unit_size (arch); + + return TYPE_LENGTH (type) / unit_size; +} + /* Alloc a new type instance structure, fill it with some defaults, and point it at OLDTYPE. Allocate the new type instance from the same place as OLDTYPE. */ diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index c166e48..83f85a6 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -780,31 +780,23 @@ struct type check_typedef. */ int instance_flags; - /* * Length of storage for a value of this type. This is what - sizeof(type) would return; use it for address arithmetic, memory - reads and writes, etc. This size includes padding. For example, - an i386 extended-precision floating point value really only - occupies ten bytes, but most ABI's declare its size to be 12 - bytes, to preserve alignment. A `struct type' representing such - a floating-point type would have a `length' value of 12, even - though the last two bytes are unused. - - There's a bit of a host/target mess here, if you're concerned - about machines whose bytes aren't eight bits long, or who don't - have byte-addressed memory. Various places pass this to memcpy - and such, meaning it must be in units of host bytes. Various - other places expect they can calculate addresses by adding it - and such, meaning it must be in units of target bytes. For - some DSP targets, in which HOST_CHAR_BIT will (presumably) be 8 - and TARGET_CHAR_BIT will be (say) 32, this is a problem. - - One fix would be to make this field in bits (requiring that it - always be a multiple of HOST_CHAR_BIT and TARGET_CHAR_BIT) --- - the other choice would be to make it consistently in units of - HOST_CHAR_BIT. However, this would still fail to address - machines based on a ternary or decimal representation. */ + /* * Length of storage for a value of this type. The value is the + expression in bytes of of what sizeof(type) would return. This + size includes padding. For example, an i386 extended-precision + floating point value really only occupies ten bytes, but most + ABI's declare its size to be 12 bytes, to preserve alignment. + A `struct type' representing such a floating-point type would + have a `length' value of 12, even though the last two bytes are + unused. + + Since this field is expressed in bytes, its value is appropriate to + pass to memcpy and such (it is assumed that GDB itself always runs + on an 8-bits addressable architecture). However, when using it for + target address arithmetic (e.g. adding it to a target address), the + type_length_units function should be used in order to get the length + expressed in addressable memory units. */ - unsigned length; + unsigned int length; /* * Core type, shared by a group of qualified types. */ @@ -1659,6 +1651,11 @@ extern struct gdbarch *get_type_arch (const struct type *); extern struct type *get_target_type (struct type *type); +/* Return the equivalent of TYPE_LENGTH, but in number of addressable memory + units of the associated gdbarch instead of bytes. */ + +extern unsigned int type_length_units (struct type *type); + /* * Helper function to construct objfile-owned types. */ extern struct type *init_type (enum type_code, int, int, const char *,