[deliverable/binutils-gdb.git] / gdb / testsuite / gdb.base / ptype-offsets.exp

# This testcase is part of GDB, the GNU debugger.

# Copyright 2017-2018 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 <http://www.gnu.org/licenses/>.

# This testcase exercises the "ptype /o" feature, which can be used to
# print the offsets and sizes of each field of a struct/union/class.

standard_testfile .cc

# Test only works on LP64 targets.  That's how we guarantee that the
# expected holes will be present in the struct.
if { ![is_lp64_target] } {
    untested "test work only on lp64 targets"
    return 0
}

if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
	  { debug c++ }] } {
    return -1
}

# Test general offset printing, ctor/dtor printing, union, formatting.
gdb_test "ptype /o struct abc" \
    [multi_line \
{/\* offset    |  size \*/  type = struct abc \{} \
{                         public:} \
{/\*    8      |     8 \*/    void \*field1;} \
{/\*   16:31   |     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      |     4 \*/    my_int_type field9;} \
{} \
{                           /\* total size \(bytes\):   56 \*/} \
{                         \}}]

# Test "ptype /oTM".
gdb_test "ptype /oTM struct abc" \
    [multi_line \
{/\* offset    |  size \*/  type = struct abc \{} \
{                         public:} \
{/\*    8      |     8 \*/    void \*field1;} \
{/\*   16:31   |     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      |     4 \*/    my_int_type field9;} \
{} \
{                           abc\(void\);} \
{                           ~abc\(\);} \
{} \
{                           typedef int my_int_type;} \
{} \
{                           /\* total size \(bytes\):   56 \*/} \
{                         \}}]

# Test "ptype /TMo".  This should be the same as "ptype /o".
gdb_test "ptype /TMo struct abc" \
    [multi_line \
{/\* offset    |  size \*/  type = struct abc \{} \
{                         public:} \
{/\*    8      |     8 \*/    void \*field1;} \
{/\*   16:31   |     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      |     4 \*/    my_int_type field9;} \
{} \
{                           /\* total size \(bytes\):   56 \*/} \
{                         \}}]

# Test nested structs.
gdb_test "ptype /o struct pqr" \
    [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;} \
{} \
{                                   /\* total size \(bytes\):   24 \*/} \
{                               \} f4;} \
{} \
{                               /\* total size \(bytes\):   40 \*/} \
{                           \} ff2;} \
{/\* XXX 28-byte hole  \*/} \
{/\*   72      |     1 \*/    signed char ff3;} \
{} \
{                           /\* 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" \
    [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;} \
{} \
{                               /\* 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;} \
{} \
{                                   /\* total size \(bytes\):   24 \*/} \
{                               \} f4;} \
{} \
{                               /\* total size \(bytes\):   40 \*/} \
{                           \} fff2;} \
{} \
{                           /\* total size \(bytes\):   40 \*/} \
{                         \}}]

# Test printing a struct that contains a union, and that also
# contains a struct.
gdb_test "ptype /o struct poi" \
    [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;} \
{} \
{                                   /\* 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;} \
{} \
{                                       /\* total size \(bytes\):   24 \*/} \
{                                   \} f4;} \
{} \
{                                   /\* total size \(bytes\):   40 \*/} \
{                               \} fff2;} \
{} \
{                               /\* total size \(bytes\):   40 \*/} \
{                           \} f2;} \
{/\*   72      |     2 \*/    uint16_t f3;} \
{/\* XXX  6-byte hole  \*/} \
{/\*   80      |    56 \*/    struct pqr \{} \
{/\*   80      |     4 \*/        int ff1;} \
{/\* XXX  4-byte hole  \*/} \
{/\*   88      |    40 \*/        struct xyz \{} \
{/\*   88      |     4 \*/            int f1;} \
{/\*   92      |     1 \*/            signed char f2;} \
{/\* XXX  3-byte hole  \*/} \
{/\*   96      |     8 \*/            void \*f3;} \
{/\*  104      |    24 \*/            struct tuv \{} \
{/\*  104      |     4 \*/                int a1;} \
{/\* XXX  4-byte hole  \*/} \
{/\*  112      |     8 \*/                signed char \*a2;} \
{/\*  120      |     4 \*/                int a3;} \
{} \
{                                       /\* total size \(bytes\):   24 \*/} \
{                                   \} f4;} \
{} \
{                                   /\* total size \(bytes\):   40 \*/} \
{                               \} ff2;} \
{/\*  152      |     1 \*/        signed char ff3;} \
{} \
{                               /\* total size \(bytes\):   56 \*/} \
{                           \} f4;} \
{} \
{                           /\* total size \(bytes\):  112 \*/} \
{                         \}}]

# Test printing a struct with several bitfields, laid out in various
# ways.
#
# Because dealing with bitfields and offsets is difficult, it can be
# tricky to confirm that the output of this command is accurate.  A
# nice way to do that is to use GDB's "x" command and print the actual
# memory layout of the struct.  In order to differentiate between
# bitfields and non-bitfield variables, one can assign "-1" to every
# bitfield in the struct.  An example of the output of "x" using
# "struct tyu" is:
#
#   (gdb) x/24xb &e
#   0x7fffffffd540: 0xff    0xff    0xff    0x1f    0x00    0x00    0x00    0x00
#   0x7fffffffd548: 0xff    0xff    0xff    0xff    0xff    0xff    0xff    0xff
#   0x7fffffffd550: 0xff    0x00    0x00    0x00    0x00    0x00    0x00    0x00
gdb_test "ptype /o struct tyu" \
    [multi_line \
{/\* offset    |  size \*/  type = struct tyu \{} \
{/\*    0:31   |     4 \*/    int a1 : 1;} \
{/\*    0:28   |     4 \*/    int a2 : 3;} \
{/\*    0: 5   |     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:27   |     4 \*/    int a6 : 5;} \
{/\*   16:56   |     8 \*/    int64_t a7 : 3;} \
{} \
{                           /\* total size \(bytes\):   24 \*/} \
{                         \}}]

gdb_test "ptype /o struct asd" \
    [multi_line \
{/\* 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 \*/} \
{                               \} f3;} \
{/\*   24:27   |     4 \*/        int f4 : 5;} \
{/\*   24:26   |     4 \*/        unsigned int f5 : 1;} \
{/\* XXX  2-bit hole   \*/} \
{/\* XXX  1-byte hole  \*/} \
{/\*   26      |     2 \*/        short f6;} \
{} \
{                               /\* total size \(bytes\):   32 \*/} \
{                           \} f7;} \
{/\*   32      |     8 \*/    unsigned long f8;} \
{/\*   40      |     8 \*/    signed char \*f9;} \
{/\*   48:28   |     4 \*/    int f10 : 4;} \
{/\*   48:27   |     4 \*/    unsigned int f11 : 1;} \
{/\*   48:26   |     4 \*/    unsigned int f12 : 1;} \
{/\*   48:25   |     4 \*/    unsigned int f13 : 1;} \
{/\*   48:24   |     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.
gdb_test "ptype /o int" "int"
gdb_test "ptype /o uint8_t" "char"

# Test that the "whatis" command doesn't print anything related to the
# "offsets" feature, even when receiving the "/o" parameter.
set test "whatis /o asd"
gdb_test_multiple "$test" "$test" {
   -re "^$test\r\ntype = asd\r\n$gdb_prompt $" {
       pass $test
   }
}
Commit	Line	Data
7c161838 SDJ	1	# This testcase is part of GDB, the GNU debugger.
7c161838 SDJ	2
e2882c85	3	# Copyright 2017-2018 Free Software Foundation, Inc.
7c161838 SDJ	4
	5	# This program is free software; you can redistribute it and/or modify
	6	# it under the terms of the GNU General Public License as published by
	7	# the Free Software Foundation; either version 3 of the License, or
	8	# (at your option) any later version.
	9	#
	10	# This program is distributed in the hope that it will be useful,
	11	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	# GNU General Public License for more details.
	14	#
	15	# You should have received a copy of the GNU General Public License
	16	# along with this program. If not, see <http://www.gnu.org/licenses/>.
	17
	18	# This testcase exercises the "ptype /o" feature, which can be used to
	19	# print the offsets and sizes of each field of a struct/union/class.
	20
	21	standard_testfile .cc
	22
	23	# Test only works on LP64 targets. That's how we guarantee that the
	24	# expected holes will be present in the struct.
	25	if { ![is_lp64_target] } {
	26	untested "test work only on lp64 targets"
	27	return 0
	28	}
	29
	30	if { [prepare_for_testing "failed to prepare" $testfile $srcfile \
	31	{ debug c++ }] } {
	32	return -1
	33	}
	34
	35	# Test general offset printing, ctor/dtor printing, union, formatting.
	36	gdb_test "ptype /o struct abc" \
	37	[multi_line \
	38	{/\* offset \| size \*/ type = struct abc \{} \
	39	{ public:} \
	40	{/\* 8 \| 8 \/ void \field1;} \
	41	{/\* 16:31 \| 4 \*/ unsigned int field2 : 1;} \
	42	{/\* XXX 7-bit hole \*/} \
	43	{/\* XXX 3-byte hole \*/} \
	44	{/\* 20 \| 4 \*/ int field3;} \
	45	{/\* 24 \| 1 \*/ signed char field4;} \
	46	{/\* XXX 7-byte hole \*/} \
	47	{/\* 32 \| 8 \*/ uint64_t field5;} \
	48	{/\* 40 \| 8 \*/ union \{} \
	49	{/\* 8 \/ void \field6;} \
	50	{/\* 4 \*/ int field7;} \
	51	{} \
	52	{ /\* total size \(bytes\): 8 \*/} \
	53	{ \} field8;} \
	54	{/\* 48 \| 4 \*/ my_int_type field9;} \
	55	{} \
	56	{ /\* total size \(bytes\): 56 \*/} \
	57	{ \}}]
	58
	59	# Test "ptype /oTM".
	60	gdb_test "ptype /oTM struct abc" \
	61	[multi_line \
	62	{/\* offset \| size \*/ type = struct abc \{} \
	63	{ public:} \
	64	{/\* 8 \| 8 \/ void \field1;} \
	65	{/\* 16:31 \| 4 \*/ unsigned int field2 : 1;} \
	66	{/\* XXX 7-bit hole \*/} \
	67	{/\* XXX 3-byte hole \*/} \
68	{/\* 20 \| 4 \*/ int field3;} \
69	{/\* 24 \| 1 \*/ signed char field4;} \
70	{/\* XXX 7-byte hole \*/} \
71	{/\* 32 \| 8 \*/ uint64_t field5;} \
72	{/\* 40 \| 8 \*/ union \{} \
73	{/\* 8 \/ void \field6;} \
74	{/\* 4 \*/ int field7;} \
75	{} \
76	{ /\* total size \(bytes\): 8 \*/} \
77	{ \} field8;} \
78	{/\* 48 \| 4 \*/ my_int_type field9;} \
79	{} \
80	{ abc\(void\);} \
81	{ ~abc\(\);} \
82	{} \
83	{ typedef int my_int_type;} \
84	{} \
85	{ /\* total size \(bytes\): 56 \*/} \
86	{ \}}]
87
88	# Test "ptype /TMo". This should be the same as "ptype /o".
89	gdb_test "ptype /TMo struct abc" \
90	[multi_line \
91	{/\* offset \| size \*/ type = struct abc \{} \
92	{ public:} \
93	{/\* 8 \| 8 \/ void \field1;} \
94	{/\* 16:31 \| 4 \*/ unsigned int field2 : 1;} \
95	{/\* XXX 7-bit hole \*/} \
96	{/\* XXX 3-byte hole \*/} \
97	{/\* 20 \| 4 \*/ int field3;} \
98	{/\* 24 \| 1 \*/ signed char field4;} \
99	{/\* XXX 7-byte hole \*/} \
100	{/\* 32 \| 8 \*/ uint64_t field5;} \
101	{/\* 40 \| 8 \*/ union \{} \
102	{/\* 8 \/ void \field6;} \
103	{/\* 4 \*/ int field7;} \
104	{} \
105	{ /\* total size \(bytes\): 8 \*/} \
106	{ \} field8;} \
107	{/\* 48 \| 4 \*/ my_int_type field9;} \
108	{} \
109	{ /\* total size \(bytes\): 56 \*/} \
110	{ \}}]
111
112	# Test nested structs.
113	gdb_test "ptype /o struct pqr" \
114	[multi_line \
115	{/\* offset \| size \*/ type = struct pqr \{} \
116	{/\* 0 \| 4 \*/ int ff1;} \
117	{/\* XXX 4-byte hole \*/} \
118	{/\* 8 \| 40 \*/ struct xyz \{} \
119	{/\* 8 \| 4 \*/ int f1;} \
120	{/\* 12 \| 1 \*/ signed char f2;} \
121	{/\* XXX 3-byte hole \*/} \
122	{/\* 16 \| 8 \/ void \f3;} \
123	{/\* 24 \| 24 \*/ struct tuv \{} \
124	{/\* 24 \| 4 \*/ int a1;} \
125	{/\* XXX 4-byte hole \*/} \
126	{/\* 32 \| 8 \/ signed char \a2;} \
127	{/\* 40 \| 4 \*/ int a3;} \
128	{} \
129	{ /\* total size \(bytes\): 24 \*/} \
130	{ \} f4;} \
131	{} \
132	{ /\* total size \(bytes\): 40 \*/} \
133	{ \} ff2;} \
134	{/\* XXX 28-byte hole \*/} \
135	{/\* 72 \| 1 \*/ signed char ff3;} \
136	{} \
137	{ /\* total size \(bytes\): 56 \*/} \
138	{ \}}]
139
140	# Test that the offset is properly reset when we are printing a union
141	# and go inside two inner structs.
142	# This also tests a struct inside a struct inside a union.
143	gdb_test "ptype /o union qwe" \
144	[multi_line \
145	{/\* offset \| size \*/ type = union qwe \{} \
146	{/\* 24 \*/ struct tuv \{} \
147	{/\* 0 \| 4 \*/ int a1;} \
148	{/\* XXX 4-byte hole \*/} \
149	{/\* 8 \| 8 \/ signed char \a2;} \
150	{/\* 16 \| 4 \*/ int a3;} \
151	{} \
152	{ /\* total size \(bytes\): 24 \*/} \
153	{ \} fff1;} \
154	{/\* 40 \*/ struct xyz \{} \
155	{/\* 0 \| 4 \*/ int f1;} \
156	{/\* 4 \| 1 \*/ signed char f2;} \
157	{/\* XXX 3-byte hole \*/} \
158	{/\* 8 \| 8 \/ void \f3;} \
159	{/\* 16 \| 24 \*/ struct tuv \{} \
160	{/\* 16 \| 4 \*/ int a1;} \
161	{/\* XXX 4-byte hole \*/} \
162	{/\* 24 \| 8 \/ signed char \a2;} \
163	{/\* 32 \| 4 \*/ int a3;} \
164	{} \
165	{ /\* total size \(bytes\): 24 \*/} \
166	{ \} f4;} \
167	{} \
168	{ /\* total size \(bytes\): 40 \*/} \
169	{ \} fff2;} \
170	{} \
171	{ /\* total size \(bytes\): 40 \*/} \
172	{ \}}]
173
174	# Test printing a struct that contains a union, and that also
175	# contains a struct.
176	gdb_test "ptype /o struct poi" \
177	[multi_line \
178	{/\* offset \| size \*/ type = struct poi \{} \
179	{/\* 0 \| 4 \*/ int f1;} \
180	{/\* XXX 4-byte hole \*/} \
181	{/\* 8 \| 40 \*/ union qwe \{} \
182	{/\* 24 \*/ struct tuv \{} \
183	{/\* 8 \| 4 \*/ int a1;} \
184	{/\* XXX 4-byte hole \*/} \
185	{/\* 16 \| 8 \/ signed char \a2;} \
186	{/\* 24 \| 4 \*/ int a3;} \
187	{} \
188	{ /\* total size \(bytes\): 24 \*/} \
189	{ \} fff1;} \
190	{/\* 40 \*/ struct xyz \{} \
191	{/\* 8 \| 4 \*/ int f1;} \
192	{/\* 12 \| 1 \*/ signed char f2;} \
193	{/\* XXX 3-byte hole \*/} \
194	{/\* 16 \| 8 \/ void \f3;} \
195	{/\* 24 \| 24 \*/ struct tuv \{} \
196	{/\* 24 \| 4 \*/ int a1;} \
197	{/\* XXX 4-byte hole \*/} \
198	{/\* 32 \| 8 \/ signed char \a2;} \
199	{/\* 40 \| 4 \*/ int a3;} \
200	{} \
201	{ /\* total size \(bytes\): 24 \*/} \
202	{ \} f4;} \
203	{} \
204	{ /\* total size \(bytes\): 40 \*/} \
205	{ \} fff2;} \
206	{} \
207	{ /\* total size \(bytes\): 40 \*/} \
208	{ \} f2;} \
209	{/\* 72 \| 2 \*/ uint16_t f3;} \
210	{/\* XXX 6-byte hole \*/} \
211	{/\* 80 \| 56 \*/ struct pqr \{} \
212	{/\* 80 \| 4 \*/ int ff1;} \
213	{/\* XXX 4-byte hole \*/} \
214	{/\* 88 \| 40 \*/ struct xyz \{} \
215	{/\* 88 \| 4 \*/ int f1;} \
216	{/\* 92 \| 1 \*/ signed char f2;} \
217	{/\* XXX 3-byte hole \*/} \
218	{/\* 96 \| 8 \/ void \f3;} \
219	{/\* 104 \| 24 \*/ struct tuv \{} \
220	{/\* 104 \| 4 \*/ int a1;} \
221	{/\* XXX 4-byte hole \*/} \
222	{/\* 112 \| 8 \/ signed char \a2;} \
223	{/\* 120 \| 4 \*/ int a3;} \
224	{} \
225	{ /\* total size \(bytes\): 24 \*/} \
226	{ \} f4;} \
227	{} \
228	{ /\* total size \(bytes\): 40 \*/} \
229	{ \} ff2;} \
230	{/\* 152 \| 1 \*/ signed char ff3;} \
231	{} \
232	{ /\* total size \(bytes\): 56 \*/} \
233	{ \} f4;} \
234	{} \
235	{ /\* total size \(bytes\): 112 \*/} \
236	{ \}}]
237
238	# Test printing a struct with several bitfields, laid out in various
239	# ways.
240	#
241	# Because dealing with bitfields and offsets is difficult, it can be
242	# tricky to confirm that the output of this command is accurate. A
243	# nice way to do that is to use GDB's "x" command and print the actual
244	# memory layout of the struct. In order to differentiate between
245	# bitfields and non-bitfield variables, one can assign "-1" to every
246	# bitfield in the struct. An example of the output of "x" using
247	# "struct tyu" is:
248	#
249	# (gdb) x/24xb &e
250	# 0x7fffffffd540: 0xff 0xff 0xff 0x1f 0x00 0x00 0x00 0x00
251	# 0x7fffffffd548: 0xff 0xff 0xff 0xff 0xff 0xff 0xff 0xff
252	# 0x7fffffffd550: 0xff 0x00 0x00 0x00 0x00 0x00 0x00 0x00
253	gdb_test "ptype /o struct tyu" \
254	[multi_line \
255	{/\* offset \| size \*/ type = struct tyu \{} \
256	{/\* 0:31 \| 4 \*/ int a1 : 1;} \
257	{/\* 0:28 \| 4 \*/ int a2 : 3;} \
258	{/\* 0: 5 \| 4 \*/ int a3 : 23;} \
259	{/\* 3: 3 \| 1 \*/ signed char a4 : 2;} \
260	{/\* XXX 3-bit hole \*/} \
261	{/\* XXX 4-byte hole \*/} \
262	{/\* 8 \| 8 \*/ int64_t a5;} \
263	{/\* 16:27 \| 4 \*/ int a6 : 5;} \
264	{/\* 16:56 \| 8 \*/ int64_t a7 : 3;} \
265	{} \
266	{ /\* total size \(bytes\): 24 \*/} \
267	{ \}}]
268
269	gdb_test "ptype /o struct asd" \
270	[multi_line \
271	{/\* offset \| size \*/ type = struct asd \{} \
272	{/\* 0 \| 32 \*/ struct asd::jkl \{} \
273	{/\* 0 \| 8 \/ signed char \f1;} \
274	{/\* 8 \| 8 \*/ union \{} \
275	{/\* 8 \/ void \ff1;} \
276	{} \
277	{ /\* total size \(bytes\): 8 \*/} \
278	{ \} f2;} \
279	{/\* 16 \| 8 \*/ union \{} \
280	{/\* 8 \/ signed char \ff2;} \
281	{} \
282	{ /\* total size \(bytes\): 8 \*/} \
283	{ \} f3;} \
284	{/\* 24:27 \| 4 \*/ int f4 : 5;} \
285	{/\* 24:26 \| 4 \*/ unsigned int f5 : 1;} \
286	{/\* XXX 2-bit hole \*/} \
287	{/\* XXX 1-byte hole \*/} \
288	{/\* 26 \| 2 \*/ short f6;} \
289	{} \
290	{ /\* total size \(bytes\): 32 \*/} \
291	{ \} f7;} \
292	{/\* 32 \| 8 \*/ unsigned long f8;} \
293	{/\* 40 \| 8 \/ signed char \f9;} \
294	{/\* 48:28 \| 4 \*/ int f10 : 4;} \
295	{/\* 48:27 \| 4 \*/ unsigned int f11 : 1;} \
296	{/\* 48:26 \| 4 \*/ unsigned int f12 : 1;} \
297	{/\* 48:25 \| 4 \*/ unsigned int f13 : 1;} \
298	{/\* 48:24 \| 4 \*/ unsigned int f14 : 1;} \
299	{/\* XXX 7-byte hole \*/} \
300	{/\* 56 \| 8 \/ void \f15;} \
301	{/\* 64 \| 8 \/ void \f16;} \
302	{} \
303	{ /\* total size \(bytes\): 72 \*/} \
304	{ \}}]
305
306	# Test that we don't print any header when issuing a "ptype /o" on a
307	# non-struct, non-union, non-class type.
308	gdb_test "ptype /o int" "int"
309	gdb_test "ptype /o uint8_t" "char"
310
311	# Test that the "whatis" command doesn't print anything related to the
312	# "offsets" feature, even when receiving the "/o" parameter.
313	set test "whatis /o asd"
314	gdb_test_multiple "$test" "$test" {
315	-re "^$test\r\ntype = asd\r\n$gdb_prompt $" {
316	pass $test
317	}
318	}