From patchwork Thu Nov 14 17:15:58 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peeter Joot X-Patchwork-Id: 35890 Received: (qmail 7772 invoked by alias); 14 Nov 2019 17:16:14 -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 7681 invoked by uid 89); 14 Nov 2019 17:16:13 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=BAYES_00, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, HTML_MESSAGE, KAM_SHORT, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_HELO_PASS, SPF_PASS autolearn=ham version=3.3.1 spammy=ov, employer X-HELO: EUR03-DB5-obe.outbound.protection.outlook.com Received: from mail-eopbgr40100.outbound.protection.outlook.com (HELO EUR03-DB5-obe.outbound.protection.outlook.com) (40.107.4.100) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 14 Nov 2019 17:16:03 +0000 ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=I9+YrEMaUSCVq80esSPPcKWs28r6mNUZvrYRThmEpqAQVsfMj73jMjJ/WqiUQQp1O7jCXwSdWoRV3LWOnBPOeHlLa6pjOh92srvObjtF6M0GjIlYpxwOc7EM9B0hZwLCYyfmJvdoJnUGYD4c9fW7UTwOZCjTNi4jRKpIIuJaIIDUboKR8rPDKOEfoAHdgIVEou/2YvY6EKxWnIlg+mxo5i6cj1C5v3VzxN9Q4mqlV5eGKHdgqnBNAyP1vQpWlIdqxJADcCn+TdBYmTXVVnGtfCM0CwjECn+BIVVbveY0+Au3dHQJA78uqYkUn7gqwoQZ8AS+lw+VOpwD8PueN99hgg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=UYcFwJzltdnio5pKy61SgVDPTLN35E9Pk5e1AynJ4gk=; b=TzGuCtiw9fkNrYSM24TWHv5yaKDA9wu3hbhY+GQs1dEd9LFWAg1dz0FwXZ5DLiRI4AsGqLnuuTWpptEg8n/aqnb/AxYT+HrdY2McMuATQoOU8ypK8RbioztP1HdkKnqP1w0Wi83J+p0nhSBpkYmarVDe2LOrCL2Byibfp3KchyMjP+lM+ff9TP1+zY+4EbQBgqQar5fczniFzGRg64ACN9/qOAfCQ2ar6oZxAT0VaNsPRfbtD/TH5OjDQNlbPMALfrgXMSu5cgd3pVdNLr8TT1LLDEtS9XtFrRvsbbm0neEC3lvJVkKVfdspeoUtL83zo+gcnFzdAsqCu0an2tqteA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=lzlabs.com; dmarc=pass action=none header.from=lzlabs.com; dkim=pass header.d=lzlabs.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lzlabsch.onmicrosoft.com; s=selector2-lzlabsch-onmicrosoft-com; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=UYcFwJzltdnio5pKy61SgVDPTLN35E9Pk5e1AynJ4gk=; b=MjzoLaJZxQqSzIF/yYCYwwtQ98pKLm5rOoEc+mM+XMain961GP+1p46fuWEtpX9q8TiNdj0QlC4d0AW2S7AMN4jfvmCVXc6uAP8OK2gzdRMXFxfySRFr61Ldluz/FCS2LJ4gnNpEbsLfpJwIx56GaICk9TCbMAWTaI1u1o+vey0= Received: from VI1PR05MB5726.eurprd05.prod.outlook.com (20.178.120.78) by VI1PR05MB4688.eurprd05.prod.outlook.com (20.176.3.161) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.2451.26; Thu, 14 Nov 2019 17:15:58 +0000 Received: from VI1PR05MB5726.eurprd05.prod.outlook.com ([fe80::894c:eba8:a22b:d5c8]) by VI1PR05MB5726.eurprd05.prod.outlook.com ([fe80::894c:eba8:a22b:d5c8%7]) with mapi id 15.20.2451.024; Thu, 14 Nov 2019 17:15:58 +0000 From: Peeter Joot To: "gdb-patches@sourceware.org" Subject: [PATCH] Adjust byte order variable display/change if DW_AT_endianity is present. Date: Thu, 14 Nov 2019 17:15:58 +0000 Message-ID: authentication-results: spf=none (sender IP is ) smtp.mailfrom=peeter.joot@lzlabs.com; x-ms-oob-tlc-oobclassifiers: OLM:5797; received-spf: None (protection.outlook.com: lzlabs.com does not designate permitted sender hosts) x-ms-exchange-senderadcheck: 1 x-ms-exchange-transport-forked: True MIME-Version: 1.0 X-MS-Exchange-CrossTenant-mailboxtype: HOSTED X-MS-Exchange-CrossTenant-userprincipalname: L3xaIWcdxietd31U2bjCl4308RBijT9CYWZDBVBoy0J7iGQfTyJlolXt5GvxKOKx4Cyl0B3zh8riMuJHtV+/5w== - Rationale: It is possible for compilers to indicate the desired byte order interpretation of scalar variables using the DWARF attribute: DW_AT_endianity A type flagged with this variable would typically use one of: DW_END_big DW_END_little which instructs the debugger what the desired byte order interpretation of the variable should be. The GCC compiler (as of V6) has a mechanism for setting the desired byte ordering of the fields within a structure or union. For, example, on a little endian target, a structure declared as: struct big { int v; short a[4]; } __attribute__( ( scalar_storage_order( "big-endian" ) ) ); could be used to ensure all the structure members have a big-endian interpretation (the compiler would automatically insert byte swap instructions before and after respective store and load instructions). - To reproduce GCC V8+ is required to correctly emit DW_AT_endianity DWARF attributes in all situations when the scalar_storage_order attribute is used. A fix for (dwarf endianity instrumentation) for GCC V6-V7 can be found in the URL field of the following PR: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82509 - Test-case: A new test case (testsuite/gdb.base/endianity.*) is included with this patch. Manual testing for mixed endianity code has also been done with GCC V8. See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82509#c4 - Observed vs. expected: Without this change, using scalar_storage_order that doesn't match the target, such as struct otherendian { int v; } __attribute__( ( scalar_storage_order( "big-endian" ) ) ); would behave like the following on a little endian target: Breakpoint 1 at 0x401135: file endianity.c, line 41. (gdb) run Starting program: /home/pjoot/freeware/t/a.out Missing separate debuginfos, use: debuginfo-install glibc-2.17-292.el7.x86_64 Breakpoint 1, main () at endianity.c:41 41 struct otherendian o = {3}; (gdb) n 43 do_nothing (&o); /* START */ (gdb) p o $1 = {v = 50331648} (gdb) p /x $2 = {v = 0x3000000} whereas with this gdb enhancement we can access the variable with the user specified endianity: Breakpoint 1, main () at endianity.c:41 41 struct otherendian o = {3}; (gdb) p o $1 = {v = 0} (gdb) n 43 do_nothing (&o); /* START */ (gdb) p o $2 = {v = 3} (gdb) p o.v = 4 $3 = 4 (gdb) p o.v $4 = 4 (gdb) x/4xb &o.v 0x7fffffffd90c: 0x00 0x00 0x00 0x04 (observe that the 4 byte int variable has a big endian representation in the hex dump.) - FSF copyright Assignment I am contributing on behalf of my employer, LzLabs GbmH. The FSF attribution documentation for binutils and gdb are both complete and signed back. - Changelogs: gdb/ChangeLog: 2019-11-14 Peeter Joot Byte reverse display of variables with DW_END_big, DW_END_little (DW_AT_endianity) dwarf attributes if different than the native byte order. * ada-lang.c (ada_value_binop): Use type_byte_order instead of gdbarch_byte_order. * ada-valprint.c (printstr): (ada_val_print_string): Use type_byte_order instead of gdbarch_byte_order. * c-lang.c (c_get_string): Use type_byte_order instead of gdbarch_byte_order. * c-valprint.c (c_val_print_array): Use type_byte_order instead of gdbarch_byte_order. * cp-valprint.c (cp_print_class_member): Use type_byte_order instead of gdbarch_byte_order. * dwarf2loc.c (rw_pieced_value): Use type_byte_order instead of gdbarch_byte_order. * dwarf2read.c (read_base_type): Handle DW_END_big, DW_END_little * f-lang.c (f_get_encoding): Use type_byte_order instead of gdbarch_byte_order. * findvar.c (default_read_var_value): Use type_byte_order instead of gdbarch_byte_order. * gdbtypes.c (check_types_equal): Require matching TYPE_ENDIANITY_BIG, and TYPE_ENDIANITY_LITTLE if set. (recursive_dump_type): Print TYPE_ENDIANITY_BIG, and TYPE_ENDIANITY_LITTLE if set. (type_byte_order): new function. * gdbtypes.h (TYPE_ENDIANITY_BIG, TYPE_ENDIANITY_LITTLE): New macro. (struct main_type) : New field. (type_byte_order): New function. * infcmd.c (default_print_one_register_info): Use type_byte_order instead of gdbarch_byte_order. * p-lang.c (pascal_printstr): Use type_byte_order instead of gdbarch_byte_order. * p-valprint.c (pascal_val_print): Use type_byte_order instead of gdbarch_byte_order. * printcmd.c (print_scalar_formatted): Use type_byte_order instead of gdbarch_byte_order. * solib-darwin.c (darwin_current_sos): Use type_byte_order instead of gdbarch_byte_order. * solib-svr4.c (solib_svr4_r_ldsomap): Use type_byte_order instead of gdbarch_byte_order. * stap-probe.c (stap_modify_semaphore): Use type_byte_order instead of gdbarch_byte_order. * target-float.c (target_float_same_format_p): Use type_byte_order instead of gdbarch_byte_order. * valarith.c (scalar_binop): Use type_byte_order instead of gdbarch_byte_order. * valops.c (value_cast): Use type_byte_order instead of gdbarch_byte_order. * valprint.c (generic_emit_char): (generic_printstr): (val_print_string): Use type_byte_order instead of gdbarch_byte_order. * value.c (unpack_long): (unpack_bits_as_long): (unpack_value_bitfield): (modify_field): (pack_long): (pack_unsigned_long): Use type_byte_order instead of gdbarch_byte_order. gdb/testsuite/ChangeLog: 2019-11-14 Peeter Joot * gdb.base/endianity.c: New test. * gdb.base/endianity.exp: New file. --- gdb/ada-lang.c | 2 +- gdb/ada-valprint.c | 4 ++-- gdb/c-lang.c | 2 +- gdb/c-valprint.c | 3 +-- gdb/cp-valprint.c | 2 +- gdb/dwarf2loc.c | 2 +- gdb/dwarf2read.c | 18 +++++++++++---- gdb/f-lang.c | 2 +- gdb/findvar.c | 2 +- gdb/gdbtypes.c | 21 +++++++++++++++++ gdb/gdbtypes.h | 20 ++++++++++++++++ gdb/infcmd.c | 2 +- gdb/p-lang.c | 2 +- gdb/p-valprint.c | 2 +- gdb/printcmd.c | 2 +- gdb/solib-darwin.c | 2 +- gdb/solib-svr4.c | 2 +- gdb/stap-probe.c | 7 +++--- gdb/target-float.c | 6 ++--- gdb/testsuite/gdb.base/endianity.c | 44 ++++++++++++++++++++++++++++++++++++ gdb/testsuite/gdb.base/endianity.exp | 38 +++++++++++++++++++++++++++++++ gdb/valarith.c | 8 +++---- gdb/valops.c | 2 +- gdb/valprint.c | 6 ++--- gdb/value.c | 12 +++++----- 25 files changed, 171 insertions(+), 42 deletions(-) create mode 100644 gdb/testsuite/gdb.base/endianity.c create mode 100644 gdb/testsuite/gdb.base/endianity.exp -- 2.9.1.200.gb1ec08f diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 2935df5..cfe950a 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -9678,7 +9678,7 @@ ada_value_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) val = allocate_value (type1); store_unsigned_integer (value_contents_raw (val), TYPE_LENGTH (value_type (val)), - gdbarch_byte_order (get_type_arch (type1)), v); + type_byte_order (type1), v); return val; } diff --git a/gdb/ada-valprint.c b/gdb/ada-valprint.c index 5ab0365..4bb9247 100644 --- a/gdb/ada-valprint.c +++ b/gdb/ada-valprint.c @@ -476,7 +476,7 @@ printstr (struct ui_file *stream, struct type *elttype, const gdb_byte *string, unsigned int length, int force_ellipses, int type_len, const struct value_print_options *options) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (elttype)); + enum bfd_endian byte_order = type_byte_order (elttype); unsigned int i; unsigned int things_printed = 0; int in_quotes = 0; @@ -719,7 +719,7 @@ ada_val_print_string (struct type *type, const gdb_byte *valaddr, struct value *original_value, const struct value_print_options *options) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); struct type *elttype = TYPE_TARGET_TYPE (type); unsigned int eltlen; unsigned int len; diff --git a/gdb/c-lang.c b/gdb/c-lang.c index 74e3f73..1de44f7 100644 --- a/gdb/c-lang.c +++ b/gdb/c-lang.c @@ -245,7 +245,7 @@ c_get_string (struct value *value, gdb::unique_xmalloc_ptr *buffer, struct type *element_type = TYPE_TARGET_TYPE (type); int req_length = *length; enum bfd_endian byte_order - = gdbarch_byte_order (get_type_arch (type)); + = type_byte_order (type); if (element_type == NULL) goto error; diff --git a/gdb/c-valprint.c b/gdb/c-valprint.c index c4306f1..58675f6 100644 --- a/gdb/c-valprint.c +++ b/gdb/c-valprint.c @@ -247,8 +247,7 @@ c_val_print_array (struct type *type, const gdb_byte *valaddr, { LONGEST low_bound, high_bound; int eltlen, len; - struct gdbarch *gdbarch = get_type_arch (type); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); unsigned int i = 0; /* Number of characters printed. */ if (!get_array_bounds (type, &low_bound, &high_bound)) diff --git a/gdb/cp-valprint.c b/gdb/cp-valprint.c index 04be4dc..e445d42 100644 --- a/gdb/cp-valprint.c +++ b/gdb/cp-valprint.c @@ -740,7 +740,7 @@ void cp_print_class_member (const gdb_byte *valaddr, struct type *type, struct ui_file *stream, const char *prefix) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); /* VAL is a byte offset into the structure type SELF_TYPE. Find the name of the field for that offset and diff --git a/gdb/dwarf2loc.c b/gdb/dwarf2loc.c index c8ba029..e25ee66 100644 --- a/gdb/dwarf2loc.c +++ b/gdb/dwarf2loc.c @@ -1601,7 +1601,7 @@ rw_pieced_value (struct value *v, struct value *from) bits_to_skip += (8 * value_offset (value_parent (v)) + value_bitpos (v)); if (from != NULL - && (gdbarch_byte_order (get_type_arch (value_type (from))) + && (type_byte_order (value_type (from)) == BFD_ENDIAN_BIG)) { /* Use the least significant bits of FROM. */ diff --git a/gdb/dwarf2read.c b/gdb/dwarf2read.c index bbfa442..711a8d3 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -17661,23 +17661,23 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) struct type *type; struct attribute *attr; int encoding = 0, bits = 0; + int endianity = 0; const char *name; attr = dwarf2_attr (die, DW_AT_encoding, cu); if (attr) - { encoding = DW_UNSND (attr); - } attr = dwarf2_attr (die, DW_AT_byte_size, cu); if (attr) - { bits = DW_UNSND (attr) * TARGET_CHAR_BIT; - } name = dwarf2_name (die, cu); if (!name) { complaint (_("DW_AT_name missing from DW_TAG_base_type")); } + attr = dwarf2_attr (die, DW_AT_endianity, cu); + if (attr) + endianity = DW_UNSND (attr); switch (encoding) { @@ -17757,6 +17757,16 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) maybe_set_alignment (cu, die, type); + switch (endianity) + { + case DW_END_big: + TYPE_ENDIANITY_BIG (type) = 1; + break; + case DW_END_little: + TYPE_ENDIANITY_LITTLE (type) = 1; + break; + } + return set_die_type (die, type, cu); } diff --git a/gdb/f-lang.c b/gdb/f-lang.c index 7f241c6..fd4ad0f 100644 --- a/gdb/f-lang.c +++ b/gdb/f-lang.c @@ -59,7 +59,7 @@ f_get_encoding (struct type *type) encoding = target_charset (get_type_arch (type)); break; case 4: - if (gdbarch_byte_order (get_type_arch (type)) == BFD_ENDIAN_BIG) + if (type_byte_order (type) == BFD_ENDIAN_BIG) encoding = "UTF-32BE"; else encoding = "UTF-32LE"; diff --git a/gdb/findvar.c b/gdb/findvar.c index bbfd689..19ce762 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -620,7 +620,7 @@ default_read_var_value (struct symbol *var, const struct block *var_block, /* Put the constant back in target format. */ v = allocate_value (type); store_signed_integer (value_contents_raw (v), TYPE_LENGTH (type), - gdbarch_byte_order (get_type_arch (type)), + type_byte_order (type), (LONGEST) SYMBOL_VALUE (var)); VALUE_LVAL (v) = not_lval; return v; diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index fd1c765..0a5c07f 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -3616,6 +3616,8 @@ check_types_equal (struct type *type1, struct type *type2, || TYPE_LENGTH (type1) != TYPE_LENGTH (type2) || TYPE_UNSIGNED (type1) != TYPE_UNSIGNED (type2) || TYPE_NOSIGN (type1) != TYPE_NOSIGN (type2) + || TYPE_ENDIANITY_BIG (type1) != TYPE_ENDIANITY_BIG (type2) + || TYPE_ENDIANITY_LITTLE (type1) != TYPE_ENDIANITY_LITTLE (type2) || TYPE_VARARGS (type1) != TYPE_VARARGS (type2) || TYPE_VECTOR (type1) != TYPE_VECTOR (type2) || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2) @@ -4669,6 +4671,14 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_NOSIGN"); } + if (TYPE_ENDIANITY_BIG (type)) + { + puts_filtered (" TYPE_ENDIANITY_BIG"); + } + if (TYPE_ENDIANITY_LITTLE (type)) + { + puts_filtered (" TYPE_ENDIANITY_LITTLE"); + } if (TYPE_STUB (type)) { puts_filtered (" TYPE_STUB"); @@ -5617,3 +5627,14 @@ _initialize_gdbtypes (void) show_strict_type_checking, &setchecklist, &showchecklist); } + +/* See gdbtypes.h. */ +enum bfd_endian +type_byte_order (const struct type *type) +{ + if (TYPE_ENDIANITY_BIG (type)) + return BFD_ENDIAN_BIG; + else if (TYPE_ENDIANITY_LITTLE (type)) + return BFD_ENDIAN_LITTLE; + return gdbarch_byte_order (get_type_arch (type)); +} diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 6d6ff59..951dcee 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -219,6 +219,18 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); #define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign) +/* * Mixed endian architectures can supply dwarf instrumentation + that indicates the desired endian interpretation of the variable. + This indicates that the interpretation should be big-endian + even if the cpu is running in little endian mode. */ + +#define TYPE_ENDIANITY_BIG(t) (TYPE_MAIN_TYPE (t)->flag_endianity_big) + +/* * The type has a little endian interpretation even if the cpu + is running in big endian mode. */ + +#define TYPE_ENDIANITY_LITTLE(t) (TYPE_MAIN_TYPE (t)->flag_endianity_little) + /* * This appears in a type's flags word if it is a stub type (e.g., if someone referenced a type that wasn't defined in a source file via (struct sir_not_appearing_in_this_film *)). */ @@ -701,6 +713,8 @@ struct main_type unsigned int flag_gnu_ifunc : 1; unsigned int flag_fixed_instance : 1; unsigned int flag_objfile_owned : 1; + unsigned int flag_endianity_big : 1; + unsigned int flag_endianity_little : 1; /* * True if this type was declared with "class" rather than "struct". */ @@ -2146,6 +2160,12 @@ extern int type_not_allocated (const struct type *type); extern int type_not_associated (const struct type *type); +/* * When the type includes explicit byte ordering, return that. + Otherwise, the byte ordering from gdbarch_byte_order for + get_type_arch is returned. */ + +extern enum bfd_endian type_byte_order (const struct type *type); + /* A flag to enable printing of debugging information of C++ overloading. */ diff --git a/gdb/infcmd.c b/gdb/infcmd.c index 5ca9933..eb18efa 100644 --- a/gdb/infcmd.c +++ b/gdb/infcmd.c @@ -2216,7 +2216,7 @@ default_print_one_register_info (struct ui_file *file, { struct value_print_options opts; const gdb_byte *valaddr = value_contents_for_printing (val); - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (regtype)); + enum bfd_endian byte_order = type_byte_order (regtype); get_user_print_options (&opts); opts.deref_ref = 1; diff --git a/gdb/p-lang.c b/gdb/p-lang.c index 0cf1c6c..33cb6e6 100644 --- a/gdb/p-lang.c +++ b/gdb/p-lang.c @@ -230,7 +230,7 @@ pascal_printstr (struct ui_file *stream, struct type *type, const char *encoding, int force_ellipses, const struct value_print_options *options) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); unsigned int i; unsigned int things_printed = 0; int in_quotes = 0; diff --git a/gdb/p-valprint.c b/gdb/p-valprint.c index 10612f3..c465d14 100644 --- a/gdb/p-valprint.c +++ b/gdb/p-valprint.c @@ -67,7 +67,7 @@ pascal_val_print (struct type *type, const struct value_print_options *options) { struct gdbarch *gdbarch = get_type_arch (type); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); unsigned int i = 0; /* Number of characters printed */ unsigned len; struct type *elttype; diff --git a/gdb/printcmd.c b/gdb/printcmd.c index 323a5d0..0251d46 100644 --- a/gdb/printcmd.c +++ b/gdb/printcmd.c @@ -356,7 +356,7 @@ print_scalar_formatted (const gdb_byte *valaddr, struct type *type, { struct gdbarch *gdbarch = get_type_arch (type); unsigned int len = TYPE_LENGTH (type); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); /* String printing should go through val_print_scalar_formatted. */ gdb_assert (options->format != 's'); diff --git a/gdb/solib-darwin.c b/gdb/solib-darwin.c index 286e385..969bfd5 100644 --- a/gdb/solib-darwin.c +++ b/gdb/solib-darwin.c @@ -223,7 +223,7 @@ static struct so_list * darwin_current_sos (void) { struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); + enum bfd_endian byte_order = type_byte_order (ptr_type); int ptr_len = TYPE_LENGTH (ptr_type); unsigned int image_info_size; struct so_list *head = NULL; diff --git a/gdb/solib-svr4.c b/gdb/solib-svr4.c index 27299ff..de76557 100644 --- a/gdb/solib-svr4.c +++ b/gdb/solib-svr4.c @@ -897,7 +897,7 @@ solib_svr4_r_ldsomap (struct svr4_info *info) { struct link_map_offsets *lmo = svr4_fetch_link_map_offsets (); struct type *ptr_type = builtin_type (target_gdbarch ())->builtin_data_ptr; - enum bfd_endian byte_order = gdbarch_byte_order (target_gdbarch ()); + enum bfd_endian byte_order = type_byte_order (ptr_type); ULONGEST version = 0; try diff --git a/gdb/stap-probe.c b/gdb/stap-probe.c index ea206cb..ba92779 100644 --- a/gdb/stap-probe.c +++ b/gdb/stap-probe.c @@ -1435,8 +1435,8 @@ stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch) return; } - value = extract_unsigned_integer (bytes, TYPE_LENGTH (type), - gdbarch_byte_order (gdbarch)); + enum bfd_endian byte_order = type_byte_order (type); + value = extract_unsigned_integer (bytes, TYPE_LENGTH (type), byte_order); /* Note that we explicitly don't worry about overflow or underflow. */ if (set) @@ -1444,8 +1444,7 @@ stap_modify_semaphore (CORE_ADDR address, int set, struct gdbarch *gdbarch) else --value; - store_unsigned_integer (bytes, TYPE_LENGTH (type), - gdbarch_byte_order (gdbarch), value); + store_unsigned_integer (bytes, TYPE_LENGTH (type), byte_order, value); if (target_write_memory (address, bytes, TYPE_LENGTH (type)) != 0) warning (_("Could not write the value of a SystemTap semaphore.")); diff --git a/gdb/target-float.c b/gdb/target-float.c index 4ef3505..caa6943 100644 --- a/gdb/target-float.c +++ b/gdb/target-float.c @@ -1753,7 +1753,7 @@ match_endianness (const gdb_byte *from, const struct type *type, gdb_byte *to) #define OPPOSITE_BYTE_ORDER BFD_ENDIAN_BIG #endif - if (gdbarch_byte_order (get_type_arch (type)) == OPPOSITE_BYTE_ORDER) + if (type_byte_order (type) == OPPOSITE_BYTE_ORDER) for (i = 0; i < len; i++) to[i] = from[len - i - 1]; else @@ -2160,8 +2160,8 @@ target_float_same_format_p (const struct type *type1, case TYPE_CODE_DECFLOAT: return (TYPE_LENGTH (type1) == TYPE_LENGTH (type2) - && (gdbarch_byte_order (get_type_arch (type1)) - == gdbarch_byte_order (get_type_arch (type2)))); + && (type_byte_order (type1) + == type_byte_order (type2))); default: gdb_assert_not_reached ("unexpected type code"); diff --git a/gdb/testsuite/gdb.base/endianity.c b/gdb/testsuite/gdb.base/endianity.c new file mode 100644 index 0000000..c5ee556 --- /dev/null +++ b/gdb/testsuite/gdb.base/endianity.c @@ -0,0 +1,44 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2017 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 . */ + +/* This tests the handling of dwarf attributes: + DW_AT_endianity, DW_END_big, and DW_END_little. */ +struct otherendian +{ + int v; +} +#if defined __GNUC__ && (__GNUC__ >= 6) +#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ +__attribute__( ( scalar_storage_order( "big-endian" ) ) ) +#else +__attribute__( ( scalar_storage_order( "little-endian" ) ) ) +#endif +#endif +; + +void +do_nothing (struct otherendian *c) +{ +} + +int +main (void) +{ + struct otherendian o = {3}; + + do_nothing (&o); /* START */ +} diff --git a/gdb/testsuite/gdb.base/endianity.exp b/gdb/testsuite/gdb.base/endianity.exp new file mode 100644 index 0000000..7e02305 --- /dev/null +++ b/gdb/testsuite/gdb.base/endianity.exp @@ -0,0 +1,38 @@ +# Copyright 2017 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 . + +standard_testfile .c + +if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } { + return -1 +} + +set bp_location [gdb_get_line_number "START"] +if ![runto "endianity.c:$bp_location" ] then { + fail "couldn't run to start" + return -1 +} + +gdb_test "print o" "= {v = 3}" "print o before assignment" + +gdb_test "print o.v = 4" "= 4" + +# scalar_storage_order requires gcc >= 6 +if { ([test_compiler_info {gcc-[0-5]-*}] || ![test_compiler_info gcc*]) } { + setup_xfail "*-*-*" +} +gdb_test "x/x &o.v" "0x04000000" + +gdb_test "print o" "= {v = 4}" "print o after assignment" diff --git a/gdb/valarith.c b/gdb/valarith.c index 7f1b24f..835f35c 100644 --- a/gdb/valarith.c +++ b/gdb/valarith.c @@ -988,7 +988,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) val = allocate_value (result_type); store_signed_integer (value_contents_raw (val), TYPE_LENGTH (result_type), - gdbarch_byte_order (get_type_arch (result_type)), + type_byte_order (result_type), v); } else @@ -1136,8 +1136,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) val = allocate_value (result_type); store_unsigned_integer (value_contents_raw (val), TYPE_LENGTH (value_type (val)), - gdbarch_byte_order - (get_type_arch (result_type)), + type_byte_order (result_type), v); } else @@ -1266,8 +1265,7 @@ scalar_binop (struct value *arg1, struct value *arg2, enum exp_opcode op) val = allocate_value (result_type); store_signed_integer (value_contents_raw (val), TYPE_LENGTH (value_type (val)), - gdbarch_byte_order - (get_type_arch (result_type)), + type_byte_order (result_type), v); } } diff --git a/gdb/valops.c b/gdb/valops.c index bfdd781..4597e99 100644 --- a/gdb/valops.c +++ b/gdb/valops.c @@ -483,7 +483,7 @@ value_cast (struct type *type, struct value *arg2) if (code2 == TYPE_CODE_PTR) longest = extract_unsigned_integer (value_contents (arg2), TYPE_LENGTH (type2), - gdbarch_byte_order (get_type_arch (type2))); + type_byte_order (type2)); else longest = value_as_long (arg2); return value_from_longest (to_type, convert_to_boolean ? diff --git a/gdb/valprint.c b/gdb/valprint.c index e0eb8e1..ced0dbc 100644 --- a/gdb/valprint.c +++ b/gdb/valprint.c @@ -2402,7 +2402,7 @@ generic_emit_char (int c, struct type *type, struct ui_file *stream, int quoter, const char *encoding) { enum bfd_endian byte_order - = gdbarch_byte_order (get_type_arch (type)); + = type_byte_order (type); gdb_byte *c_buf; int need_escape = 0; @@ -2722,7 +2722,7 @@ generic_printstr (struct ui_file *stream, struct type *type, int quote_char, int c_style_terminator, const struct value_print_options *options) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); unsigned int i; int width = TYPE_LENGTH (type); int finished = 0; @@ -2834,7 +2834,7 @@ val_print_string (struct type *elttype, const char *encoding, int bytes_read; gdb::unique_xmalloc_ptr buffer; /* Dynamically growable fetch buffer. */ struct gdbarch *gdbarch = get_type_arch (elttype); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (elttype); int width = TYPE_LENGTH (elttype); /* First we need to figure out the limit on the number of characters we are diff --git a/gdb/value.c b/gdb/value.c index 47e647a..35a7a5c 100644 --- a/gdb/value.c +++ b/gdb/value.c @@ -2737,7 +2737,7 @@ value_as_address (struct value *val) LONGEST unpack_long (struct type *type, const gdb_byte *valaddr) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); enum type_code code = TYPE_CODE (type); int len = TYPE_LENGTH (type); int nosign = TYPE_UNSIGNED (type); @@ -3100,7 +3100,7 @@ static LONGEST unpack_bits_as_long (struct type *field_type, const gdb_byte *valaddr, LONGEST bitpos, LONGEST bitsize) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (field_type)); + enum bfd_endian byte_order = type_byte_order (field_type); ULONGEST val; ULONGEST valmask; int lsbcount; @@ -3209,7 +3209,7 @@ unpack_value_bitfield (struct value *dest_val, int dst_bit_offset; struct type *field_type = value_type (dest_val); - byte_order = gdbarch_byte_order (get_type_arch (field_type)); + byte_order = type_byte_order (field_type); /* First, unpack and sign extend the bitfield as if it was wholly valid. Optimized out/unavailable bits are read as zero, but @@ -3269,7 +3269,7 @@ void modify_field (struct type *type, gdb_byte *addr, LONGEST fieldval, LONGEST bitpos, LONGEST bitsize) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); ULONGEST oword; ULONGEST mask = (ULONGEST) -1 >> (8 * sizeof (ULONGEST) - bitsize); LONGEST bytesize; @@ -3315,7 +3315,7 @@ modify_field (struct type *type, gdb_byte *addr, void pack_long (gdb_byte *buf, struct type *type, LONGEST num) { - enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type)); + enum bfd_endian byte_order = type_byte_order (type); LONGEST len; type = check_typedef (type); @@ -3363,7 +3363,7 @@ pack_unsigned_long (gdb_byte *buf, struct type *type, ULONGEST num) type = check_typedef (type); len = TYPE_LENGTH (type); - byte_order = gdbarch_byte_order (get_type_arch (type)); + byte_order = type_byte_order (type); switch (TYPE_CODE (type)) {