From patchwork Thu Nov 21 18:26:34 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Peeter Joot X-Patchwork-Id: 36100 Received: (qmail 16464 invoked by alias); 21 Nov 2019 18:26:52 -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 16456 invoked by uid 89); 21 Nov 2019 18:26:52 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-25.4 required=5.0 tests=BAYES_00, FREEMAIL_FROM, GIT_PATCH_0, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_SHORT, KAM_STOCKGEN, RCVD_IN_DNSWL_NONE, SPF_PASS autolearn=ham version=3.3.1 spammy=0-5, ov, sk:signed_, wholly X-HELO: mail-qk1-f194.google.com Received: from mail-qk1-f194.google.com (HELO mail-qk1-f194.google.com) (209.85.222.194) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Thu, 21 Nov 2019 18:26:47 +0000 Received: by mail-qk1-f194.google.com with SMTP id i3so3915349qkk.9 for ; Thu, 21 Nov 2019 10:26:47 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:reply-to:mime-version :content-transfer-encoding; bh=mqgDKvY7Mk5Wsd5nlhUvITM/aQzUAQLwhToguH1AOjo=; b=WQlvCNnMLWVV0Mj1ICjAqI027j/s5iJ4h17ra1ur5YCHbbKFPWstBn93KXnINwICcD 9KqmFB9JK9XU6ReIamNfoKQT6QzHEMQF0B25rDUiPCWI5+273D0mnvirjDwIXc/EjG/Q Ljo+MDk4hthwC9Hwtx2KKt5hl5i9g8HbwvcZyBv+vSoJ5zg0uNWXQjL2kir2n+hqPxlH MN55YsU91yXwAVb6fCac1MgBW0VUD5P9DRTFnFYuxYhABMphg/TBBElYaOj4dYnBi3t0 cdun3nSNmTQTnsTTNGdXLOCnVRoibU7ciWHMXogtW1Ehoh6VJ2ozknIuShOqvF65VNC6 yAYw== Return-Path: Received: from localhost.localdomain (CPEa84e3fc40403-CMa84e3fc40400.cpe.net.cable.rogers.com. [99.244.151.109]) by smtp.gmail.com with ESMTPSA id 27sm2012726qtu.71.2019.11.21.10.26.43 (version=TLS1_2 cipher=ECDHE-RSA-AES128-GCM-SHA256 bits=128/128); Thu, 21 Nov 2019 10:26:43 -0800 (PST) From: peeter.joot@gmail.com To: gdb-patches@sourceware.org Cc: tom@tromey.com, peeter.joot@lzlabs.com Subject: [PATCH] Adjust byte order variable display/change if DW_AT_endianity is present. Date: Thu, 21 Nov 2019 13:26:34 -0500 Message-Id: <20191121182634.78392-1-peeter.joot@lzlabs.com> Reply-To: peeter.joot@lzlabs.com MIME-Version: 1.0 From: Peeter Joot # Changes since last week's submission include: 0) rebased to: commit b13e475ed21ee0b57c5ce0f3cf8489a4164734e7 (Thu Nov 21 00:00:23 2019 +0000) 1) more of the type_byte order transformations. All the functions that I can find that called both get_type_arch and gdbarch_byte_order now use type_byte_order. The Changelog was updated to include the new files/functions changed. 2) gdb/testsuite/gdb.base/endianity: add short structure member and test cases. Also updated the copyright year. 3) switch to a single bit flag (flag_endianity_not_default) The testsuite still runs cleanly, as did my manual testing (w/ DW_END_* code compiled with gcc-9.2 and our in-house PL/I compiler). Testsuite differences all look like they are probably all related to non-deterministic test cases (gdb.threads/process-dies-while-handling-bp.exp). # Patch Details: - 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.) 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): * ada-lang.c (value_pointer): (ada_value_binop): 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_NOT_DEFAULT if set. (recursive_dump_type): Print TYPE_ENDIANITY_BIG, and TYPE_ENDIANITY_LITTLE if set. (type_byte_order): new function. * gdbtypes.h (TYPE_ENDIANITY_NOT_DEFAULT): 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): (value_bit_index): 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. * findvar.c (unsigned_pointer_to_address): (signed_pointer_to_address): (unsigned_address_to_pointer): (address_to_signed_pointer): (default_read_var_value): (default_value_from_register): Use type_byte_order instead of gdbarch_byte_order. * gnu-v3-abi.c (gnuv3_make_method_ptr): Use type_byte_order instead of gdbarch_byte_order. * riscv-tdep.c (riscv_print_one_register_info): 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 | 4 ++-- 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 | 32 ++++++++++++++++--------- gdb/f-lang.c | 2 +- gdb/findvar.c | 12 +++++----- gdb/gdbtypes.c | 23 ++++++++++++++++++ gdb/gdbtypes.h | 13 +++++++++++ gdb/gnu-v3-abi.c | 2 +- gdb/infcmd.c | 2 +- gdb/p-lang.c | 2 +- gdb/p-valprint.c | 2 +- gdb/printcmd.c | 2 +- gdb/riscv-tdep.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 | 45 ++++++++++++++++++++++++++++++++++++ gdb/testsuite/gdb.base/endianity.exp | 40 ++++++++++++++++++++++++++++++++ gdb/valarith.c | 10 ++++---- gdb/valops.c | 2 +- gdb/valprint.c | 6 ++--- gdb/value.c | 12 +++++----- 27 files changed, 185 insertions(+), 58 deletions(-) create mode 100644 gdb/testsuite/gdb.base/endianity.c create mode 100644 gdb/testsuite/gdb.base/endianity.exp diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c index 2935df5..36001ef 100644 --- a/gdb/ada-lang.c +++ b/gdb/ada-lang.c @@ -4546,7 +4546,7 @@ value_pointer (struct value *value, struct type *type) addr = value_address (value); gdbarch_address_to_pointer (gdbarch, type, buf, addr); - addr = extract_unsigned_integer (buf, len, gdbarch_byte_order (gdbarch)); + addr = extract_unsigned_integer (buf, len, type_byte_order (type)); return addr; } @@ -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 9178e0e..d89a541 100644 --- a/gdb/dwarf2read.c +++ b/gdb/dwarf2read.c @@ -17661,24 +17661,24 @@ 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; + gdbarch *arch; attr = dwarf2_attr (die, DW_AT_encoding, cu); if (attr != nullptr) - { - encoding = DW_UNSND (attr); - } + encoding = DW_UNSND (attr); attr = dwarf2_attr (die, DW_AT_byte_size, cu); if (attr != nullptr) - { - bits = DW_UNSND (attr) * TARGET_CHAR_BIT; - } + bits = DW_UNSND (attr) * TARGET_CHAR_BIT; name = dwarf2_name (die, cu); if (!name) - { - complaint (_("DW_AT_name missing from DW_TAG_base_type")); - } + complaint (_("DW_AT_name missing from DW_TAG_base_type")); + attr = dwarf2_attr (die, DW_AT_endianity, cu); + if (attr) + endianity = DW_UNSND (attr); + arch = get_objfile_arch (objfile); switch (encoding) { case DW_ATE_address: @@ -17729,8 +17729,6 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) break; case DW_ATE_UTF: { - gdbarch *arch = get_objfile_arch (objfile); - if (bits == 16) type = builtin_type (arch)->builtin_char16; else if (bits == 32) @@ -17757,6 +17755,18 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu) maybe_set_alignment (cu, die, type); + switch (endianity) + { + case DW_END_big: + if (gdbarch_byte_order (arch) == BFD_ENDIAN_LITTLE) + TYPE_ENDIANITY_NOT_DEFAULT (type) = 1; + break; + case DW_END_little: + if (gdbarch_byte_order (arch) == BFD_ENDIAN_BIG) + TYPE_ENDIANITY_NOT_DEFAULT (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..95cc58d 100644 --- a/gdb/findvar.c +++ b/gdb/findvar.c @@ -309,7 +309,7 @@ CORE_ADDR unsigned_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf) { - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); return extract_unsigned_integer (buf, TYPE_LENGTH (type), byte_order); } @@ -318,7 +318,7 @@ CORE_ADDR signed_pointer_to_address (struct gdbarch *gdbarch, struct type *type, const gdb_byte *buf) { - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); return extract_signed_integer (buf, TYPE_LENGTH (type), byte_order); } @@ -329,7 +329,7 @@ void unsigned_address_to_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr) { - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); store_unsigned_integer (buf, TYPE_LENGTH (type), byte_order, addr); } @@ -338,7 +338,7 @@ void address_to_signed_pointer (struct gdbarch *gdbarch, struct type *type, gdb_byte *buf, CORE_ADDR addr) { - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); store_signed_integer (buf, TYPE_LENGTH (type), byte_order, addr); } @@ -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; @@ -840,7 +840,7 @@ default_value_from_register (struct gdbarch *gdbarch, struct type *type, an integral number of registers. Otherwise, you need to do some fiddling with the last register copied here for little endian machines. */ - if (gdbarch_byte_order (gdbarch) == BFD_ENDIAN_BIG + if (type_byte_order (type) == BFD_ENDIAN_BIG && len < register_size (gdbarch, regnum)) /* Big-endian, and we want less than full size. */ set_value_offset (value, register_size (gdbarch, regnum) - len); diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c index fd1c765..31c1a7b 100644 --- a/gdb/gdbtypes.c +++ b/gdb/gdbtypes.c @@ -3616,6 +3616,7 @@ 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_NOT_DEFAULT (type1) != TYPE_ENDIANITY_NOT_DEFAULT (type2) || TYPE_VARARGS (type1) != TYPE_VARARGS (type2) || TYPE_VECTOR (type1) != TYPE_VECTOR (type2) || TYPE_NOTTEXT (type1) != TYPE_NOTTEXT (type2) @@ -4669,6 +4670,10 @@ recursive_dump_type (struct type *type, int spaces) { puts_filtered (" TYPE_NOSIGN"); } + if (TYPE_ENDIANITY_NOT_DEFAULT (type)) + { + puts_filtered (" TYPE_ENDIANITY_NOT_DEFAULT"); + } if (TYPE_STUB (type)) { puts_filtered (" TYPE_STUB"); @@ -5617,3 +5622,21 @@ _initialize_gdbtypes (void) show_strict_type_checking, &setchecklist, &showchecklist); } + +/* See gdbtypes.h. */ +enum bfd_endian +type_byte_order (const struct type *type) +{ + bfd_endian byteorder = gdbarch_byte_order (get_type_arch (type)); + if (TYPE_ENDIANITY_NOT_DEFAULT (type)) + { + if (byteorder == BFD_ENDIAN_BIG) + return BFD_ENDIAN_LITTLE; + else if (byteorder == BFD_ENDIAN_LITTLE) + return BFD_ENDIAN_BIG; + else + return BFD_ENDIAN_UNKNOWN; + } + + return byteorder; +} diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h index 6d6ff59..8fc770c 100644 --- a/gdb/gdbtypes.h +++ b/gdb/gdbtypes.h @@ -219,6 +219,12 @@ DEF_ENUM_FLAGS_TYPE (enum type_instance_flag_value, type_instance_flags); #define TYPE_NOSIGN(t) (TYPE_MAIN_TYPE (t)->flag_nosign) +/* * A compiler may supply dwarf instrumentation + that indicates the desired endian interpretation of the variable + differs from the native endian representation. */ + +#define TYPE_ENDIANITY_NOT_DEFAULT(t) (TYPE_MAIN_TYPE (t)->flag_endianity_not_default) + /* * 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 +707,7 @@ 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_not_default : 1; /* * True if this type was declared with "class" rather than "struct". */ @@ -2146,6 +2153,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/gnu-v3-abi.c b/gdb/gnu-v3-abi.c index 2533a94..2a5486c 100644 --- a/gdb/gnu-v3-abi.c +++ b/gdb/gnu-v3-abi.c @@ -678,7 +678,7 @@ gnuv3_make_method_ptr (struct type *type, gdb_byte *contents, { struct gdbarch *gdbarch = get_type_arch (type); int size = TYPE_LENGTH (builtin_type (gdbarch)->builtin_data_ptr); - enum bfd_endian byte_order = gdbarch_byte_order (gdbarch); + enum bfd_endian byte_order = type_byte_order (type); /* FIXME drow/2006-12-24: The adjustment of "this" is currently always zero, since the method pointer is of the correct type. 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/riscv-tdep.c b/gdb/riscv-tdep.c index 810b834..d262b7d 100644 --- a/gdb/riscv-tdep.c +++ b/gdb/riscv-tdep.c @@ -688,7 +688,7 @@ riscv_print_one_register_info (struct gdbarch *gdbarch, { 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/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..5ab090d --- /dev/null +++ b/gdb/testsuite/gdb.base/endianity.c @@ -0,0 +1,45 @@ +/* This testcase is part of GDB, the GNU debugger. + + Copyright 2019 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; + short w; +} +#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,2}; + + 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..80df012 --- /dev/null +++ b/gdb/testsuite/gdb.base/endianity.exp @@ -0,0 +1,40 @@ +# Copyright 2019 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, w = 2}" "print o before assignment" + +gdb_test "print o.v = 4" "= 4" +gdb_test "print o.w = 3" "= 3" + +# 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 "x/xh &o.w" "0x0300" + +gdb_test "print o" "= {v = 4, w = 3}" "print o after assignment" diff --git a/gdb/valarith.c b/gdb/valarith.c index 7f1b24f..ea999b5 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); } } @@ -1712,7 +1710,7 @@ value_bit_index (struct type *type, const gdb_byte *valaddr, int index) return -1; rel_index = index - low_bound; word = extract_unsigned_integer (valaddr + (rel_index / TARGET_CHAR_BIT), 1, - gdbarch_byte_order (gdbarch)); + type_byte_order (type)); rel_index %= TARGET_CHAR_BIT; if (gdbarch_bits_big_endian (gdbarch)) rel_index = TARGET_CHAR_BIT - 1 - rel_index; 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)) {