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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [gdb/] [testsuite/] [gdb.base/] [pointers.exp] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
# Copyright 1998, 1999, 2000, 2007, 2008 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 3 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, see .
15
 
16
# Please email any bugs, comments, and/or additions to this file to:
17
# bug-gdb@prep.ai.mit.edu
18
 
19
# This file was written by Elena Zannoni (ezannoni@cygnus.com)
20
 
21
# This file is part of the gdb testsuite
22
#
23
# tests for pointer arithmetic and pointer dereferencing
24
# with integer type variables and pointers to integers
25
#
26
 
27
if $tracelevel then {
28
        strace $tracelevel
29
        }
30
 
31
#
32
# test running programs
33
#
34
set prms_id 0
35
set bug_id 0
36
 
37
set testfile "pointers"
38
set srcfile ${testfile}.c
39
set binfile ${objdir}/${subdir}/${testfile}
40
 
41
if  { [gdb_compile "${srcdir}/${subdir}/${srcfile}" "${binfile}" executable {debug nowarnings}] != "" } {
42
     untested pointers.exp
43
     return -1
44
    }
45
 
46
if [get_compiler_info ${binfile}] {
47
    return -1;
48
}
49
 
50
gdb_exit
51
gdb_start
52
gdb_reinitialize_dir $srcdir/$subdir
53
gdb_load ${binfile}
54
 
55
 
56
#
57
# set it up at a breakpoint so we can play with the variable values
58
#
59
 
60
if ![runto_main] then {
61
    perror "couldn't run to breakpoint"
62
    continue
63
}
64
 
65
gdb_test "next " "more_code.*;" "continuing after dummy()"
66
 
67
 
68
#
69
# let's see if gdb catches some illegal operations on pointers
70
#
71
# I must comment these out because strict type checking is not
72
# supported in this version of GDB. I do not really know
73
# what the expected gdb reply is.
74
#
75
 
76
#send_gdb "print v_int_pointer2 = &v_int_pointer\n"
77
#gdb_expect {
78
#    -re ".*.*$gdb_prompt $" {
79
#        pass "illegal pointer assignment rejected"
80
#      }
81
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
82
#    timeout           { fail "(timeout) illegal pointer assignment rejected" }
83
#  }
84
 
85
 
86
#send_gdb "print v_unsigned_int_pointer = &v_int\n"
87
#gdb_expect {
88
#    -re ".*.*$gdb_prompt $" {
89
#        pass "illegal pointer assignment rejected"
90
#      }
91
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
92
#    timeout           { fail "(timeout) ilegal pointer assignment rejected" }
93
#  }
94
 
95
#send_gdb "print v_unsigned_int_pointer == v_double_pointer\n"
96
#gdb_expect {
97
#    -re ".*.*$gdb_prompt $" {
98
#        pass "illegal pointer operation (+) rejected"
99
#      }
100
#    -re ".*$gdb_prompt $" { fail "illegal pointer operation (+) rejected" }
101
#    timeout           { fail "(timeout) illegal pointer operation (+) rejected" }
102
#  }
103
 
104
 
105
#send_gdb "print v_unsigned_int_pointer * v_double_pointer\n"
106
#gdb_expect {
107
#    -re ".*Argument to arithmetic operation not a number or boolean.*$gdb_prompt $" {
108
#        pass "illegal pointer operation (*) rejected"
109
#      }
110
#    -re ".*$gdb_prompt $" { fail "illegal pointer operation (*) rejected" }
111
#    timeout           { fail "(timeout) illegal pointer operation (*) rejected" }
112
#  }
113
 
114
 
115
#send_gdb "print v_unsigned_int_pointer = v_double_pointer\n"
116
#gdb_expect {
117
#    -re ".*.*$gdb_prompt $" {
118
#        pass "ilegal pointer assignment rejected"
119
#      }
120
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
121
#    timeout           { fail "(timeout) illegal pointer assignment rejected" }
122
#  }
123
 
124
 
125
#send_gdb "print v_unsigned_int_pointer = v_unsigned_int\n"
126
#gdb_expect {
127
#    -re ".*.*$gdb_prompt $" {
128
#        pass "illegal pointer assignment rejected"
129
#      }
130
#    -re ".*$gdb_prompt $" { fail "illegal pointer assignment rejected" }
131
#    timeout           { fail "(timeout) illegal pointer assignment rejected" }
132
#  }
133
 
134
gdb_test "set variable v_int_pointer=&v_int_array\[0\]" "" "set pointer to beginning of array"
135
gdb_test "set variable v_int_pointer2=&v_int_array\[1\]" "" "set pointer to end of array"
136
 
137
 
138
send_gdb "print *v_int_pointer\n"
139
gdb_expect {
140
    -re ".*= 6.*$gdb_prompt $" {
141
        pass "print object pointed to"
142
      }
143
    -re ".*$gdb_prompt $" { fail "print object pointed to" }
144
    timeout           { fail "(timeout) print object pointed to" }
145
  }
146
 
147
send_gdb "print *v_int_pointer2\n"
148
gdb_expect {
149
    -re ".*= 18.*$gdb_prompt $" {
150
        pass "print object pointed to"
151
      }
152
    -re ".*$gdb_prompt $" { fail "print object pointed to" }
153
    timeout           { fail "(timeout) print object pointed to" }
154
  }
155
 
156
 
157
send_gdb "print v_int_pointer == v_int_pointer2\n"
158
gdb_expect {
159
    -re ".*= $false.*$gdb_prompt $" {
160
        pass "pointer1==pointer2"
161
      }
162
    -re ".*$gdb_prompt $" { fail "pointer1==pointer2" }
163
    timeout           { fail "(timeout) pointer1==pointer2" }
164
  }
165
 
166
send_gdb "print v_int_pointer != v_int_pointer2\n"
167
gdb_expect {
168
    -re ".*= $true.*$gdb_prompt $" {
169
        pass "pointer1!=pointer2"
170
      }
171
    -re ".*$gdb_prompt $" { fail "pointer1!=pointer2" }
172
    timeout           { fail "(timeout) pointer1!=pointer2" }
173
  }
174
 
175
 
176
send_gdb "print v_int_pointer <= v_int_pointer2\n"
177
gdb_expect {
178
    -re ".*= $true.*$gdb_prompt $" {
179
        pass "pointer1<=pointer2"
180
      }
181
    -re ".*$gdb_prompt $" { fail "pointer1<=pointer2" }
182
    timeout           { fail "(timeout) pointer1<=pointer2" }
183
  }
184
 
185
 
186
send_gdb "print v_int_pointer >= v_int_pointer2\n"
187
gdb_expect {
188
    -re ".*= $false.*$gdb_prompt $" {
189
        pass "pointer1>=pointer2"
190
      }
191
    -re ".*$gdb_prompt $" { fail "pointer1>=pointer2" }
192
    timeout           { fail "(timeout) pointer1>=pointer2" }
193
  }
194
 
195
 
196
send_gdb "print v_int_pointer < v_int_pointer2\n"
197
gdb_expect {
198
    -re ".*= $true.*$gdb_prompt $" {
199
        pass "pointer1
200
      }
201
    -re ".*$gdb_prompt $" { fail "pointer1
202
    timeout           { fail "(timeout) pointer1
203
  }
204
 
205
send_gdb "print v_int_pointer > v_int_pointer2\n"
206
gdb_expect {
207
    -re ".*= $false.*$gdb_prompt $" {
208
        pass "pointer1>pointer2"
209
      }
210
    -re ".*$gdb_prompt $" { fail "pointer1>pointer2" }
211
    timeout           { fail "(timeout) pointer1>pointer2" }
212
  }
213
 
214
 
215
gdb_test "set variable y = *v_int_pointer++" "" "set y = *v_int_pointer++"
216
send_gdb "print y\n"
217
gdb_expect {
218
    -re ".*= 6.*$gdb_prompt $" {
219
        send_gdb "print *v_int_pointer\n"
220
        gdb_expect {
221
             -re ".*= 18.*$gdb_prompt $" {
222
                 pass "pointer assignment and increment"
223
               }
224
             -re ".*$gdb_prompt $" { fail "pointer assignment and increment" }
225
             timeout           { fail "(timeout) pointer assignment and increment" }
226
         }
227
         }
228
    -re ".*$gdb_prompt $" { fail "pointer assignment and increment" }
229
    timeout           { fail "(timeout) pointer assignment and increment" }
230
  }
231
 
232
 
233
 
234
 
235
gdb_test "set variable y = *--v_int_pointer2" "" "set y = *--v_int_pointer2"
236
send_gdb "print y\n"
237
gdb_expect {
238
    -re ".*= 6.*$gdb_prompt $" {
239
        send_gdb "print *v_int_pointer2\n"
240
        gdb_expect {
241
             -re ".*= 6.*$gdb_prompt $" {
242
                 pass "pointer decrement and assignment"
243
               }
244
             -re ".*$gdb_prompt $" { fail "pointer decrement and assignment" }
245
             timeout           { fail "(timeout) pointer decrement and assignment" }
246
         }
247
         }
248
    -re ".*$gdb_prompt $" { fail "pointer decrement and assignment" }
249
    timeout           { fail "(timeout) pointer decrement and assignment" }
250
  }
251
 
252
gdb_test "set variable y =v_int_pointer-v_int_pointer2" "" "set y =v_int_pointer-v_int_pointer2"
253
send_gdb "print y\n"
254
gdb_expect {
255
    -re ".*= 1.*$gdb_prompt $" {
256
        pass "pointer1-pointer2"
257
      }
258
    -re ".*$gdb_prompt $" { fail "pointer1-pointer2" }
259
    timeout           { fail "(timeout) pointer1-pointer2" }
260
  }
261
 
262
gdb_test "set variable v_int_pointer=v_int_array" "" "set v_int_pointer=v_int_array"
263
send_gdb "print *v_int_pointer\n"
264
gdb_expect {
265
    -re ".*= 6.*$gdb_prompt $" {
266
        pass "print array element through pointer"
267
      }
268
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
269
    timeout           { fail "(timeout) print array element through pointer" }
270
  }
271
 
272
 
273
send_gdb "print *(v_int_pointer+1)\n"
274
gdb_expect {
275
    -re ".*= 18.*$gdb_prompt $" {
276
        pass "print array element through pointer"
277
      }
278
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
279
    timeout           { fail "(timeout) print array element through pointer" }
280
  }
281
 
282
# test print elements of array through pointers
283
 
284
send_gdb "print (*rptr)\[0\]\n"
285
gdb_expect {
286
    -re ".*= 0.*$gdb_prompt $" {
287
        pass "print array element through pointer"
288
      }
289
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
290
    timeout           { fail "(timeout) print array element through pointer" }
291
  }
292
 
293
send_gdb "print (*rptr)\[1\]\n"
294
gdb_expect {
295
    -re ".*= 1.*$gdb_prompt $" {
296
        pass "print array element through pointer"
297
      }
298
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
299
    timeout           { fail "(timeout) print array element through pointer" }
300
  }
301
 
302
 
303
send_gdb "print (*rptr)\[2\]\n"
304
gdb_expect {
305
    -re ".*= 2.*$gdb_prompt $" {
306
        pass "print array element through pointer"
307
      }
308
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
309
    timeout           { fail "(timeout) print array element through pointer" }
310
  }
311
 
312
gdb_test "set variable rptr = rptr+1" "" "increment rptr"
313
 
314
send_gdb "print (*rptr)\[0\]\n"
315
gdb_expect {
316
    -re ".*= 3.*$gdb_prompt $" {
317
        pass "print array element through pointer"
318
      }
319
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
320
    timeout           { fail "(timeout) print array element through pointer" }
321
  }
322
 
323
 
324
send_gdb "print (*rptr)\[1\]\n"
325
gdb_expect {
326
    -re ".*= 4.*$gdb_prompt $" {
327
        pass "print array element through pointer"
328
      }
329
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
330
    timeout           { fail "(timeout) print array element through pointer" }
331
  }
332
 
333
 
334
send_gdb "print (*rptr)\[2\]\n"
335
gdb_expect {
336
    -re ".*= 5.*$gdb_prompt $" {
337
        pass "print array element through pointer"
338
      }
339
    -re ".*$gdb_prompt $" { fail "print array element through pointer" }
340
    timeout           { fail "(timeout) print array element through pointer" }
341
  }
342
 
343
 
344
send_gdb "print *( *(matrix+1) +2)\n"
345
gdb_expect {
346
    -re ".*= 5.*$gdb_prompt $" {
347
        pass "print array element w/ pointer arithmetic"
348
      }
349
    -re ".*$gdb_prompt $" { fail "print array element w/ pointer arithemtic" }
350
    timeout           { fail "(timeout) print array element w/ pointer arithmetic" }
351
  }
352
 
353
 
354
send_gdb "print **ptr_to_ptr_to_float\n"
355
gdb_expect {
356
    -re ".*= 100.*$gdb_prompt $" {
357
        pass "print through ptr to ptr"
358
      }
359
    -re ".*$gdb_prompt $" { fail "print through ptr to ptr" }
360
    timeout           { fail "(timeout) print through ptr to ptr" }
361
  }
362
 
363
# tests for pointers
364
# with elementary type variables and pointers.
365
#
366
 
367
send_gdb "break marker1\n" ; gdb_expect -re ".*$gdb_prompt $"
368
 
369
send_gdb "cont\n"
370
gdb_expect {
371
    -re "Break.* marker1 \\(\\) at .*:$decimal.*$gdb_prompt $" {
372
        pass "continue to marker1"
373
        send_gdb "up\n"
374
        gdb_expect {
375
            -re ".*more_code.*$gdb_prompt $" {
376
                pass "up from marker1"
377
            }
378
            -re ".*$gdb_prompt $" {
379
                fail "up from marker1"
380
            }
381
            timeout { fail "up from marker1 (timeout)" }
382
        }
383
    }
384
    -re "$gdb_prompt $" {
385
        fail "continue to marker1"
386
    }
387
    timeout {
388
        fail "continue to marker1 (timeout)"
389
    }
390
}
391
 
392
 
393
send_gdb "print *pUC\n"
394
gdb_expect {
395
    -re ".\[0-9\]* = 21 \'.025\'.*$gdb_prompt $" {
396
        pass "print value of *pUC"
397
      }
398
    -re ".*$gdb_prompt $" { fail "print value of *pUC" }
399
    timeout           { fail "(timeout) print value of *pUC" }
400
  }
401
 
402
 
403
send_gdb "ptype pUC\n"
404
gdb_expect {
405
    -re "type = unsigned char \\*.*$gdb_prompt $"  { pass "ptype pUC" }
406
    -re ".*$gdb_prompt $"   {  fail "ptype pUC" }
407
    timeout             { fail "(timeout) ptype pUC" }
408
}
409
 
410
send_gdb "print *pS\n"
411
gdb_expect {
412
    -re ".\[0-9\]* = -14.*$gdb_prompt $" {
413
        pass "print value of *pS"
414
      }
415
    -re ".*$gdb_prompt $" { fail "print value of *pS" }
416
    timeout           { fail "(timeout) print value of *pS" }
417
  }
418
 
419
 
420
send_gdb "ptype pS\n"
421
gdb_expect {
422
    -re "type = short \\*.*$gdb_prompt $"  { pass "ptype pS" }
423
    -re "type = short int \\*.*$gdb_prompt $"  { pass "ptype pS" }
424
    -re ".*$gdb_prompt $"   {  fail "ptype pS" }
425
    timeout             { fail "(timeout) ptype pS" }
426
}
427
 
428
send_gdb "print *pUS\n"
429
gdb_expect {
430
    -re ".\[0-9\]* = 7.*$gdb_prompt $" {
431
        pass "print value of *pUS"
432
      }
433
    -re ".*$gdb_prompt $" { fail "print value of *pUS" }
434
    timeout           { fail "(timeout) print value of *pUS" }
435
  }
436
 
437
 
438
send_gdb "ptype pUS\n"
439
gdb_expect {
440
    -re "type = unsigned short \\*.*$gdb_prompt $"  { pass "ptype pUS" }
441
    -re "type = short unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUS" }
442
    -re ".*$gdb_prompt $"   {  fail "ptype pUS" }
443
    timeout             { fail "(timeout) ptype pUS" }
444
}
445
 
446
send_gdb "print *pI\n"
447
gdb_expect {
448
    -re ".\[0-9\]* = 102.*$gdb_prompt $" {
449
        pass "print value of *pI"
450
      }
451
    -re ".*$gdb_prompt $" { fail "print value of *pI" }
452
    timeout           { fail "(timeout) print value of *pI" }
453
  }
454
 
455
 
456
send_gdb "ptype pI\n"
457
gdb_expect {
458
    -re "type = int \\*.*$gdb_prompt $"  { pass "ptype pI" }
459
    -re ".*$gdb_prompt $"   {  fail "ptype pI" }
460
    timeout             { fail "(timeout) ptype pI" }
461
}
462
 
463
send_gdb "print *pUI\n"
464
gdb_expect {
465
    -re ".\[0-9\]* = 1002.*$gdb_prompt $" {
466
        pass "print value of *pUI"
467
      }
468
    -re ".*$gdb_prompt $" { fail "print value of *pUI" }
469
    timeout           { fail "(timeout) print value of *pUI" }
470
  }
471
 
472
 
473
send_gdb "ptype pUI\n"
474
gdb_expect {
475
    -re "type = unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUI" }
476
    -re ".*$gdb_prompt $"   {  fail "ptype pUI" }
477
    timeout             { fail "(timeout) ptype pUI" }
478
}
479
 
480
send_gdb "print *pL\n"
481
gdb_expect {
482
    -re ".\[0-9\]* = -234.*$gdb_prompt $" {
483
        pass "print value of *pL"
484
      }
485
    -re ".*$gdb_prompt $" { fail "print value of *pL" }
486
    timeout           { fail "(timeout) print value of *pL" }
487
  }
488
 
489
 
490
send_gdb "ptype pL\n"
491
gdb_expect {
492
    -re "type = long \\*.*$gdb_prompt $"  { pass "ptype pL" }
493
    -re "type = long int \\*.*$gdb_prompt $"  { pass "ptype pL" }
494
    -re ".*$gdb_prompt $"   {  fail "ptype pL" }
495
    timeout             { fail "(timeout) ptype pL" }
496
}
497
 
498
send_gdb "print *pUL\n"
499
gdb_expect {
500
    -re ".\[0-9\]* = 234.*$gdb_prompt $" {
501
        pass "print value of *pUL"
502
      }
503
    -re ".*$gdb_prompt $" { fail "print value of *pUL" }
504
    timeout           { fail "(timeout) print value of *pUL" }
505
  }
506
 
507
 
508
send_gdb "ptype pUL\n"
509
gdb_expect {
510
    -re "type = unsigned long \\*.*$gdb_prompt $"  { pass "ptype pUL" }
511
    -re "type = long unsigned int \\*.*$gdb_prompt $"  { pass "ptype pUL" }
512
    -re ".*$gdb_prompt $"   {  fail "ptype pUL" }
513
    timeout             { fail "(timeout) ptype pUL" }
514
}
515
 
516
send_gdb "print *pF\n"
517
gdb_expect {
518
    -re ".\[0-9\]* = 1.2\[0-9\]*e\\+10.*$gdb_prompt $" {
519
        pass "print value of *pF"
520
      }
521
    -re ".*$gdb_prompt $" { fail "print value of *pF" }
522
    timeout           { fail "(timeout) print value of *pF" }
523
  }
524
 
525
 
526
send_gdb "ptype pF\n"
527
gdb_expect {
528
    -re "type = float \\*.*$gdb_prompt $"  { pass "ptype pF" }
529
    -re ".*$gdb_prompt $"   {  fail "ptype pF" }
530
    timeout             { fail "(timeout) ptype pF" }
531
}
532
 
533
send_gdb "print *pD\n"
534
gdb_expect {
535
    -re ".\[0-9\]* = -1.2\[0-9\]*e\\-37.*$gdb_prompt $" {
536
        pass "print value of *pD"
537
      }
538
    -re ".*$gdb_prompt $" { fail "print value of *pD" }
539
    timeout           { fail "(timeout) print value of *pD" }
540
  }
541
 
542
 
543
send_gdb "ptype pD\n"
544
gdb_expect {
545
    -re "type = double \\*.*$gdb_prompt $"  { pass "ptype pD" }
546
    -re ".*$gdb_prompt $"   {  fail "ptype pD" }
547
    timeout             { fail "(timeout) ptype pD" }
548
}
549
 
550
send_gdb "print ******ppppppC\n"
551
gdb_expect {
552
    -re ".\[0-9\]* = 65 \'A\'.*$gdb_prompt $" {
553
        pass "print value of ******ppppppC"
554
      }
555
    -re ".*$gdb_prompt $" { fail "print value of ******ppppppC" }
556
    timeout           { fail "(timeout) print value of ******ppppppC" }
557
  }
558
 
559
 
560
send_gdb "ptype pC\n"
561
gdb_expect {
562
    -re "type = char \\*.*$gdb_prompt $"  { pass "ptype pC" }
563
    -re ".*$gdb_prompt $"   {  fail "ptype pC" }
564
    timeout             { fail "(timeout) ptype pC" }
565
}
566
 
567
send_gdb "ptype ppC\n"
568
gdb_expect {
569
    -re "type = char \\*\\*.*$gdb_prompt $"  { pass "ptype ppC" }
570
    -re ".*$gdb_prompt $"   {  fail "ptype ppC" }
571
    timeout             { fail "(timeout) ptype ppC" }
572
}
573
 
574
send_gdb "ptype pppC\n"
575
gdb_expect {
576
    -re "type = char \\*\\*\\*.*$gdb_prompt $"  { pass "ptype pppC" }
577
    -re ".*$gdb_prompt $"   {  fail "ptype pppC" }
578
    timeout             { fail "(timeout) ptype pppC" }
579
}
580
 
581
send_gdb "ptype ppppC\n"
582
gdb_expect {
583
    -re "type = char \\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype ppppC" }
584
    -re ".*$gdb_prompt $"   {  fail "ptype ppppC" }
585
    timeout             { fail "(timeout) ptype ppppC" }
586
}
587
 
588
send_gdb "ptype pppppC\n"
589
gdb_expect {
590
    -re "type = char \\*\\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype pppppC" }
591
    -re ".*$gdb_prompt $"   {  fail "ptype pppppC" }
592
    timeout             { fail "(timeout) ptype pppppC" }
593
}
594
 
595
send_gdb "ptype ppppppC\n"
596
gdb_expect {
597
    -re "type = char \\*\\*\\*\\*\\*\\*.*$gdb_prompt $"  { pass "ptype ppppppC" }
598
    -re ".*$gdb_prompt $"   {  fail "ptype ppppppC" }
599
    timeout             { fail "(timeout) ptype ppppppC" }
600
}
601
 

powered by: WebSVN 2.1.0

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