[PR gdb/22640] ptype: add option to use hexadecimal notation

This commit adds a flag to the ptype command in order to print the
offsets and sizes of struct members using the hexadecimal notation.  The
'x' flag ensures use of the hexadecimal notation while the 'd' flag
ensures use of the decimal notation.  The default is to use decimal
notation.

Before this patch, gdb only uses decimal notation, as pointed out in PR
gdb/22640.

Here is an example of this new behavior with hex output turned on:

    (gdb) ptype /ox struct type_print_options
    /* offset      |    size */  type = struct type_print_options {
    /* 0x0000: 0x0 |  0x0004 */    unsigned int raw : 1;
    /* 0x0000: 0x1 |  0x0004 */    unsigned int print_methods : 1;
    /* 0x0000: 0x2 |  0x0004 */    unsigned int print_typedefs : 1;
    /* 0x0000: 0x3 |  0x0004 */    unsigned int print_offsets : 1;
    /* 0x0000: 0x4 |  0x0004 */    unsigned int print_in_hex : 1;
    /* XXX  3-bit hole       */
    /* XXX  3-byte hole      */
    /* 0x0004      |  0x0004 */    int print_nested_type_limit;
    /* 0x0008      |  0x0008 */    typedef_hash_table *local_typedefs;
    /* 0x0010      |  0x0008 */    typedef_hash_table *global_typedefs;
    /* 0x0018      |  0x0008 */    ext_lang_type_printers *global_printers;

                                   /* total size (bytes):   32 */
                                 }

This patch also adds the 'set print type hex' and 'show print type hex'
commands in order to set and inspect the default behavior regarding the
use of decimal or hexadecimal notation when printing struct sizes and
offsets.

Tested using on x86_64.

gdb/ChangeLog:

	PR gdb/22640
	* typeprint.h (struct type_print_options): Add print_in_hex
	flag.
	(struct print_offset_data): Add print_in_hex flag, add a
	constructor accepting a type_print_options* argument.
	* typeprint.c (type_print_raw_options, default_ptype_flags): Set
	default value for print_in_hex.
	(print_offset_data::indentation): Allow more horizontal space.
	(print_offset_data::print_offset_data): Add ctor.
	(print_offset_data::maybe_print_hole, print_offset_data::update):
	Handle the print_in_hex flag.
	(whatis_exp): Handle 'x' and 'd' flags.
	(print_offsets_and_sizes_in_hex): Declare.
	(set_print_offsets_and_sizes_in_hex): Create.
	(show_print_offsets_and_sizes_in_hex): Create.
	(_initialize_typeprint): Update help message for the ptype
	command, register the 'set print type hex' and 'show print type
	hex' commands.
	* c-typeprint.c (c_print_type, c_type_print_base_struct_union)
	(c_type_print_base): Construct the print_offset_data
	object using the type_print_optons parameter.
	* rust-lang.c (rust_language::print_type): Construct the
	print_offset_data object using the type_print_optons parameter.
	* NEWS: Mention the new flags of the ptype command.

gdb/doc/ChangeLog:

	PR gdb/22640
	* gdb.texinfo (Symbols): Describe the 'x' and 'd' flags of the
	ptype command, describe 'set print type hex' and 'show print
	type hex' commands.  Update 'ptype/o' examples.

gdb/testsuite/ChangeLog:

	PR gdb/22640
	* gdb.base/ptype-offsets.exp: Add tests to verify the behavior
	of 'ptype/ox' and 'ptype/od'. Check that 'set print type hex'
	changes the default behavior of 'ptype/o'.  Update to take into
	account new horizontal layout.
	* gdb.rust/simple.exp: Update ptype test to check new horizontal
	layout.
	* gdb.rust/union.exp: Same.

4 files changed, 359 insertions, 234 deletions

diff --git a/gdb/testsuite/ChangeLog b/gdb/testsuite/ChangeLog
index 73f95b9..8f41b3a 100644
--- a/gdb/testsuite/ChangeLog
+++ b/gdb/testsuite/ChangeLog
@@ -1,3 +1,14 @@
+2021-04-25  Lancelot Six  <lsix@lancelotsix.com>
+
+	PR gdb/22640
+	* gdb.base/ptype-offsets.exp: Add tests to verify the behavior
+	of 'ptype/ox' and 'ptype/od'. Check that 'set print type hex'
+	changes the default behavior of 'ptype/o'.  Update to take into
+	account new horizontal layout.
+	* gdb.rust/simple.exp: Update ptype test to check new horizontal
+	layout.
+	* gdb.rust/union.exp: Same.
+
 2021-04-23  Andrew Burgess  <andrew.burgess@embecosm.com>
 
 	* gdb.base/info_sources.exp: Add new tests.
diff --git a/gdb/testsuite/gdb.base/ptype-offsets.exp b/gdb/testsuite/gdb.base/ptype-offsets.exp
index 0a0bbc8..cc017ad 100644
--- a/gdb/testsuite/gdb.base/ptype-offsets.exp
+++ b/gdb/testsuite/gdb.base/ptype-offsets.exp
@@ -35,216 +35,271 @@ if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
 # Test general offset printing, ctor/dtor printing, union, formatting.
 gdb_test "ptype /o struct abc" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct abc \{" \
-"                         public:" \
-"/*    8      |     8 */    void *field1;" \
-"/*   16: 0   |     4 */    unsigned int field2 : 1;" \
-"/* XXX  7-bit hole   */" \
-"/* XXX  3-byte hole  */" \
-"/*   20      |     4 */    int field3;" \
-"/*   24      |     1 */    signed char field4;" \
-"/* XXX  7-byte hole  */" \
-"/*   32      |     8 */    uint64_t field5;" \
-"/*   40      |     8 */    union \{" \
-"/*                 8 */        void *field6;" \
-"/*                 4 */        int field7;" \
+"/* offset      |    size */  type = struct abc \{" \
+"                             public:" \
+"/*      8      |       8 */    void *field1;" \
+"/*     16: 0   |       4 */    unsigned int field2 : 1;" \
+"/* XXX  7-bit hole       */" \
+"/* XXX  3-byte hole      */" \
+"/*     20      |       4 */    int field3;" \
+"/*     24      |       1 */    signed char field4;" \
+"/* XXX  7-byte hole      */" \
+"/*     32      |       8 */    uint64_t field5;" \
+"/*     40      |       8 */    union \{" \
+"/*                     8 */        void *field6;" \
+"/*                     4 */        int field7;" \
 "" \
-"                               /* total size (bytes):    8 */" \
-"                           \} field8;" \
-"/*   48      |     2 */    my_int_type field9;" \
-"/* XXX  6-byte padding  */" \
+"                                   /* total size (bytes):    8 */" \
+"                               \} field8;" \
+"/*     48      |       2 */    my_int_type field9;" \
+"/* XXX  6-byte padding   */" \
 "" \
-"                           /* total size (bytes):   56 */" \
-"                         \}"]]
+"                               /* total size (bytes):   56 */" \
+"                             \}"]]
+
+# test "ptype /ox"
+gdb_test "ptype /ox struct abc" \
+    [string_to_regexp [multi_line \
+"/* offset      |    size */  type = struct abc {" \
+"                             public:" \
+"/* 0x0008      |  0x0008 */    void *field1;" \
+"/* 0x0010: 0x0 |  0x0004 */    unsigned int field2 : 1;" \
+"/* XXX  7-bit hole       */" \
+"/* XXX  3-byte hole      */" \
+"/* 0x0014      |  0x0004 */    int field3;" \
+"/* 0x0018      |  0x0001 */    signed char field4;" \
+"/* XXX  7-byte hole      */" \
+"/* 0x0020      |  0x0008 */    uint64_t field5;" \
+"/* 0x0028      |  0x0008 */    union \{" \
+"/*                0x0008 */        void *field6;" \
+"/*                0x0004 */        int field7;" \
+"" \
+"                                   /* total size (bytes):    8 */" \
+"                               \} field8;" \
+"/* 0x0030      |  0x0002 */    my_int_type field9;" \
+"/* XXX  6-byte padding   */" \
+"" \
+"                               /* total size (bytes):   56 */" \
+"                             \}"]]
 
 # Test "ptype /oTM".
 gdb_test "ptype /oTM struct abc" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct abc \{" \
-"                         public:" \
-"/*    8      |     8 */    void *field1;" \
-"/*   16: 0   |     4 */    unsigned int field2 : 1;" \
-"/* XXX  7-bit hole   */" \
-"/* XXX  3-byte hole  */" \
-"/*   20      |     4 */    int field3;" \
-"/*   24      |     1 */    signed char field4;" \
-"/* XXX  7-byte hole  */" \
-"/*   32      |     8 */    uint64_t field5;" \
-"/*   40      |     8 */    union \{" \
-"/*                 8 */        void *field6;" \
-"/*                 4 */        int field7;" \
+"/* offset      |    size */  type = struct abc \{" \
+"                             public:" \
+"/*      8      |       8 */    void *field1;" \
+"/*     16: 0   |       4 */    unsigned int field2 : 1;" \
+"/* XXX  7-bit hole       */" \
+"/* XXX  3-byte hole      */" \
+"/*     20      |       4 */    int field3;" \
+"/*     24      |       1 */    signed char field4;" \
+"/* XXX  7-byte hole      */" \
+"/*     32      |       8 */    uint64_t field5;" \
+"/*     40      |       8 */    union \{" \
+"/*                     8 */        void *field6;" \
+"/*                     4 */        int field7;" \
 "" \
-"                               /* total size (bytes):    8 */" \
-"                           \} field8;" \
-"/*   48      |     2 */    my_int_type field9;" \
+"                                   /* total size (bytes):    8 */" \
+"                               \} field8;" \
+"/*     48      |       2 */    my_int_type field9;" \
 "" \
-"                           abc(void);" \
-"                           ~abc();" \
+"                               abc(void);" \
+"                               ~abc();" \
 "" \
-"                           typedef short my_int_type;" \
-"/* XXX  6-byte padding  */" \
+"                               typedef short my_int_type;" \
+"/* XXX  6-byte padding   */" \
 "" \
-"                           /* total size (bytes):   56 */" \
-"                         \}"]]
+"                               /* total size (bytes):   56 */" \
+"                             \}"]]
 
 # Test "ptype /TMo".  This should be the same as "ptype /o".
 gdb_test "ptype /TMo struct abc" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct abc \{" \
-"                         public:" \
-"/*    8      |     8 */    void *field1;" \
-"/*   16: 0   |     4 */    unsigned int field2 : 1;" \
-"/* XXX  7-bit hole   */" \
-"/* XXX  3-byte hole  */" \
-"/*   20      |     4 */    int field3;" \
-"/*   24      |     1 */    signed char field4;" \
-"/* XXX  7-byte hole  */" \
-"/*   32      |     8 */    uint64_t field5;" \
-"/*   40      |     8 */    union \{" \
-"/*                 8 */        void *field6;" \
-"/*                 4 */        int field7;" \
+"/* offset      |    size */  type = struct abc \{" \
+"                             public:" \
+"/*      8      |       8 */    void *field1;" \
+"/*     16: 0   |       4 */    unsigned int field2 : 1;" \
+"/* XXX  7-bit hole       */" \
+"/* XXX  3-byte hole      */" \
+"/*     20      |       4 */    int field3;" \
+"/*     24      |       1 */    signed char field4;" \
+"/* XXX  7-byte hole      */" \
+"/*     32      |       8 */    uint64_t field5;" \
+"/*     40      |       8 */    union \{" \
+"/*                     8 */        void *field6;" \
+"/*                     4 */        int field7;" \
 "" \
-"                               /* total size (bytes):    8 */" \
-"                           \} field8;" \
-"/*   48      |     2 */    my_int_type field9;" \
-"/* XXX  6-byte padding  */" \
+"                                   /* total size (bytes):    8 */" \
+"                               \} field8;" \
+"/*     48      |       2 */    my_int_type field9;" \
+"/* XXX  6-byte padding   */" \
 "" \
-"                           /* total size (bytes):   56 */" \
-"                         \}"]]
+"                               /* total size (bytes):   56 */" \
+"                             \}"]]
 
 # Test nested structs.
 gdb_test "ptype /o struct pqr" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct pqr \{" \
-"/*    0      |     4 */    int ff1;" \
-"/* XXX  4-byte hole  */" \
-"/*    8      |    40 */    struct xyz \{" \
-"/*    8      |     4 */        int f1;" \
-"/*   12      |     1 */        signed char f2;" \
-"/* XXX  3-byte hole  */" \
-"/*   16      |     8 */        void *f3;" \
-"/*   24      |    24 */        struct tuv \{" \
-"/*   24      |     4 */            int a1;" \
-"/* XXX  4-byte hole  */" \
-"/*   32      |     8 */            signed char *a2;" \
-"/*   40      |     4 */            int a3;" \
-"/* XXX  4-byte padding  */" \
+"/* offset      |    size */  type = struct pqr \{" \
+"/*      0      |       4 */    int ff1;" \
+"/* XXX  4-byte hole      */" \
+"/*      8      |      40 */    struct xyz \{" \
+"/*      8      |       4 */        int f1;" \
+"/*     12      |       1 */        signed char f2;" \
+"/* XXX  3-byte hole      */" \
+"/*     16      |       8 */        void *f3;" \
+"/*     24      |      24 */        struct tuv \{" \
+"/*     24      |       4 */            int a1;" \
+"/* XXX  4-byte hole      */" \
+"/*     32      |       8 */            signed char *a2;" \
+"/*     40      |       4 */            int a3;" \
+"/* XXX  4-byte padding   */" \
 "" \
-"                                   /* total size (bytes):   24 */" \
-"                               \} f4;" \
+"                                       /* total size (bytes):   24 */" \
+"                                   \} f4;" \
 "" \
-"                               /* total size (bytes):   40 */" \
-"                           \} ff2;" \
-"/*   48      |     1 */    signed char ff3;" \
-"/* XXX  7-byte padding  */" \
+"                                   /* total size (bytes):   40 */" \
+"                               \} ff2;" \
+"/*     48      |       1 */    signed char ff3;" \
+"/* XXX  7-byte padding   */" \
 "" \
-"                           /* total size (bytes):   56 */" \
-"                         \}"]]
+"                               /* total size (bytes):   56 */" \
+"                             \}"]]
 
-# Test that the offset is properly reset when we are printing a union
-# and go inside two inner structs.
-# This also tests a struct inside a struct inside a union.
-gdb_test "ptype /o union qwe" \
+# Test nested struct with /x
+gdb_test "ptype /ox struct pqr" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = union qwe \{" \
-"/*                24 */    struct tuv \{" \
-"/*    0      |     4 */        int a1;" \
-"/* XXX  4-byte hole  */" \
-"/*    8      |     8 */        signed char *a2;" \
-"/*   16      |     4 */        int a3;" \
-"/* XXX  4-byte padding  */" \
+"/* offset      |    size */  type = struct pqr \{" \
+"/* 0x0000      |  0x0004 */    int ff1;" \
+"/* XXX  4-byte hole      */" \
+"/* 0x0008      |  0x0028 */    struct xyz \{" \
+"/* 0x0008      |  0x0004 */        int f1;" \
+"/* 0x000c      |  0x0001 */        signed char f2;" \
+"/* XXX  3-byte hole      */" \
+"/* 0x0010      |  0x0008 */        void *f3;" \
+"/* 0x0018      |  0x0018 */        struct tuv \{" \
+"/* 0x0018      |  0x0004 */            int a1;" \
+"/* XXX  4-byte hole      */" \
+"/* 0x0020      |  0x0008 */            signed char *a2;" \
+"/* 0x0028      |  0x0004 */            int a3;" \
+"/* XXX  4-byte padding   */" \
 "" \
-"                               /* total size (bytes):   24 */" \
-"                           \} fff1;" \
-"/*                40 */    struct xyz \{" \
-"/*    0      |     4 */        int f1;" \
-"/*    4      |     1 */        signed char f2;" \
-"/* XXX  3-byte hole  */" \
-"/*    8      |     8 */        void *f3;" \
-"/*   16      |    24 */        struct tuv \{" \
-"/*   16      |     4 */            int a1;" \
-"/* XXX  4-byte hole  */" \
-"/*   24      |     8 */            signed char *a2;" \
-"/*   32      |     4 */            int a3;" \
-"/* XXX  4-byte padding  */" \
-"" \
-"                                   /* total size (bytes):   24 */" \
-"                               \} f4;" \
+"                                       /* total size (bytes):   24 */" \
+"                                   \} f4;" \
 "" \
-"                               /* total size (bytes):   40 */" \
-"                           \} fff2;" \
+"                                   /* total size (bytes):   40 */" \
+"                               \} ff2;" \
+"/* 0x0030      |  0x0001 */    signed char ff3;" \
+"/* XXX  7-byte padding   */" \
 "" \
-"                           /* total size (bytes):   40 */" \
-"                         \}"]]
+"                               /* total size (bytes):   56 */" \
+"                             \}"]]
 
-# Test printing a struct that contains a union, and that also
-# contains a struct.
-gdb_test "ptype /o struct poi" \
+
+# Test that the offset is properly reset when we are printing a union
+# and go inside two inner structs.
+# This also tests a struct inside a struct inside a union.
+gdb_test "ptype /o union qwe" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct poi \{" \
-"/*    0      |     4 */    int f1;" \
-"/* XXX  4-byte hole  */" \
-"/*    8      |    40 */    union qwe \{" \
-"/*                24 */        struct tuv \{" \
-"/*    8      |     4 */            int a1;" \
-"/* XXX  4-byte hole  */" \
-"/*   16      |     8 */            signed char *a2;" \
-"/*   24      |     4 */            int a3;" \
-"/* XXX  4-byte padding  */" \
+"/* offset      |    size */  type = union qwe \{" \
+"/*                    24 */    struct tuv \{" \
+"/*      0      |       4 */        int a1;" \
+"/* XXX  4-byte hole      */" \
+"/*      8      |       8 */        signed char *a2;" \
+"/*     16      |       4 */        int a3;" \
+"/* XXX  4-byte padding   */" \
 "" \
 "                                   /* total size (bytes):   24 */" \
 "                               \} fff1;" \
-"/*                40 */        struct xyz \{" \
-"/*    8      |     4 */            int f1;" \
-"/*   12      |     1 */            signed char f2;" \
-"/* XXX  3-byte hole  */" \
-"/*   16      |     8 */            void *f3;" \
-"/*   24      |    24 */            struct tuv \{" \
-"/*   24      |     4 */                int a1;" \
-"/* XXX  4-byte hole  */" \
-"/*   32      |     8 */                signed char *a2;" \
-"/*   40      |     4 */                int a3;" \
-"/* XXX  4-byte padding  */" \
+"/*                    40 */    struct xyz \{" \
+"/*      0      |       4 */        int f1;" \
+"/*      4      |       1 */        signed char f2;" \
+"/* XXX  3-byte hole      */" \
+"/*      8      |       8 */        void *f3;" \
+"/*     16      |      24 */        struct tuv \{" \
+"/*     16      |       4 */            int a1;" \
+"/* XXX  4-byte hole      */" \
+"/*     24      |       8 */            signed char *a2;" \
+"/*     32      |       4 */            int a3;" \
+"/* XXX  4-byte padding   */" \
 "" \
 "                                       /* total size (bytes):   24 */" \
 "                                   \} f4;" \
 "" \
 "                                   /* total size (bytes):   40 */" \
 "                               \} fff2;" \
-"/* XXX 32-byte padding  */" \
 "" \
 "                               /* total size (bytes):   40 */" \
-"                           \} f2;" \
-"/*   48      |     2 */    uint16_t f3;" \
-"/* XXX  6-byte hole  */" \
-"/*   56      |    56 */    struct pqr \{" \
-"/*   56      |     4 */        int ff1;" \
-"/* XXX  4-byte hole  */" \
-"/*   64      |    40 */        struct xyz \{" \
-"/*   64      |     4 */            int f1;" \
-"/*   68      |     1 */            signed char f2;" \
-"/* XXX  3-byte hole  */" \
-"/*   72      |     8 */            void *f3;" \
-"/*   80      |    24 */            struct tuv \{" \
-"/*   80      |     4 */                int a1;" \
-"/* XXX  4-byte hole  */" \
-"/*   88      |     8 */                signed char *a2;" \
-"/*   96      |     4 */                int a3;" \
-"/* XXX  4-byte padding  */" \
+"                             \}"]]
+
+# Test printing a struct that contains a union, and that also
+# contains a struct.
+gdb_test "ptype /o struct poi" \
+    [string_to_regexp [multi_line \
+"/* offset      |    size */  type = struct poi \{" \
+"/*      0      |       4 */    int f1;" \
+"/* XXX  4-byte hole      */" \
+"/*      8      |      40 */    union qwe \{" \
+"/*                    24 */        struct tuv \{" \
+"/*      8      |       4 */            int a1;" \
+"/* XXX  4-byte hole      */" \
+"/*     16      |       8 */            signed char *a2;" \
+"/*     24      |       4 */            int a3;" \
+"/* XXX  4-byte padding   */" \
 "" \
 "                                       /* total size (bytes):   24 */" \
-"                                   \} f4;" \
+"                                   \} fff1;" \
+"/*                    40 */        struct xyz \{" \
+"/*      8      |       4 */            int f1;" \
+"/*     12      |       1 */            signed char f2;" \
+"/* XXX  3-byte hole      */" \
+"/*     16      |       8 */            void *f3;" \
+"/*     24      |      24 */            struct tuv \{" \
+"/*     24      |       4 */                int a1;" \
+"/* XXX  4-byte hole      */" \
+"/*     32      |       8 */                signed char *a2;" \
+"/*     40      |       4 */                int a3;" \
+"/* XXX  4-byte padding   */" \
+"" \
+"                                           /* total size (bytes):   24 */" \
+"                                       \} f4;" \
+"" \
+"                                       /* total size (bytes):   40 */" \
+"                                   \} fff2;" \
+"/* XXX 32-byte padding   */" \
 "" \
 "                                   /* total size (bytes):   40 */" \
-"                               \} ff2;" \
-"/*  104      |     1 */        signed char ff3;" \
-"/* XXX  7-byte padding  */" \
+"                               \} f2;" \
+"/*     48      |       2 */    uint16_t f3;" \
+"/* XXX  6-byte hole      */" \
+"/*     56      |      56 */    struct pqr \{" \
+"/*     56      |       4 */        int ff1;" \
+"/* XXX  4-byte hole      */" \
+"/*     64      |      40 */        struct xyz \{" \
+"/*     64      |       4 */            int f1;" \
+"/*     68      |       1 */            signed char f2;" \
+"/* XXX  3-byte hole      */" \
+"/*     72      |       8 */            void *f3;" \
+"/*     80      |      24 */            struct tuv \{" \
+"/*     80      |       4 */                int a1;" \
+"/* XXX  4-byte hole      */" \
+"/*     88      |       8 */                signed char *a2;" \
+"/*     96      |       4 */                int a3;" \
+"/* XXX  4-byte padding   */" \
 "" \
-"                               /* total size (bytes):   56 */" \
-"                           \} f4;" \
+"                                           /* total size (bytes):   24 */" \
+"                                       \} f4;" \
+"" \
+"                                       /* total size (bytes):   40 */" \
+"                                   \} ff2;" \
+"/*    104      |       1 */        signed char ff3;" \
+"/* XXX  7-byte padding   */" \
+"" \
+"                                   /* total size (bytes):   56 */" \
+"                               \} f4;" \
 "" \
-"                           /* total size (bytes):  112 */" \
-"                         \}"]]
+"                               /* total size (bytes):  112 */" \
+"                             \}"]]
 
 # Test printing a struct with several bitfields, laid out in various
 # ways.
@@ -263,58 +318,58 @@ gdb_test "ptype /o struct poi" \
 #   0x7fffffffd550: 0xff    0x00    0x00    0x00    0x00    0x00    0x00    0x00
 gdb_test "ptype /o struct tyu" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct tyu \{" \
-"/*    0: 0   |     4 */    int a1 : 1;" \
-"/*    0: 1   |     4 */    int a2 : 3;" \
-"/*    0: 4   |     4 */    int a3 : 23;" \
-"/*    3: 3   |     1 */    signed char a4 : 2;" \
-"/* XXX  3-bit hole   */" \
-"/* XXX  4-byte hole  */" \
-"/*    8      |     8 */    int64_t a5;" \
-"/*   16: 0   |     4 */    int a6 : 5;" \
-"/*   16: 5   |     8 */    int64_t a7 : 3;" \
-"/* XXX  7-byte padding  */" \
-"" \
-"                           /* total size (bytes):   24 */" \
-"                         \}"]]
+"/* offset      |    size */  type = struct tyu \{" \
+"/*      0: 0   |       4 */    int a1 : 1;" \
+"/*      0: 1   |       4 */    int a2 : 3;" \
+"/*      0: 4   |       4 */    int a3 : 23;" \
+"/*      3: 3   |       1 */    signed char a4 : 2;" \
+"/* XXX  3-bit hole       */" \
+"/* XXX  4-byte hole      */" \
+"/*      8      |       8 */    int64_t a5;" \
+"/*     16: 0   |       4 */    int a6 : 5;" \
+"/*     16: 5   |       8 */    int64_t a7 : 3;" \
+"/* XXX  7-byte padding   */" \
+"" \
+"                               /* total size (bytes):   24 */" \
+"                             \}"]]
 
 gdb_test "ptype /o struct asd" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct asd \{" \
-"/*    0      |    32 */    struct asd::jkl \{" \
-"/*    0      |     8 */        signed char *f1;" \
-"/*    8      |     8 */        union \{" \
-"/*                 8 */            void *ff1;" \
+"/* offset      |    size */  type = struct asd \{" \
+"/*      0      |      32 */    struct asd::jkl \{" \
+"/*      0      |       8 */        signed char *f1;" \
+"/*      8      |       8 */        union \{" \
+"/*                     8 */            void *ff1;" \
 "" \
-"                                   /* total size (bytes):    8 */" \
-"                               \} f2;" \
-"/*   16      |     8 */        union \{" \
-"/*                 8 */            signed char *ff2;" \
+"                                       /* total size (bytes):    8 */" \
+"                                   \} f2;" \
+"/*     16      |       8 */        union \{" \
+"/*                     8 */            signed char *ff2;" \
 "" \
-"                                   /* total size (bytes):    8 */" \
-"                               \} f3;" \
-"/*   24: 0   |     4 */        int f4 : 5;" \
-"/*   24: 5   |     4 */        unsigned int f5 : 1;" \
-"/* XXX  2-bit hole   */" \
-"/* XXX  1-byte hole  */" \
-"/*   26      |     2 */        short f6;" \
-"/* XXX  4-byte padding  */" \
-"" \
-"                               /* total size (bytes):   32 */" \
-"                           \} f7;" \
-"/*   32      |     8 */    unsigned long f8;" \
-"/*   40      |     8 */    signed char *f9;" \
-"/*   48: 0   |     4 */    int f10 : 4;" \
-"/*   48: 4   |     4 */    unsigned int f11 : 1;" \
-"/*   48: 5   |     4 */    unsigned int f12 : 1;" \
-"/*   48: 6   |     4 */    unsigned int f13 : 1;" \
-"/*   48: 7   |     4 */    unsigned int f14 : 1;" \
-"/* XXX  7-byte hole  */" \
-"/*   56      |     8 */    void *f15;" \
-"/*   64      |     8 */    void *f16;" \
-"" \
-"                           /* total size (bytes):   72 */" \
-"                         \}"]]
+"                                       /* total size (bytes):    8 */" \
+"                                   \} f3;" \
+"/*     24: 0   |       4 */        int f4 : 5;" \
+"/*     24: 5   |       4 */        unsigned int f5 : 1;" \
+"/* XXX  2-bit hole       */" \
+"/* XXX  1-byte hole      */" \
+"/*     26      |       2 */        short f6;" \
+"/* XXX  4-byte padding   */" \
+"" \
+"                                   /* total size (bytes):   32 */" \
+"                               \} f7;" \
+"/*     32      |       8 */    unsigned long f8;" \
+"/*     40      |       8 */    signed char *f9;" \
+"/*     48: 0   |       4 */    int f10 : 4;" \
+"/*     48: 4   |       4 */    unsigned int f11 : 1;" \
+"/*     48: 5   |       4 */    unsigned int f12 : 1;" \
+"/*     48: 6   |       4 */    unsigned int f13 : 1;" \
+"/*     48: 7   |       4 */    unsigned int f14 : 1;" \
+"/* XXX  7-byte hole      */" \
+"/*     56      |       8 */    void *f15;" \
+"/*     64      |       8 */    void *f16;" \
+"" \
+"                               /* total size (bytes):   72 */" \
+"                             \}"]]
 
 # Test that we don't print any header when issuing a "ptype /o" on a
 # non-struct, non-union, non-class type.
@@ -334,24 +389,83 @@ gdb_test_multiple "$test" "$test" {
 # get us into an infinite loop.
 gdb_test "ptype/o static_member" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct static_member \{" \
-"                           static static_member Empty;" \
-"/*    0      |     4 */    int abc;" \
+"/* offset      |    size */  type = struct static_member \{" \
+"                               static static_member Empty;" \
+"/*      0      |       4 */    int abc;" \
 "" \
-"                           /* total size (bytes):    4 */" \
-"                         \}"]]
+"                               /* total size (bytes):    4 */" \
+"                             \}"]]
 
 # Test that the "no data fields" text is indented properly.
 gdb_test "ptype/o empty_member" \
     [string_to_regexp [multi_line \
-"/* offset    |  size */  type = struct empty_member \{" \
-"/*    0      |     1 */    struct {" \
-"                               <no data fields>" \
+"/* offset      |    size */  type = struct empty_member \{" \
+"/*      0      |       1 */    struct {" \
+"                                   <no data fields>" \
 "" \
-"                               /* total size (bytes):    1 */" \
-"                           } empty;" \
-"/* XXX  3-byte hole  */" \
-"/*    4      |     4 */    int an_int;" \
+"                                   /* total size (bytes):    1 */" \
+"                               } empty;" \
+"/* XXX  3-byte hole      */" \
+"/*      4      |       4 */    int an_int;" \
 "" \
-"                           /* total size (bytes):    8 */" \
-"                         \}"]]
+"                               /* total size (bytes):    8 */" \
+"                             \}"]]
+
+with_test_prefix "with_hex_default" {
+  # Test setting default display to hex
+  send_gdb "set print type hex on\n"
+  gdb_test "show print type hex" \
+           "Display of struct members offsets and sizes in hexadecimal is on"
+
+  # test "ptype /o" is now equivalent to "ptype /ox"
+  gdb_test "ptype /o struct abc" \
+      [string_to_regexp [multi_line \
+  "/* offset      |    size */  type = struct abc \{" \
+  "                             public:" \
+  "/* 0x0008      |  0x0008 */    void *field1;" \
+  "/* 0x0010: 0x0 |  0x0004 */    unsigned int field2 : 1;" \
+  "/* XXX  7-bit hole       */" \
+  "/* XXX  3-byte hole      */" \
+  "/* 0x0014      |  0x0004 */    int field3;" \
+  "/* 0x0018      |  0x0001 */    signed char field4;" \
+  "/* XXX  7-byte hole      */" \
+  "/* 0x0020      |  0x0008 */    uint64_t field5;" \
+  "/* 0x0028      |  0x0008 */    union \{" \
+  "/*                0x0008 */        void *field6;" \
+  "/*                0x0004 */        int field7;" \
+  "" \
+  "                                   /* total size (bytes):    8 */" \
+  "                               \} field8;" \
+  "/* 0x0030      |  0x0002 */    my_int_type field9;" \
+  "/* XXX  6-byte padding   */" \
+  "" \
+  "                               /* total size (bytes):   56 */" \
+  "                             \}"]]
+
+  gdb_test "ptype /od struct abc" \
+      [string_to_regexp [multi_line \
+  "/* offset      |    size */  type = struct abc \{" \
+  "                             public:" \
+  "/*      8      |       8 */    void *field1;" \
+  "/*     16: 0   |       4 */    unsigned int field2 : 1;" \
+  "/* XXX  7-bit hole       */" \
+  "/* XXX  3-byte hole      */" \
+  "/*     20      |       4 */    int field3;" \
+  "/*     24      |       1 */    signed char field4;" \
+  "/* XXX  7-byte hole      */" \
+  "/*     32      |       8 */    uint64_t field5;" \
+  "/*     40      |       8 */    union \{" \
+  "/*                     8 */        void *field6;" \
+  "/*                     4 */        int field7;" \
+  "" \
+  "                                   /* total size (bytes):    8 */" \
+  "                               \} field8;" \
+  "/*     48      |       2 */    my_int_type field9;" \
+  "/* XXX  6-byte padding   */" \
+  "" \
+  "                               /* total size (bytes):   56 */" \
+  "                             \}"]]
+
+  # restore
+  send_gdb "set print type hex off\n"
+}
diff --git a/gdb/testsuite/gdb.rust/simple.exp b/gdb/testsuite/gdb.rust/simple.exp
index 1588e15..cf9d400 100644
--- a/gdb/testsuite/gdb.rust/simple.exp
+++ b/gdb/testsuite/gdb.rust/simple.exp
@@ -364,12 +364,12 @@ gdb_test "print parametrized" \
     " = simple::ParametrizedStruct<i32> \\{next: simple::ParametrizedEnum<\[a-z:\]*Box<simple::ParametrizedStruct<i32>.*>>::Val\\{val: $hex\\}, value: 0\\}"
 
 gdb_test_sequence "ptype/o SimpleLayout" "" {
-    "/\\* offset    |  size \\*/  type = struct simple::SimpleLayout {"
-    "/\\*    0      |     2 \\*/    f1: u16,"
-    "/\\*    2      |     2 \\*/    f2: u16,"
+    "/\\* offset      |    size \\*/  type = struct simple::SimpleLayout {"
+    "/\\*      0      |       2 \\*/    f1: u16,"
+    "/\\*      2      |       2 \\*/    f2: u16,"
     ""
-    "                           /\\* total size \\(bytes\\):    4 \\*/"
-    "                         }"
+    "                               /\\* total size \\(bytes\\):    4 \\*/"
+    "                             }"
 }
 
 gdb_test "print nonzero_offset" " = simple::EnumWithNonzeroOffset {a: core::option::Option<u8>::Some\\(1\\), b: core::option::Option<u8>::None}"
diff --git a/gdb/testsuite/gdb.rust/union.exp b/gdb/testsuite/gdb.rust/union.exp
index 3a2e6bc..ce59a36 100644
--- a/gdb/testsuite/gdb.rust/union.exp
+++ b/gdb/testsuite/gdb.rust/union.exp
@@ -34,12 +34,12 @@ if {![runto ${srcfile}:$line]} {
 gdb_test "print u" " = union::Union {f1: -1, f2: 255}"
 
 gdb_test_sequence "ptype/o Union" "" {
-    "/\\* offset    |  size \\*/  type = union union::Union {"
-    "/\\*                 1 \\*/    f1: i8,"
-    "/\\*                 1 \\*/    f2: u8,"
+    "/\\* offset      |    size \\*/  type = union union::Union {"
+    "/\\*                     1 \\*/    f1: i8,"
+    "/\\*                     1 \\*/    f2: u8,"
     ""
-    "                           /\\* total size \\(bytes\\):    1 \\*/"
-    "                         }"
+    "                               /\\* total size \\(bytes\\):    1 \\*/"
+    "                             }"
 }
 
 gdb_test "print u2" " = union::Union2 {name: \\\[1\\\]}"