OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.0/] [gdb/] [testsuite/] [gdb.c++/] [classes.exp] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom
# Copyright (C) 1992, 1994, 1995, 1997, 1999 Free Software Foundation, Inc.
2
 
3
# This program is free software; you can redistribute it and/or modify
4
# it under the terms of the GNU General Public License as published by
5
# the Free Software Foundation; either version 2 of the License, or
6
# (at your option) any later version.
7
#
8
# This program is distributed in the hope that it will be useful,
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
11
# GNU General Public License for more details.
12
#
13
# You should have received a copy of the GNU General Public License
14
# along with this program; if not, write to the Free Software
15
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
16
 
17
# Please email any bugs, comments, and/or additions to this file to:
18
# bug-gdb@prep.ai.mit.edu
19
 
20
# This file was written by Fred Fish. (fnf@cygnus.com)
21
 
22
set ws "\[\r\n\t \]+"
23
set nl "\[\r\n\]+"
24
 
25
if $tracelevel then {
26
        strace $tracelevel
27
}
28
 
29
if { [skip_cplus_tests] } { continue }
30
 
31
set testfile "misc"
32
set srcfile ${testfile}.cc
33
set binfile ${objdir}/${subdir}/${testfile}
34
 
35
# Create and source the file that provides information about the compiler
36
# used to compile the test case.
37
 
38
if [get_compiler_info ${binfile} "c++"] {
39
    return -1
40
}
41
 
42
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
43
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
44
}
45
 
46
#
47
# Test ptype of class objects.
48
#
49
 
50
proc test_ptype_class_objects {} {
51
    global gdb_prompt
52
    global ws
53
    global nl
54
 
55
    # Note that struct members are public by default, so we don't print
56
    # "public:" for the public members of structs.
57
    # Accept it as an expected failure if gdb just fails to distinguish between
58
    # class and struct, and everything else is OK.
59
 
60
    send_gdb "ptype struct default_public_struct\n"
61
    gdb_expect {
62
        -re "type = struct default_public_struct \{${ws}int a;${ws}int b;$nl\}$nl$gdb_prompt $" {
63
            pass "ptype struct default_public_struct"
64
        }
65
        -re "type = class default_public_struct \{$nl.*int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
66
            setup_xfail "*-*-*"
67
            fail "ptype struct default_public_struct"
68
        }
69
        -re ".*$gdb_prompt $" { fail "ptype struct default_public_struct" }
70
        timeout { fail "ptype struct default_public_struct (timeout)" ; return }
71
    }
72
 
73
    # Note that struct members are public by default, so we don't print
74
    # "public:" for the public members of structs.
75
    # Accept it as an expected failure if gdb just fails to distinguish between
76
    # class and struct, and everything else is OK.
77
 
78
    send_gdb "ptype struct explicit_public_struct\n"
79
    gdb_expect {
80
        -re "type = struct explicit_public_struct \{${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
81
            pass "ptype struct explicit_public_struct"
82
        }
83
        -re "type = class explicit_public_struct \{$nl.*int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
84
            setup_xfail "*-*-*"
85
            fail "ptype struct explicit_public_struct"
86
        }
87
        -re ".*$gdb_prompt $" { fail "ptype struct explicit_public_struct" }
88
        timeout { fail "ptype struct explicit_public_struct (timeout)" ; return }
89
    }
90
 
91
    # Accept it as an expected failure if gdb just fails to distinguish between
92
    # class and struct, and everything else is OK.
93
 
94
    setup_xfail_format "DWARF 1"
95
    send_gdb "ptype struct protected_struct\n"
96
    gdb_expect {
97
        -re "type = struct protected_struct \{${ws}protected:${ws}int a;${ws}int b;$nl\}$nl$gdb_prompt $" {
98
            pass "ptype struct protected_struct (FIXME)"
99
        }
100
        -re "type = class protected_struct \{${ws}protected:${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
101
            setup_xfail "*-*-*"
102
            fail "ptype struct protected_struct (FIXME)"
103
        }
104
        -re ".*$gdb_prompt $" { fail "ptype struct protected_struct" }
105
        timeout { fail "ptype struct protected_struct (timeout)" ; return }
106
    }
107
 
108
    # Accept it as an expected failure if gdb just fails to distinguish between
109
    # class and struct, and everything else is OK.
110
 
111
    setup_xfail_format "DWARF 1"
112
    send_gdb "ptype struct private_struct\n"
113
    gdb_expect {
114
        -re "type = struct private_struct \{${ws}private:${ws}int a;${ws}int b;$nl\}$nl$gdb_prompt $" {
115
            pass "ptype struct private_struct (FIXME)"
116
        }
117
        -re "type = class private_struct \{${ws}private:${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
118
            setup_xfail "*-*-*"
119
            fail "ptype struct private_struct (FIXME)"
120
        }
121
        -re ".*$gdb_prompt $" { fail "ptype struct private_struct" }
122
        timeout { fail "ptype struct private_struct (timeout)" ; return }
123
    }
124
 
125
    # Accept it as an expected failure if gdb just fails to distinguish between
126
    # class and struct, and everything else is OK.
127
 
128
    setup_xfail_format "DWARF 1"
129
    send_gdb "ptype struct mixed_protection_struct\n"
130
    gdb_expect {
131
        -re "type = struct mixed_protection_struct \{${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;$nl\}$nl$gdb_prompt $" {
132
            pass "ptype struct mixed_protection_struct (FIXME)"
133
        }
134
        -re "type = struct mixed_protection_struct \{${ws}public:${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;$nl.*\}$nl$gdb_prompt $" {
135
            pass "ptype struct mixed_protection_struct (extra public)"
136
        }
137
        -re "type = class mixed_protection_struct \{${ws}public:${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;$nl.*\}$nl$gdb_prompt $" {
138
            setup_xfail "*-*-*"
139
            fail "ptype struct mixed_protection_struct (FIXME)"
140
        }
141
        -re ".*$gdb_prompt $" { fail "ptype struct mixed_protection_struct" }
142
        timeout { fail "ptype struct mixed_protection_struct (timeout)" ; return }
143
    }
144
 
145
    # Accept it as an expected failure if gdb just fails to distinguish between
146
    # class and struct, and everything else is OK.
147
 
148
    send_gdb "ptype class public_class\n"
149
    gdb_expect {
150
        -re "type = class public_class \{${ws}public:${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
151
            pass "ptype class public_class (FIXME)"
152
        }
153
        -re "type = struct public_class \{${ws}int a;${ws}int b;$nl\}$nl$gdb_prompt $" {
154
            setup_xfail "*-*-*"
155
            fail "ptype class public_class (FIXME)"
156
        }
157
        -re ".*$gdb_prompt $" { fail "ptype class public_class" }
158
        timeout { fail "ptype class public_class (timeout)" ; return }
159
    }
160
 
161
    send_gdb "ptype class protected_class\n"
162
    gdb_expect {
163
        -re "type = class protected_class \{${ws}protected:${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
164
            pass "ptype class protected_class"
165
        }
166
        -re "type = struct protected_class \{${ws}int a;${ws}int b;$nl\}$nl$gdb_prompt $" {
167
            setup_xfail "*-*-*"
168
            fail "ptype class protected_class"
169
        }
170
        -re ".*$gdb_prompt $" { fail "ptype class protected_class" }
171
        timeout { fail "ptype class protected_class (timeout)" ; return }
172
    }
173
 
174
    # Accept it as an expected failure if gdb just emits a superflous "private:"
175
    # attribute, since classes default to private and for consistency with
176
    # structs (where we don't print the "public:" attribute) we don't print
177
    # the "private:" attribute.
178
 
179
    setup_xfail_format "DWARF 1"
180
    send_gdb "ptype class default_private_class\n"
181
    gdb_expect {
182
        -re "type = class default_private_class \{${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
183
            pass "ptype class default_private_class (FIXME)"
184
        }
185
        -re "type = class default_private_class \{${ws}private:${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
186
            setup_xfail "*-*-*"
187
            fail "ptype class default_private_class (FIXME)"
188
        }
189
        -re ".*$gdb_prompt $" { fail "ptype class default_private_class" }
190
        timeout { fail "ptype class default_private_class (timeout)" ; return }
191
    }
192
 
193
    send_gdb "ptype class explicit_private_class\n"
194
    gdb_expect {
195
        -re "type = class explicit_private_class \{${ws}private:${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
196
            pass "ptype class explicit_private_class"
197
        }
198
        -re "type = class explicit_private_class \{${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
199
            pass "ptype class explicit_private_class (OK for HP aCC)"
200
        }
201
        -re "type = struct explicit_private_class \{${ws}int a;${ws}int b;$nl.*\}$nl$gdb_prompt $" {
202
            setup_xfail "*-*-*"
203
            fail "ptype class explicit_private_class"
204
        }
205
        -re ".*$gdb_prompt $" { fail "ptype class explicit_private_class" }
206
        timeout { fail "ptype class explicit_private_class (timeout)" ; return }
207
    }
208
 
209
    send_gdb "ptype class mixed_protection_class\n"
210
    gdb_expect {
211
        -re "type = class mixed_protection_class \{${ws}public:${ws}int a;${ws}int b;${ws}private:${ws}int c;${ws}int d;${ws}protected:${ws}int e;${ws}int f;${ws}public:${ws}int g;${ws}private:${ws}int h;${ws}protected:${ws}int i;$nl.*\}$nl$gdb_prompt $" {
212
            pass "ptype class mixed_protection_class"
213
        }
214
        -re "type = struct mixed_protection_class \{${ws}int a;${ws}int b;${ws}int c;${ws}int d;${ws}int e;${ws}int f;${ws}int g;${ws}int h;${ws}int i;$nl.*\}$nl$gdb_prompt $" {
215
            setup_xfail "*-*-*"
216
            fail "ptype class mixed_protection_class"
217
        }
218
        -re ".*$gdb_prompt $" { fail "ptype class mixed_protection_class" }
219
        timeout { fail "ptype class mixed_protection_class (timeout)" ; return }
220
    }
221
 
222
    # This class does not use any C++-specific features, so it's fine for
223
    # it to print as "struct".
224
    send_gdb "ptype class A\n"
225
    gdb_expect {
226
        -re "type = (class|struct) A \{(${ws}public:|)${ws}int a;${ws}int x;((${ws}A & operator=\\(A const &\\);)|(${ws}A\\(A const &\\);)|(${ws}A\\(void\\);))*${ws}\}$nl$gdb_prompt $" {
227
            pass "ptype class A"
228
        }
229
        -re ".*$gdb_prompt $" {
230
            fail "ptype class A"
231
        }
232
        timeout {
233
            fail "ptype class A (timeout)"
234
            return
235
        }
236
    }
237
 
238
    setup_xfail_format "DWARF 1"
239
    send_gdb "ptype class B\n"
240
    gdb_expect {
241
        -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;${ws}B & operator=\\(B const &\\);${ws}B\\(B const &\\);${ws}B\\(void\\);${ws}\}$nl$gdb_prompt $" {
242
            pass "ptype class B"
243
        }
244
        -re "type = class B : public A \{${ws}public:${ws}int b;${ws}int x;((${ws}B & operator=\\(B const &\\);)|(${ws}B\\(B const &\\);)|(${ws}B\\(void\\);))*${ws}\}$nl$gdb_prompt $" {
245
            pass "ptype class B (obsolescent gcc or gdb)"
246
        }
247
        -re ".*$gdb_prompt $" {
248
            fail "ptype class B"
249
        }
250
        timeout {
251
            fail "ptype class B (timeout)"
252
            return
253
        }
254
    }
255
 
256
    setup_xfail_format "DWARF 1"
257
    send_gdb "ptype class C\n"
258
    gdb_expect {
259
        -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;${ws}C & operator=\\(C const &\\);${ws}C\\(C const &\\);${ws}C\\(void\\);${ws}\}$nl$gdb_prompt $" {
260
            pass "ptype class C"
261
        }
262
        -re "type = class C : public A \{${ws}public:${ws}int c;${ws}int x;((${ws}C & operator=\\(C const &\\);)|(${ws}C\\(C const &\\);)|(${ws}C\\(void\\);))*${ws}\}$nl$gdb_prompt $" {
263
            pass "ptype class C (obsolescent gcc or gdb)"
264
        }
265
        -re ".*$gdb_prompt $" {
266
            fail "ptype class C"
267
        }
268
        timeout {
269
            fail "ptype class C (timeout)"
270
            return
271
        }
272
    }
273
 
274
    setup_xfail_format "DWARF 1"
275
    send_gdb "ptype class D\n"
276
    gdb_expect {
277
        -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;${ws}D & operator=\\(D const &\\);${ws}D\\(D const &\\);${ws}D\\(void\\);${ws}\}$nl$gdb_prompt $" {
278
            pass "ptype class D"
279
        }
280
        -re "type = class D : public B, public C \{${ws}public:${ws}int d;${ws}int x;((${ws}D & operator=\\(D const &\\);)|(${ws}D\\(D const &\\);)|(${ws}D\\(void\\);))*${ws}\}$nl$gdb_prompt $" {
281
            pass "ptype class D (obsolescent gcc or gdb)"
282
        }
283
        -re ".*$gdb_prompt $" {
284
            fail "ptype class D"
285
        }
286
        timeout {
287
            fail "ptype class D (timeout)"
288
            return
289
        }
290
    }
291
 
292
    setup_xfail_format "DWARF 1"
293
    send_gdb "ptype class E\n"
294
    gdb_expect {
295
        -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;${ws}E & operator=\\(E const &\\);${ws}E\\(E const &\\);${ws}E\\(void\\);${ws}\}$nl$gdb_prompt $" {
296
            pass "ptype class E"
297
        }
298
        -re "type = class E : public D \{${ws}public:${ws}int e;${ws}int x;((${ws}E & operator=\\(E const &\\);)|(${ws}E\\(E const &\\);)|(${ws}E\\(void\\);))*${ws}\}$nl$gdb_prompt $" {
299
            pass "ptype class E"
300
        }
301
        -re ".*$gdb_prompt $" {
302
            fail "ptype class E"
303
        }
304
        timeout {
305
            fail "ptype class E (timeout)"
306
            return
307
        }
308
    }
309
 
310
    send_gdb "ptype class vA\n"
311
    gdb_expect {
312
        -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;${ws}vA & operator=\\(vA const &\\);${ws}vA\\(vA const &\\);${ws}vA\\(void\\);${ws}\}$nl$gdb_prompt $" {
313
            pass "ptype class vA"
314
        }
315
        -re "type = (class|struct) vA \{(${ws}public:|)${ws}int va;${ws}int vx;((${ws}vA & operator=\\(vA const &\\);)|(${ws}vA\\(vA const &\\);)|(${ws}vA\\(void\\);))*${ws}\}$nl$gdb_prompt $" {
316
            pass "ptype class vA (obsolescent gcc or gdb)"
317
        }
318
        -re ".*$gdb_prompt $" {
319
            fail "ptype class vA"
320
        }
321
        timeout {
322
            fail "ptype class vA (timeout)"
323
            return
324
        }
325
    }
326
 
327
    # Accept the form with embedded GNU style mangled virtual table constructs
328
    # for now, but with a FIXME.  At some future point, gdb should use a
329
    # portable representation for the virtual table constructs.
330
 
331
    # The format of a g++ virtual base pointer.
332
    set vbptr "(_vb\[$.\]|__vb_)\[0-9\]?"
333
 
334
    setup_xfail_format "DWARF 1"
335
    send_gdb "ptype class vB\n"
336
    gdb_expect {
337
        -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*${vbptr}vA;${ws}public:${ws}int vb;${ws}int vx;${ws}vB & operator=\\(vB const &\\);${ws}vB\\(int, vB const &\\);${ws}vB\\(int\\);${ws}\}$nl$gdb_prompt $" {
338
            setup_xfail "*-*-*"
339
            fail "ptype class vB (FIXME: non-portable virtual table constructs)"
340
        }
341
        -re "type = class vB : public virtual vA \{${ws}public:${ws}int vb;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
342
            pass "ptype class vB (aCC)"
343
        }
344
        -re "type = class vB : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vb;${ws}int vx;((${ws}vB & operator=\\(vB const &\\);)|(${ws}vB\\(int, vB const &\\);)|(${ws}vB\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
345
            setup_xfail "*-*-*"
346
            fail "ptype class vB (FIXME) (obsolescent gcc or gdb)"
347
        }
348
        -re ".*$gdb_prompt $" {
349
            fail "ptype class vB"
350
        }
351
        timeout {
352
            fail "ptype class vB (timeout)"
353
            return
354
        }
355
    }
356
 
357
    # Accept the form with embedded GNU style mangled virtual table constructs
358
    # for now, but with a FIXME.  At some future point, gdb should use a
359
    # portable representation for the virtual table constructs.
360
 
361
    setup_xfail_format "DWARF 1"
362
    send_gdb "ptype class vC\n"
363
    gdb_expect {
364
        -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*${vbptr}vA;${ws}public:${ws}int vc;${ws}int vx;${ws}vC & operator=\\(vC const &\\);${ws}vC\\(int, vC const &\\);${ws}vC\\(int\\);${ws}\}$nl$gdb_prompt $" {
365
            setup_xfail "*-*-*"
366
            fail "ptype class vC (FIXME: non-portable virtual table constructs)"
367
        }
368
        -re "type = class vC : public virtual vA \{${ws}public:${ws}int vc;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
369
            pass "ptype class vC (aCC)"
370
        }
371
        -re "type = class vC : public virtual vA \{${ws}private:${ws}vA \\*_vb.vA;${ws}public:${ws}int vc;${ws}int vx;((${ws}vC & operator=\\(vC const &\\);)|(${ws}vC\\(int, vC const &\\);)|(${ws}vC\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
372
            setup_xfail "*-*-*"
373
            fail "ptype class vC (FIXME) (obsolescent gcc or gdb)"
374
        }
375
        -re ".*$gdb_prompt $" {
376
            fail "ptype class vC"
377
        }
378
        timeout {
379
            fail "ptype class vC (timeout)"
380
            return
381
        }
382
    }
383
 
384
    # Accept the form with embedded GNU style mangled virtual table constructs
385
    # for now, but with a FIXME.  At some future point, gdb should use a
386
    # portable representation for the virtual table constructs.
387
 
388
    setup_xfail_format "DWARF 1"
389
    send_gdb "ptype class vD\n"
390
    gdb_expect {
391
        -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*${vbptr}vC;${ws}vB \\*${vbptr}vB;${ws}public:${ws}int vd;${ws}int vx;${ws}vD & operator=\\(vD const &\\);${ws}vD\\(int, vD const &\\);${ws}vD\\(int\\);${ws}\}$nl$gdb_prompt $" {
392
            setup_xfail "*-*-*"
393
            fail "ptype class vD (FIXME: non-portable virtual table constructs)"
394
        }
395
        -re "type = class vD : public virtual vB, public virtual vC \{${ws}public:${ws}int vd;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
396
            pass "ptype class vD (aCC)"
397
        }
398
        -re "type = class vD : public virtual vB, public virtual vC \{${ws}private:${ws}vC \\*_vb.vC;${ws}vB \\*_vb.vB;${ws}public:${ws}int vd;${ws}int vx;((${ws}vD & operator=\\(vD const &\\);)|(${ws}vD\\(int, vD const &\\);)|(${ws}vD\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
399
            setup_xfail "*-*-*"
400
            fail "ptype class vD (FIXME) (obsolescent gcc or gdb)"
401
        }
402
        -re ".*$gdb_prompt $" {
403
            fail "ptype class vD"
404
        }
405
        timeout {
406
            fail "ptype class vD (timeout)"
407
            return
408
        }
409
    }
410
 
411
    # Accept the form with embedded GNU style mangled virtual table constructs
412
    # for now, but with a FIXME.  At some future point, gdb should use a
413
    # portable representation for the virtual table constructs.
414
 
415
    setup_xfail_format "DWARF 1"
416
    send_gdb "ptype class vE\n"
417
    gdb_expect {
418
        -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*${vbptr}vD;${ws}public:${ws}int ve;${ws}int vx;${ws}vE & operator=\\(vE const &\\);${ws}vE\\(int, vE const &\\);${ws}vE\\(int\\);${ws}\}$nl$gdb_prompt $" {
419
            setup_xfail "*-*-*"
420
            fail "ptype class vE (FIXME: non-portable virtual table constructs)"
421
        }
422
        -re "type = class vE : public virtual vD \{${ws}public:${ws}int ve;${ws}int vx;${ws}\}$nl$gdb_prompt $" {
423
            pass "ptype class vE (aCC)"
424
        }
425
        -re "type = class vE : public virtual vD \{${ws}private:${ws}vD \\*_vb.vD;${ws}public:${ws}int ve;${ws}int vx;((${ws}vE & operator=\\(vE const &\\);)|(${ws}vE\\(int, vE const &\\);)|(${ws}vE\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
426
            setup_xfail "*-*-*"
427
            fail "ptype class vE (FIXME) (obsolescent gcc or gdb)"
428
        }
429
        -re ".*$gdb_prompt $" {
430
            fail "ptype class vE"
431
        }
432
        timeout {
433
            fail "ptype class vE (timeout)"
434
            return
435
        }
436
    }
437
 
438
    setup_xfail_format "DWARF 1"
439
    send_gdb "ptype class Base1\n"
440
    gdb_expect {
441
        -re "type = class Base1 \{${ws}public:${ws}int x;${ws}Base1 & operator=\\(Base1 const &\\);${ws}Base1\\(Base1 const &\\);${ws}Base1\\(int\\);${ws}\}$nl$gdb_prompt $" {
442
            pass "ptype class Base1"
443
        }
444
        -re "type = class Base1 \{${ws}public:${ws}int x;((${ws}Base1 & operator=\\(Base1 const &\\);)|(${ws}Base1\\(Base1 const &\\);)|(${ws}Base1\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
445
            pass "ptype class Base1 (obsolescent gcc or gdb)"
446
        }
447
        -re ".*$gdb_prompt $" {
448
            fail "ptype class Base1"
449
        }
450
        timeout {
451
            fail "ptype class Base1 (timeout)"
452
            return
453
        }
454
    }
455
 
456
    setup_xfail_format "DWARF 1"
457
    send_gdb "ptype class Foo\n"
458
    gdb_expect {
459
        -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;\r\n${ws}Foo\\(int, int\\);${ws}int operator!.void.;${ws}operator int.void.;${ws}int times.int.;$nl\}$nl$gdb_prompt $" {
460
            pass "ptype class Foo(aCC)"
461
        }
462
        -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;${ws}Foo & operator=\\(Foo const &\\);${ws}Foo\\(Foo const &\\);${ws}Foo\\(int, int\\);${ws}int operator!\\(void\\);${ws}operator int\\(void\\);${ws}int times\\(int\\);${ws}\}$nl$gdb_prompt $" {
463
            pass "ptype class Foo"
464
        }
465
        -re "type = class Foo \{${ws}public:${ws}int x;${ws}int y;${ws}static int st;((${ws}Foo & operator=\\(Foo const &\\);)|(${ws}Foo\\(Foo const &\\);)|(${ws}Foo\\(int, int\\);)|(${ws}int operator!\\(void\\);)|(${ws}int operator int\\(void\\);)|(${ws}int times\\(int\\);))*${ws}\}$nl$gdb_prompt $" {
466
            pass "ptype class Foo (obsolescent gcc or gdb)"
467
        }
468
        -re ".*$gdb_prompt $" {
469
            fail "ptype class Foo"
470
        }
471
        timeout {
472
            fail "ptype class Foo (timeout)"
473
            return
474
        }
475
    }
476
 
477
    setup_xfail_format "DWARF 1"
478
    send_gdb "ptype class Bar\n"
479
    gdb_expect {
480
        -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;${ws}Bar & operator=\\(Bar const &\\);${ws}Bar\\(Bar const &\\);${ws}Bar\\(int, int, int\\);${ws}\}$nl$gdb_prompt $" {
481
            pass "ptype class Bar"
482
        }
483
        -re "type = class Bar : public Base1, public Foo \{${ws}public:${ws}int z;((${ws}Bar & operator=\\(Bar const &\\);)|(${ws}Bar\\(Bar const &\\);)|(${ws}Bar\\(int, int, int\\);))*${ws}\}$nl$gdb_prompt $" {
484
            pass "ptype class Bar (obsolescent gcc or gdb)"
485
        }
486
        -re ".*$gdb_prompt $" {
487
            fail "ptype class Bar"
488
        }
489
        timeout {
490
            fail "ptype class Bar (timeout)"
491
            return
492
        }
493
    }
494
}
495
 
496
#
497
# Test simple access to class members.
498
#
499
 
500
proc test_non_inherited_member_access {} {
501
    global gdb_prompt
502
 
503
    # Print non-inherited members of g_A.
504
 
505
    gdb_test "print g_A.a" ".* = 1" "g_A.a incorrect"
506
 
507
    gdb_test "print g_A.x" ".* = 2" "g_A.x incorrect"
508
 
509
    # Print non-inherited members of g_B.
510
 
511
    gdb_test "print g_B.b" ".* = 5" "g_B.b incorrect"
512
 
513
    gdb_test "print g_B.x" ".* = 6" "g_B.x incorrect"
514
 
515
    # Print non-inherited members of g_C.
516
 
517
    gdb_test "print g_C.c" ".* = 9" "g_C.c incorrect"
518
 
519
    gdb_test "print g_C.x" ".* = 10" "g_C.x incorrect"
520
 
521
    # Print non-inherited members of g_D.
522
 
523
    gdb_test "print g_D.d" ".* = 19" "g_D.d incorrect"
524
 
525
    gdb_test "print g_D.x" ".* = 20" "g_D.x incorrect"
526
 
527
    # Print non-inherited members of g_E.
528
 
529
    gdb_test "print g_E.e" ".* = 31" "g_E.e incorrect"
530
 
531
    gdb_test "print g_E.x" ".* = 32" "g_E.x incorrect"
532
}
533
 
534
#
535
# Try access to non-members that are members of another class.
536
# Should give errors.
537
#
538
 
539
proc test_wrong_class_members {} {
540
    global gdb_prompt
541
 
542
    gdb_test "print g_A.b" "There is no member( or method|) named b." "print g_A.b should be error"
543
 
544
    gdb_test "print g_B.c" "There is no member( or method|) named c." "print g_B.c should be error"
545
 
546
    gdb_test "print g_B.d" "There is no member( or method|) named d." "print g_B.d should be error"
547
 
548
    gdb_test "print g_C.b" "There is no member( or method|) named b." "print g_C.b should be error"
549
 
550
    gdb_test "print g_C.d" "There is no member( or method|) named d." "print g_C.d should be error"
551
 
552
    gdb_test "print g_D.e" "There is no member( or method|) named e." "print g_D.e should be error"
553
}
554
 
555
#
556
# Try access to non-members that are not members of any class.
557
# Should give errors.
558
#
559
 
560
proc test_nonexistant_members {} {
561
    global gdb_prompt
562
 
563
    gdb_test "print g_A.y" "There is no member( or method|) named y." "print g_A.y should be error"
564
 
565
    gdb_test "print g_B.z" "There is no member( or method|) named z." "print g_B.z should be error"
566
 
567
    gdb_test "print g_C.q" "There is no member( or method|) named q." "print g_C.q should be error"
568
 
569
    gdb_test "print g_D.p" "There is no member( or method|) named p." "print g_D.p should be error"
570
}
571
 
572
#
573
# Pointers to class members
574
#
575
 
576
proc test_pointers_to_class_members {} {
577
    global gdb_prompt
578
    global decimal
579
    global nl
580
 
581
    gdb_test "print Bar::z" ".* = .int\[ \]*\[( \]*Bar::&\[)\]+\[ \]*Bar::z" "print Bar::z"
582
 
583
    gdb_test "print &Foo::x" ".* = .int\[ \]*\[( \]*Foo::\[*)\]+\[ \]*&Foo::x" "print &Foo::x"
584
 
585
    gdb_test "print (int)&Foo::x" ".* = 0" "print (int)&Foo::x"
586
 
587
    send_gdb "print (int)&Bar::y == 2*sizeof(int)\n"
588
    gdb_expect {
589
        -re ".* = true$nl$gdb_prompt $" {
590
            pass "print (int)&Bar::y == 2*sizeof(int)"
591
        }
592
        -re "There is no field named y.*$gdb_prompt $" {
593
            setup_xfail "*-*-*"
594
            fail "print (int)&Bar::y == 2*sizeof(int)"
595
        }
596
        -re ".*$gdb_prompt $" { fail "print (int)&Bar::y == 2*sizeof(int)" }
597
        timeout { fail "print (int)&Bar::y == 2*sizeof(int) (timeout)" ; return }
598
    }
599
 
600
    send_gdb "next 2\n"
601
    setup_xfail "*-*-*"
602
    gdb_expect {
603
        -re "$decimal\[ \t\]+inheritance3 \[)(\]+;$nl$gdb_prompt $" {}
604
        -re ".*$gdb_prompt $" { fail "next to inheritance3" ; return }
605
    }
606
    clear_xfail "*-*-*"
607
 
608
    setup_xfail_format "DWARF 1"
609
    gdb_test "print (int)pmi == sizeof(int)" ".* = false" "print (int)pmi == sizeof(int)"
610
}
611
 
612
#
613
# Test static members.
614
#
615
 
616
proc test_static_members {} {
617
    global gdb_prompt
618
    global hex
619
    global nl
620
 
621
    send_gdb "print Foo::st\n"
622
    gdb_expect {
623
        -re ".* = 100$nl$gdb_prompt $" {
624
            pass "print Foo::st"
625
        }
626
        -re "There is no field named st.*$gdb_prompt $" {
627
            setup_xfail "*-*-*"
628
            fail "print Foo::st"
629
        }
630
        -re ".*$gdb_prompt $" { fail "print Foo::st" }
631
       timeout { fail "print Foo::st (timeout)" ; return }
632
    }
633
 
634
    send_gdb "set foo.st = 200\n"
635
    gdb_expect {
636
        -re ".*$gdb_prompt $" {}
637
    }
638
 
639
    send_gdb "print bar.st\n"
640
    gdb_expect {
641
        -re ".* = 200$nl$gdb_prompt $" {
642
            pass "print bar.st"
643
        }
644
        -re "There is no member( or method|) named st.*$gdb_prompt $" {
645
            setup_xfail "*-*-*"
646
            fail "print bar.st"
647
        }
648
        -re ".*$gdb_prompt $" { fail "print bar.st" }
649
       timeout { fail "print bar.st (timeout)" ; return }
650
    }
651
 
652
    send_gdb "print &foo.st\n"
653
    gdb_expect {
654
        -re ".* = .int \[*)\]+ $hex$nl$gdb_prompt $" {
655
            pass "print &foo.st"
656
        }
657
        -re "There is no member( or method|) named st.*$gdb_prompt $" {
658
            setup_xfail "*-*-*"
659
            fail "print &foo.st"
660
        }
661
        -re ".*$gdb_prompt $" { fail "print &foo.st" }
662
       timeout { fail "print &foo.st (timeout)" ; return }
663
    }
664
 
665
    set got_bar_st 0
666
    send_gdb "print &Bar::st\n"
667
    gdb_expect {
668
        -re ".* = .int \[*)\]+ $hex$nl$gdb_prompt $" {
669
            pass "print &Bar::st"
670
            set got_bar_st 1
671
        }
672
        -re "There is no field named st.*$gdb_prompt $" {
673
            setup_xfail "*-*-*"
674
            fail "print &Bar::st"
675
        }
676
        -re ".*$gdb_prompt $" { fail "print &Bar::st" }
677
       timeout { fail "print &Bar::st (timeout)" ; return }
678
    }
679
 
680
    if $got_bar_st then {
681
        gdb_test "print *\$" ".* = 200" "print *\$"
682
    }
683
 
684
    gdb_test "set print static-members off" ""
685
    gdb_test "print csi" \
686
        "{x = 10, y = 20}" \
687
        "print csi without static members"
688
    gdb_test "print cnsi" \
689
        "{x = 30, y = 40}" \
690
        "print cnsi without static members"
691
 
692
    gdb_test "set print static-members on" ""
693
    setup_xfail_format "DWARF 1"
694
    gdb_test "print csi" \
695
        "{x = 10, y = 20, static null = {x = 0, y = 0, static null = }}" \
696
        "print csi with static members"
697
    setup_xfail_format "DWARF 1"
698
    gdb_test "print cnsi" \
699
        "{x = 30, y = 40, static null = {x = 0, y = 0, static null = , static yy = {z = 5, static xx = {x = 1, y = 2, static null = , static yy = }}}, static yy = }" \
700
        "print cnsi with static members"
701
}
702
 
703
proc do_tests {} {
704
    global prms_id
705
    global bug_id
706
    global subdir
707
    global objdir
708
    global srcdir
709
    global binfile
710
    global gdb_prompt
711
 
712
    set prms_id 0
713
    set bug_id 0
714
 
715
    # Start with a fresh gdb.
716
 
717
    gdb_exit
718
    gdb_start
719
    gdb_reinitialize_dir $srcdir/$subdir
720
    gdb_load $binfile
721
 
722
    send_gdb "set language c++\n"
723
    gdb_expect -re "$gdb_prompt $"
724
    send_gdb "set width 0\n"
725
    gdb_expect -re "$gdb_prompt $"
726
 
727
    # Get the debug format for the compiled test case.
728
 
729
    if [ runto_main ] then {
730
        get_debug_format
731
    }
732
 
733
    test_ptype_class_objects
734
 
735
    if [ runto 'inheritance2(void)' ] then {
736
        test_non_inherited_member_access
737
        test_wrong_class_members
738
        test_nonexistant_members
739
    }
740
 
741
    if [istarget "mips-idt-*"] then {
742
        # Restart because IDT/SIM runs out of file descriptors.
743
        gdb_exit
744
        gdb_start
745
        gdb_reinitialize_dir $srcdir/$subdir
746
        gdb_load $binfile
747
    }
748
 
749
    if [ runto_main ] then {
750
        test_pointers_to_class_members
751
        test_static_members
752
    }
753
 
754
    if [istarget "mips-idt-*"] then {
755
        # Restart because IDT/SIM runs out of file descriptors.
756
        gdb_exit
757
        gdb_start
758
        gdb_reinitialize_dir $srcdir/$subdir
759
        gdb_load $binfile
760
    }
761
 
762
    if [ runto marker_reg1 ] then {
763
 
764
        gdb_test "finish" "Run till exit from.*" "finish from marker_reg1"
765
 
766
        send_gdb "print v.method ()\n"
767
        gdb_expect {
768
            -re "= 82.*$gdb_prompt $" {
769
                pass "calling method for small class"
770
            }
771
            -re "Address requested for identifier .v. which is in a register.*$gdb_prompt $" {
772
                setup_xfail "*-*-*" 2972
773
                fail "calling method for small class"
774
            }
775
            -re ".*$gdb_prompt $" { fail "calling method for small class" }
776
            timeout { fail "calling method for small class (timeout)" }
777
            eof { fail "calling method for small class (eof)" }
778
        }
779
    }
780
 
781
}
782
 
783
do_tests
784
 
785
 
786
# Some additional tests for enums inside classes
787
 
788
 
789
# set a breakpoint and go there
790
send_gdb "break 516\n"
791
gdb_expect {
792
   -re "Breakpoint \[0-9\] at.*$gdb_prompt $" { pass "set break 516" }
793
   -re "$gdb_prompt $"                     { fail "set break 516" }
794
   timeout                             { fail "(timeout) set break 516" }
795
}
796
send_gdb "continue\n"
797
gdb_expect {
798
   -re "Continuing\\.\r\n\r\nBreakpoint \[0-9\]*, main....at.*misc\\.cc:516\r\n516.*\r\n$gdb_prompt $" { pass "continue" }
799
   -re "$gdb_prompt $"                     { fail "continue" }
800
   timeout                             { fail "(timeout) continue" }
801
}
802
 
803
# print the object
804
send_gdb "print obj_with_enum\n"
805
gdb_expect {
806
   -re "\\$\[0-9\]* = \\{priv_enum = red, x = 0\\}.*$gdb_prompt $" { pass "print obj_with_enum (1)" }
807
   -re "$gdb_prompt $"                     { fail "print obj_with_enum (1)" }
808
   timeout                             { fail "(timeout) print obj_with_enum (1)" }
809
}
810
 
811
send_gdb "next\n"
812
gdb_expect {
813
   -re "$gdb_prompt $"                     { pass "next" }
814
   timeout                             { fail "(timeout) next" }
815
}
816
 
817
# print the object again
818
send_gdb "print obj_with_enum\n"
819
gdb_expect {
820
   -re "\\$\[0-9\]* = \\{priv_enum = green, x = 0\\}.*$gdb_prompt $" { pass "print obj_with_enum (2)" }
821
   -re "$gdb_prompt $"                     { fail "print obj_with_enum (2)" }
822
   timeout                             { fail "(timeout) print obj_with_enum (2)" }
823
}
824
 
825
# print out the enum member
826
send_gdb "print obj_with_enum.priv_enum\n"
827
gdb_expect {
828
   -re "\\$\[0-9\]* = green.*$gdb_prompt $" { pass "print obj_with_enum.priv_enum" }
829
   -re "$gdb_prompt $"                     { fail "print obj_with_enum.priv_enum" }
830
   timeout                             { fail "(timeout) print obj_with_enum.priv_enum" }
831
}
832
 
833
# ptype on the enum member
834
# The third success case is a little dubious, but it's not clear what
835
# ought to be required of a ptype on a private enum... -sts 19990324
836
send_gdb "ptype obj_with_enum.priv_enum\n"
837
gdb_expect {
838
   -re "type = enum ClassWithEnum::PrivEnum \\{red, green, blue, yellow = 42\\}.*$gdb_prompt $" { pass "ptype obj_with_enum.priv_enum" }
839
   -re "type = enum PrivEnum \\{red, green, blue, yellow = 42\\}.*$gdb_prompt $" { pass "ptype obj_with_enum.priv_enum" }
840
   -re "type = enum \\{red, green, blue, yellow = 42\\}.*$gdb_prompt $" { pass "ptype obj_with_enum.priv_enum" }
841
   -re "$gdb_prompt $"                     { fail "ptype obj_with_enum.priv_enum" }
842
   timeout                             { fail "(timeout) ptype obj_with_enum.priv_enum" }
843
}
844
 
845
# ptype on the object
846
# g++ is putting out the wrong debug info.  This works with aCC
847
if {!$hp_aCC_compiler} {setup_xfail "*-*-*"}
848
send_gdb "ptype obj_with_enum\n"
849
gdb_expect {
850
   -re "type = class ClassWithEnum \\{\r\n\[ \t\]*public:\r\n\[ \t\]*(enum |)ClassWithEnum::PrivEnum priv_enum;\r\n\[ \t\]*int x;\r\n\\}\r\n$gdb_prompt $" { pass "ptype obj_with_enum" }
851
   -re "$gdb_prompt $"                     { fail "ptype obj_with_enum" }
852
   timeout                             { fail "(timeout) ptype obj_with_enum" }
853
}
854
 
855
# g++ is putting out the wrong debug info.  This works with aCC
856
if {!$hp_aCC_compiler} {setup_xfail "*-*-*"}
857
send_gdb "print (ClassWithEnum::PrivEnum) 42\n"
858
gdb_expect {
859
   -re "\\$\[0-9\]* = yellow.*$gdb_prompt $" { pass "print (ClassWithEnum::PrivEnum) 42" }
860
   -re "$gdb_prompt $"                     { fail "print (ClassWithEnum::PrivEnum) 42" }
861
   timeout                             { fail "(timeout) print (ClassWithEnum::PrivEnum) 42" }
862
}
863
 
864
 
865
send_gdb "maint demangle inheritance1__Fv\n"
866
gdb_expect {
867
   -re "inheritance1\\(void\\).*$gdb_prompt $" { pass "demangle" }
868
   -re ".*$gdb_prompt $"   { fail "demangle" }
869
   timeout           { fail "(timeout) demangle" }
870
}
871
 

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.