OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [testsuite/] [gdb.cp/] [member-ptr.exp] - Blame information for rev 357

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn 
# Copyright 1998, 1999, 2003, 2004, 2006, 2007, 2008, 2009, 2010
2 
# Free Software Foundation, Inc.
3 
 
4 
# This file is part of the gdb testsuite
5 
 
6 
# This program is free software; you can redistribute it and/or modify
7 
# it under the terms of the GNU General Public License as published by
8 
# the Free Software Foundation; either version 3 of the License, or
9 
# (at your option) any later version.
10 
#
11 
# This program is distributed in the hope that it will be useful,
12 
# but WITHOUT ANY WARRANTY; without even the implied warranty of
13 
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 
# GNU General Public License for more details.
15 
#
16 
# You should have received a copy of the GNU General Public License
17 
# along with this program.  If not, see .
18 
 
19 
# Tests for pointer-to-member support
20 
# Written by Satish Pai  1997-08-19
21 
# Rewritten by Michael Chastain  2004-01-11
22 
 
23 
set vhn "\\$\[0-9\]+"
24 
 
25 
if $tracelevel then {
26 
    strace $tracelevel
27 
}
28 
 
29 
if { [skip_cplus_tests] } { continue }
30 
 
31 
 
32 
set testfile "member-ptr"
33 
set srcfile ${testfile}.cc
34 
set binfile ${objdir}/${subdir}/${testfile}
35 
 
36 
if [get_compiler_info ${binfile} "c++"] {
37 
    return -1
38 
}
39 
 
40 
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug c++}] != "" } {
41 
     untested member-ptr.exp
42 
     return -1
43 
}
44 
 
45 
gdb_exit
46 
gdb_start
47 
gdb_reinitialize_dir $srcdir/$subdir
48 
gdb_load ${binfile}
49 
 
50 
if ![runto_main] then {
51 
    perror "couldn't run to breakpoint"
52 
    continue
53 
}
54 
 
55 
gdb_breakpoint [gdb_get_line_number "Breakpoint 1 here"]
56 
gdb_continue_to_breakpoint "continue to pmi = NULL"
57 
 
58 
# ======================
59 
# pointer to member data
60 
# ======================
61 
 
62 
# ptype on pointer to data member
63 
 
64 
set name "ptype pmi (A::j)"
65 
gdb_test_multiple "ptype pmi" $name {
66 
    -re "type = int A::\\*\r\n$gdb_prompt $" {
67 
        pass $name
68 
    }
69 
}
70 
 
71 
# print pointer to data member
72 
 
73 
set name "print pmi (A::j) "
74 
gdb_test_multiple "print pmi" $name {
75 
    -re "$vhn = &A::j\r\n$gdb_prompt $" {
76 
        pass $name
77 
    }
78 
    -re "$vhn = \\(int ?\\( ?A::\\*\\)\\) &A::j\r\n$gdb_prompt $" {
79 
        pass $name
80 
    }
81 
    -re "$vhn = \\(int ?\\( ?A::\\*\\)\\) ?&A::j ?\\+ ?1 bytes\r\n$gdb_prompt $" {
82 
        # gcc 2.95.3 -gdwarf-2
83 
        kfail "gdb/NNNN" $name
84 
    }
85 
    -re "$vhn = &A::j ?\\+ ?1 bytes\r\n$gdb_prompt $" {
86 
        # gcc 2.95.3 -gstabs+
87 
        kfail "gdb/NNNN" $name
88 
    }
89 
    -re "$vhn = not implemented: member type in c_val_print\r\n$gdb_prompt $" {
90 
        # gcc HEAD 2004-01-11 05:33:21 -gdwarf-2
91 
        # gcc HEAD 2004-01-11 05:33:21 -gstabs+
92 
        kfail "gdb/NNNN" $name
93 
    }
94 
    -re "$vhn = \\(int ?\\( A::\\*\\)\\) 536870920\r\n$gdb_prompt $" {
95 
        # the value is 0x20000008 hex.   0x20000000 is an internal flag.
96 
        # Use '|' to add in more values as needed.
97 
        # hpacc A.03.45
98 
        kfail "gdb/NNNN" $name
99 
    }
100 
}
101 
 
102 
# print dereferenced pointer to data member
103 
 
104 
set name "print a.*pmi (A::j)"
105 
gdb_test_multiple "print a.*pmi" $name {
106 
    -re "$vhn = 121\r\n$gdb_prompt $" {
107 
        pass $name
108 
    }
109 
    -re "$vhn = 855638016\r\n$gdb_prompt $" {
110 
        # gcc 2.95.3 -gdwarf-2
111 
        # gcc 2.95.3 -gstabs+
112 
        kfail "gdb/NNNN" $name
113 
    }
114 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
115 
        # gcc HEAD 2004-01-10 -gdwarf-2
116 
        # gcc HEAD 2004-01-10 -gstabs+
117 
        kfail "gdb/NNNN" $name
118 
    }
119 
}
120 
 
121 
# print dereferenced pointer to data member
122 
# this time, dereferenced through a pointer
123 
 
124 
set name "print a_p->*pmi (A::j)"
125 
gdb_test_multiple "print a_p->*pmi" $name {
126 
    -re "$vhn = 121\r\n$gdb_prompt $" {
127 
        pass $name
128 
    }
129 
    -re "$vhn = 855638016\r\n$gdb_prompt $" {
130 
        # gcc 2.95.3 -gdwarf-2
131 
        # gcc 2.95.3 -gstabs+
132 
        kfail "gdb/NNNN" $name
133 
    }
134 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
135 
        # gcc HEAD 2004-01-10 -gdwarf-2
136 
        # gcc HEAD 2004-01-10 -gstabs+
137 
        kfail "gdb/NNNN" $name
138 
    }
139 
}
140 
 
141 
# set the pointer to a different data member
142 
 
143 
set name "set var pmi = &A::jj"
144 
gdb_test_multiple "set var pmi = &A::jj" $name {
145 
    -re "Invalid cast.\r\n$gdb_prompt $" {
146 
        # gcc HEAD 2004-01-10 -gdwarf-2
147 
        # gcc HEAD 2004-01-10 -gstabs+
148 
        kfail "gdb/NNNN" $name
149 
    }
150 
    -re "set var pmi = &A::jj\r\n$gdb_prompt $" {
151 
        # I have to match the echo'ed input explicitly here.
152 
        # If I leave it out, the pattern becomes too general
153 
        # and matches anything that ends in "$gdb_prompt $".
154 
        pass $name
155 
    }
156 
}
157 
 
158 
# print the pointer again
159 
 
160 
set name "print pmi (A::jj)"
161 
gdb_test_multiple "print pmi" $name {
162 
    -re "$vhn = &A::jj\r\n$gdb_prompt $" {
163 
        pass $name
164 
    }
165 
    -re "$vhn = \\(int ?\\( ?A::\\*\\)\\) &A::jj\r\n$gdb_prompt $" {
166 
        pass $name
167 
    }
168 
    -re "$vhn = not implemented: member type in c_val_print\r\n$gdb_prompt $" {
169 
        # gcc HEAD 2004-01-11 05:33:21 -gdwarf-2
170 
        # gcc HEAD 2004-01-11 05:33:21 -gstabs+
171 
        kfail "gdb/NNNN" $name
172 
    }
173 
    -re "$vhn = \\(int ?\\( A::\\*\\)\\) 536870924\r\n$gdb_prompt $" {
174 
        # the value is 0x20000008 hex.   0x20000000 is an internal flag.
175 
        # Use '|' to add in more values as needed.
176 
        # hpacc A.03.45
177 
        kfail "gdb/NNNN" $name
178 
    }
179 
}
180 
 
181 
# print dereferenced pointer to data member again
182 
 
183 
set name "print a.*pmi (A::jj)"
184 
gdb_test_multiple "print a.*pmi" $name {
185 
    -re "$vhn = 1331\r\n$gdb_prompt $" {
186 
        pass $name
187 
    }
188 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
189 
        # gcc HEAD 2004-01-10 -gdwarf-2
190 
        # gcc HEAD 2004-01-10 -gstabs+
191 
        kfail "gdb/NNNN" $name
192 
    }
193 
}
194 
 
195 
# set the pointer to data member back to A::j
196 
 
197 
set name "set var pmi = &A::j"
198 
gdb_test_multiple "set var pmi = &A::j" $name {
199 
    -re "Invalid cast.\r\n$gdb_prompt $" {
200 
        # gcc HEAD 2004-01-10 -gdwarf-2
201 
        # gcc HEAD 2004-01-10 -gstabs+
202 
        kfail "gdb/NNNN" $name
203 
    }
204 
    -re "set var pmi = &A::j\r\n$gdb_prompt $" {
205 
        # I have to match the echo'ed input explicitly here.
206 
        # If I leave it out, the pattern becomes too general
207 
        # and matches anything that ends in "$gdb_prompt $".
208 
        pass $name
209 
    }
210 
}
211 
 
212 
# print dereferenced pointer to data member yet again (extra check, why not)
213 
 
214 
set name "print a.*pmi (A::j) (again)"
215 
gdb_test_multiple "print a.*pmi" $name {
216 
    -re "$vhn = 121\r\n$gdb_prompt $" {
217 
        pass $name
218 
    }
219 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
220 
        # gcc HEAD 2004-01-10 -gdwarf-2
221 
        # gcc HEAD 2004-01-10 -gstabs+
222 
        kfail "gdb/NNNN" $name
223 
    }
224 
}
225 
 
226 
# Set the data member pointed to.
227 
 
228 
set name "print a.*pmi = 33"
229 
gdb_test_multiple "print a.*pmi = 33" $name {
230 
    -re "$vhn = 33\r\n$gdb_prompt $" {
231 
        pass $name
232 
    }
233 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
234 
        # gcc HEAD 2004-01-10 -gdwarf-2
235 
        # gcc HEAD 2004-01-10 -gstabs+
236 
        kfail "gdb/NNNN" $name
237 
    }
238 
}
239 
 
240 
# Now check that the data really was changed
241 
 
242 
set name "print a.*pmi (A::j) (33)"
243 
gdb_test_multiple "print a.*pmi" $name {
244 
    -re "$vhn = 33\r\n$gdb_prompt $" {
245 
        pass $name
246 
    }
247 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
248 
        # gcc HEAD 2004-01-10 -gdwarf-2
249 
        # gcc HEAD 2004-01-10 -gstabs+
250 
        kfail "gdb/NNNN" $name
251 
    }
252 
}
253 
 
254 
# Double-check by printing a.
255 
 
256 
set name "print a (j = 33)"
257 
gdb_test_multiple "print a" $name {
258 
    -re "$vhn = \{c = 120 'x', j = 33, jj = 1331, (static|static int) s = 10, (_vptr.A|_vptr\\$) = ($hex|$hex )\}\r\n$gdb_prompt $" {
259 
        pass $name
260 
    }
261 
    -re "$vhn = \{c = 120 'x', j = 33, jj = 1331, (static|static int) s = 10, Virtual table at $hex\}\r\n$gdb_prompt $" {
262 
        pass $name
263 
    }
264 
    -re "$vhn = \{(_vptr.A|_vptr\\$) = $hex, c = 120 'x', j = 33, jj = 1331, (static|static int) s = 10\}\r\n$gdb_prompt $" {
265 
        pass $name
266 
    }
267 
    -re "$vhn = \{(_vptr.A|_vptr\\$) = $hex, c = 120 'x', j = 121, jj = 1331, (static|static int) s = 10\}\r\n$gdb_prompt $" {
268 
        # gcc HEAD 2004-01-10 -gdwarf-2
269 
        # gcc HEAD 2004-01-10 -gstabs+
270 
        kfail "gdb/NNNN" $name
271 
    }
272 
}
273 
 
274 
# Set the data member pointed to, using ->*
275 
 
276 
set name "print a_p->*pmi = 44"
277 
gdb_test_multiple "print a_p->*pmi = 44" $name {
278 
    -re "$vhn = 44\r\n$gdb_prompt $" {
279 
        pass $name
280 
    }
281 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
282 
        # gcc HEAD 2004-01-10 -gdwarf-2
283 
        # gcc HEAD 2004-01-10 -gstabs+
284 
        kfail "gdb/NNNN" $name
285 
    }
286 
}
287 
 
288 
# Check that the data really was changed
289 
 
290 
set name "print a_p->*pmi (44)"
291 
gdb_test_multiple "print a_p->*pmi" $name {
292 
    -re "$vhn = 44\r\n$gdb_prompt $" {
293 
        pass $name
294 
    }
295 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
296 
        # gcc HEAD 2004-01-10 -gdwarf-2
297 
        # gcc HEAD 2004-01-10 -gstabs+
298 
        kfail "gdb/NNNN" $name
299 
    }
300 
}
301 
 
302 
# Double-check by printing a.
303 
 
304 
set name "print a (j = 44)"
305 
gdb_test_multiple "print a" $name {
306 
    -re "$vhn = \{c = 120 'x', j = 44, jj = 1331, (static|static int) s = 10, (_vptr.A|_vptr\\$) = ($hex|$hex )\}\r\n$gdb_prompt $" {
307 
        pass $name
308 
    }
309 
    -re "$vhn = \{c = 120 'x', j = 44, jj = 1331, (static|static int) s = 10, Virtual table at $hex\}\r\n$gdb_prompt $" {
310 
        pass $name
311 
    }
312 
    -re "$vhn = \{(_vptr.A|_vptr\\$) = $hex, c = 120 'x', j = 44, jj = 1331, (static|static int) s = 10\}\r\n$gdb_prompt $" {
313 
        pass $name
314 
    }
315 
    -re "$vhn = \{(_vptr.A|_vptr\\$) = $hex, c = 120 'x', j = 121, jj = 1331, (static|static int) s = 10\}\r\n$gdb_prompt $" {
316 
        # gcc HEAD 2004-01-10 -gdwarf-2
317 
        # gcc HEAD 2004-01-10 -gstabs+
318 
        kfail "gdb/NNNN" $name
319 
    }
320 
}
321 
 
322 
# ptype the dereferenced pointer to member.
323 
 
324 
set name "ptype a.*pmi"
325 
gdb_test_multiple "ptype a.*pmi" $name {
326 
    -re "type = int\r\n$gdb_prompt" {
327 
        pass $name
328 
    }
329 
    -re "not implemented: member types in unpack_long\r\n$gdb_prompt $" {
330 
        # gcc HEAD 2004-01-10 -gdwarf-2
331 
        # gcc HEAD 2004-01-10 -gstabs+
332 
        kfail "gdb/NNNN" $name
333 
    }
334 
}
335 
 
336 
# dereference the pointer to data member without any object
337 
# this is not allowed: a pmi must be bound to an object to dereference
338 
 
339 
set name "print *pmi"
340 
gdb_test_multiple "print *pmi" $name {
341 
    -re "Attempt to dereference pointer to member without an object\r\n$gdb_prompt $" {
342 
        pass $name
343 
    }
344 
    -re "Cannot access memory at address 0x4\r\n$gdb_prompt $" {
345 
        # gcc 2.95.3 -gstabs+
346 
        kfail "gdb/NNNN" $name
347 
    }
348 
    -re "Cannot access memory at address 0x8\r\n$gdb_prompt $" {
349 
        # gcc 3.3.2 -gdwarf-2
350 
        # gcc 3.3.2 -gstabs+
351 
        kfail "gdb/NNNN" $name
352 
    }
353 
}
354 
 
355 
# dereference the pointer to data member without any object
356 
# this is not allowed: a pmi must be bound to an object to dereference
357 
 
358 
set name "ptype *pmi"
359 
gdb_test_multiple "ptype *pmi" $name {
360 
    -re "Attempt to dereference pointer to member without an object\r\n$gdb_prompt $" {
361 
        pass $name
362 
    }
363 
    -re "type = int  A::\r\n$gdb_prompt $" {
364 
        # gcc 2.95.3 -gstabs+
365 
        # gcc HEAD 2004-01-10 -gdwarf-2
366 
        # gcc HEAD 2004-01-10 -gstabs+
367 
        kfail "gdb/NNNN" $name
368 
    }
369 
}
370 
 
371 
# Check cast of pointer to member to integer.
372 
# This is similar to "offset-of".
373 
# such as "A a; print (size_t) &A.j - (size_t) &A".
374 
 
375 
set name "print (int) pmi"
376 
gdb_test_multiple "print (int) pmi" $name {
377 
    -re "$vhn = (4|8|12)\r\n$gdb_prompt" {
378 
        pass $name
379 
    }
380 
}
381 
 
382 
# Check "(int) pmi" explicitly for equality.
383 
 
384 
set name "print ((int) pmi) == ((char *) &a.j - (char *) &a)"
385 
gdb_test_multiple "print ((int) pmi) == ((char *) &a.j - (char *) & a)" $name {
386 
    -re "$vhn = true\r\n$gdb_prompt" {
387 
        pass $name
388 
    }
389 
}
390 
 
391 
# ==========================
392 
# pointer to member function
393 
# ==========================
394 
 
395 
# ptype a pointer to a method
396 
 
397 
set name "ptype pmf"
398 
gdb_test_multiple "ptype pmf" $name {
399 
    -re "type = int \\( ?A::\\*\\)\\(A \\*, int\\)\r\n$gdb_prompt $" {
400 
        pass $name
401 
    }
402 
    -re "type = int \\( ?A::\\*\\)\\(void\\)\r\n$gdb_prompt $" {
403 
        # hpacc A.03.45
404 
        kfail "gdb/NNNN" $name
405 
    }
406 
    -re "type = struct \{.*\}\r\n$gdb_prompt $" {
407 
        # gcc 2.95.3 -gdwarf-2
408 
        # gcc 2.95.3 -gstabs+
409 
        # gcc 3.2.2 -gdwarf-2
410 
        # gcc 3.2.2 -gstabs+
411 
        # gcc HEAD 2004-01-10 -gdwarf-2
412 
        # gcc HEAD 2004-01-10 -gstabs+
413 
        kfail "gdb/NNNN" $name
414 
    }
415 
}
416 
 
417 
# print a pointer to a method
418 
 
419 
set name "print pmf"
420 
gdb_test_multiple "print pmf" $name {
421 
    -re "$vhn = \\(int \\(A::\\*\\)\\(A \\*, int\\)\\) $hex \r\n$gdb_prompt $" {
422 
        pass $name
423 
    }
424 
    -re "$vhn = .*not supported with HP aCC.*\r\n$gdb_prompt $" {
425 
        # hpacc A.03.45
426 
        kfail "gdb/NNNN" $name
427 
    }
428 
    -re "$vhn = \{.*\}\r\n$gdb_prompt $" {
429 
        # gcc 2.95.3 -gdwarf-2
430 
        # gcc 2.95.3 -gstabs+
431 
        # gcc 3.2.2 -gdwarf-2
432 
        # gcc 3.2.2 -gstabs+
433 
        # gcc HEAD 2004-01-10 -gdwarf-2
434 
        # gcc HEAD 2004-01-10 -gstabs+
435 
        kfail "gdb/NNNN" $name
436 
    }
437 
}
438 
 
439 
# ptype a pointer to a pointer to a method
440 
 
441 
set name "ptype pmf_p"
442 
gdb_test_multiple "ptype pmf_p" $name {
443 
    -re "type = int \\( ?A::\\*\\*\\)\\(A \\*, int\\)\r\n$gdb_prompt $" {
444 
        pass $name
445 
    }
446 
    -re "type = int \\( ?A::\\*\\*\\)\\(void\\)\r\n$gdb_prompt $" {
447 
        # hpacc A.03.45
448 
        kfail "gdb/NNNN" $name
449 
    }
450 
    -re "type = struct \{.*\} \\*\r\n$gdb_prompt $" {
451 
        # gcc 2.95.3 -gdwarf-2
452 
        # gcc 2.95.3 -gstabs+
453 
        # gcc 3.2.2 -gdwarf-2
454 
        # gcc 3.2.2 -gstabs+
455 
        # gcc HEAD 2004-01-10 -gdwarf-2
456 
        # gcc HEAD 2004-01-10 -gstabs+
457 
        kfail "gdb/NNNN" $name
458 
    }
459 
}
460 
 
461 
# print a pointer to a pointer to a method
462 
 
463 
set name "print pmf_p"
464 
gdb_test_multiple "print pmf_p" $name {
465 
    -re "$vhn = \\(int \\( ?A::\\*\\*\\)\\)\\(int\\)\\) $hex\r\n$gdb_prompt $" {
466 
        pass $name
467 
    }
468 
    -re "$vhn = \\(PMF \\*\\) $hex\r\n$gdb_prompt $" {
469 
        pass "gdb/NNNN"
470 
    }
471 
    -re "$vhn = \\(int \\( ?A::\\*\\*\\)\\(void\\)\\) $hex\r\n$gdb_prompt $" {
472 
        # hpacc A.03.45
473 
        kfail "gdb/NNNN" $name
474 
    }
475 
    -re "$vhn = \\(struct \{.*\} \\*\\) $hex\r\n$gdb_prompt $" {
476 
        # gcc 2.95.3 -gdwarf-2
477 
        kfail "gdb/NNNN" $name
478 
    }
479 
}
480 
 
481 
# print dereferenced pointer to method
482 
 
483 
set name "print a.*pmf"
484 
gdb_test_multiple "print a.*pmf" $name {
485 
    -re "$vhn = {int \\(A \\*, int\\)} $hex \r\n$gdb_prompt $" {
486 
        pass $name
487 
    }
488 
    -re "Pointers to methods not supported with HP aCC\r\n$gdb_prompt $" {
489 
        # hpacc A.03.45
490 
        kfail "gdb/NNNN" $name
491 
    }
492 
    -re "Value can't be converted to integer.\r\n$gdb_prompt $" {
493 
        # gcc 2.95.3 -gdwarf-2
494 
        # gcc 2.95.3 -gstabs+
495 
        # gcc 3.2.2 -gdwarf-2
496 
        # gcc 3.2.2 -gstabs+
497 
        # gcc HEAD 2004-01-10 -gdwarf-2
498 
        # gcc HEAD 2004-01-10 -gstabs+
499 
        kfail "gdb/NNNN" $name
500 
    }
501 
}
502 
 
503 
# print dereferenced pointer to method, using ->*
504 
 
505 
set name "print a_p->*pmf"
506 
gdb_test_multiple "print a_p->*pmf" $name {
507 
    -re "$vhn = {int \\(A \\*, int\\)} $hex \r\n$gdb_prompt $" {
508 
        pass $name
509 
    }
510 
    -re "Pointers to methods not supported with HP aCC\r\n$gdb_prompt $" {
511 
        # hpacc A.03.45
512 
        kfail "gdb/NNNN" $name
513 
    }
514 
    -re "Value can't be converted to integer.\r\n$gdb_prompt $" {
515 
        # gcc 2.95.3 -gdwarf-2
516 
        # gcc 2.95.3 -gstabs+
517 
        # gcc 3.2.2 -gdwarf-2
518 
        # gcc 3.2.2 -gstabs+
519 
        # gcc HEAD 2004-01-10 -gdwarf-2
520 
        # gcc HEAD 2004-01-10 -gstabs+
521 
        kfail "gdb/NNNN" $name
522 
    }
523 
}
524 
 
525 
# set the pointer to data member
526 
 
527 
set name "set var pmf = &A::foo"
528 
gdb_test_multiple "set var pmf = &A::foo" $name {
529 
    -re "set var pmf = &A::foo\r\n$gdb_prompt $" {
530 
        # I have to match the echo'ed input explicitly here.
531 
        # If I leave it out, the pattern becomes too general
532 
        # and matches anything that ends in "$gdb_prompt $".
533 
        pass $name
534 
    }
535 
    -re "Invalid cast.\r\n$gdb_prompt $" {
536 
        # gcc 2.95.3 -gdwarf-2
537 
        # gcc 2.95.3 -gstabs+
538 
        # gcc 3.2.2 -gdwarf-2
539 
        # gcc 3.2.2 -gstabs+
540 
        # gcc HEAD 2004-01-10 -gdwarf-2
541 
        # gcc HEAD 2004-01-10 -gstabs+
542 
        kfail "gdb/NNNN" $name
543 
    }
544 
    -re "Assignment to pointers to methods not implemented with HP aCC\r\n$gdb_prompt $" {
545 
        kfail "gdb/NNNN" $name
546 
    }
547 
}
548 
 
549 
# dereference the pointer to data member without any object
550 
# this is not allowed: a pmf must be bound to an object to dereference
551 
 
552 
set name "print *pmf"
553 
gdb_test_multiple "print *pmf" $name {
554 
    -re "Attempt to dereference pointer to member without an object\r\n$gdb_prompt $" {
555 
        pass $name
556 
    }
557 
    -re "Structure has no component named operator\\*.\r\n$gdb_prompt $" {
558 
        # gcc 2.95.3 -gdwarf-2
559 
        # gcc 2.95.3 -gstabs+
560 
        # gcc 3.3.2 -gdwarf-2
561 
        # gcc 3.3.2 -gstabs+
562 
        # gcc HEAD 2004-01-10 -gdwarf-2
563 
        # gcc HEAD 2004-01-10 -gstabs+
564 
        kfail "gdb/NNNN" $name
565 
    }
566 
}
567 
 
568 
# dereference the pointer to data member without any object
569 
# this is not allowed: a pmf must be bound to an object to dereference
570 
 
571 
set name "ptype *pmf"
572 
gdb_test_multiple "ptype *pmf" $name {
573 
    -re "Attempt to dereference pointer to member without an object\r\n$gdb_prompt $" {
574 
        pass $name
575 
    }
576 
    -re "Structure has no component named operator\\*.\r\n$gdb_prompt $" {
577 
        # gcc 2.95.3 -gdwarf-2
578 
        # gcc 2.95.3 -gstabs+
579 
        # gcc 3.3.2 -gdwarf-2
580 
        # gcc 3.3.2 -gstabs+
581 
        # gcc HEAD 2004-01-10 -gdwarf-2
582 
        # gcc HEAD 2004-01-10 -gstabs+
583 
        kfail "gdb/NNNN" $name
584 
    }
585 
}
586 
 
587 
# Call a function through a pmf.
588 
 
589 
set name "print (a.*pmf)(3)"
590 
gdb_test_multiple "print (a.*pmf)(3)" $name {
591 
    -re "$vhn = 50\r\n$gdb_prompt $" {
592 
        pass $name
593 
    }
594 
    -re "Not implemented: function invocation through pointer to method with HP aCC\r\n$gdb_prompt $" {
595 
        # hpacc A.03.45
596 
        kfail "gdb/NNNN" $name
597 
    }
598 
    -re "Value can't be converted to integer.\r\n$gdb_prompt $" {
599 
        # gcc 2.95.3 -gdwarf-2
600 
        # gcc 2.95.3 -gstabs+
601 
        # gcc 3.3.2 -gdwarf-2
602 
        # gcc 3.3.2 -gstabs+
603 
        # gcc HEAD 2004-01-10 -gdwarf-2
604 
        # gcc HEAD 2004-01-10 -gstabs+
605 
        kfail "gdb/NNNN" $name
606 
    }
607 
}
608 
 
609 
gdb_test "ptype a.*pmf" "type = int \\(A \\*, int\\)"
610 
 
611 
# Print out a pointer to data member which requires looking into
612 
# a base class.
613 
gdb_test "print diamond_pmi" "$vhn = &Base::x"
614 
gdb_test "print diamond.*diamond_pmi" "$vhn = 77"
615 
 
616 
# Examine some more complicated pmfs, which require adjusting "this"
617 
# and looking through virtual tables.
618 
 
619 
# These two have a different object adjustment, but call the same method.
620 
gdb_test "print diamond.*left_pmf" \
621 
    "$vhn = {int \\(Diamond \\*\\)} $hex "
622 
gdb_test "print diamond.*right_pmf" \
623 
    "$vhn = {int \\(Diamond \\*\\)} $hex "
624 
 
625 
gdb_test "print (diamond.*left_pmf) ()" "$vhn = 77"
626 
gdb_test "print (diamond.*right_pmf) ()" "$vhn = 88"
627 
 
628 
# These two point to different methods, although they have the same
629 
# virtual table offsets.
630 
gdb_test "print diamond.*left_vpmf" \
631 
    "$vhn = {int \\(Diamond \\*\\)} $hex "
632 
gdb_test "print diamond.*right_vpmf" \
633 
    "$vhn = {int \\(Diamond \\*\\)} $hex "
634 
 
635 
gdb_test "print (diamond.*left_vpmf) ()" "$vhn = 177"
636 
gdb_test "print (diamond.*left_base_vpmf) ()" "$vhn = 2077"
637 
gdb_test "print (diamond.*right_vpmf) ()" "$vhn = 288"
638 
 
639 
# We should be able to figure out left_vpmf even without an object,
640 
# because it comes from a non-virtual base.  The same for right_vpmf.
641 
gdb_test "print left_vpmf" "$vhn = &virtual Left::vget\\(\\)"
642 
gdb_test "print right_vpmf" "$vhn = &virtual Right::vget\\(\\)"
643 
 
644 
# But we should gracefully fail to figure out base_vpmf, because
645 
# its runtime type is more derived than its static type.  This
646 
# is a valid but unspecified cast (it is value preserving, i.e.
647 
# can be casted back to the correct type and used).
648 
gdb_test "print base_vpmf" \
649 
    "$vhn = &virtual table offset \[0-9\]*, this adjustment -\[0-9\]*"
650 
 
651 
# Make sure we parse this correctly; it's invalid.
652 
gdb_test "print diamond.*left_vpmf ()" \
653 
    "Invalid data type for function to be called\\."
654 
 
655 
# NULL pointer to member tests.
656 
gdb_test "print null_pmi" "$vhn = NULL"
657 
gdb_test "print null_pmi = &A::j" "$vhn = &A::j"
658 
gdb_test "print null_pmi = 0" "$vhn = NULL"
659 
 
660 
gdb_test "print null_pmf" "$vhn = NULL"
661 
gdb_test "print null_pmf = &A::foo" "$vhn = \\(int \\(A::\\*\\)\\(A \\*, int\\)\\) $hex "
662 
gdb_test "print null_pmf = 0" "$vhn = NULL"

powered by: WebSVN 2.1.0

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