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.disasm/] [h8300s.exp] - Blame information for rev 157

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 24 jeremybenn
# Copyright (C) 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 Kazu Hirata. (kazu@hxi.com)
20
 
21
if $tracelevel then {
22
        strace $tracelevel
23
}
24
 
25
if ![istarget "h8300*-*-*"] {
26
    verbose "Tests ignored for all but h8300s based targets."
27
    return
28
}
29
 
30
set prms_id 0
31
set bug_id 0
32
 
33
set testfile "h8300s"
34
set srcfile ${srcdir}/${subdir}/${testfile}.s
35
set binfile ${objdir}/${subdir}/${testfile}
36
if  { [gdb_compile "${srcfile}" "${binfile}" executable {debug additional_flags=-ms}] != "" } {
37
     untested h8300s.exp
38
     return -1
39
}
40
 
41
proc all_set_machine_h8300s { } {
42
    global gdb_prompt
43
    global hex
44
    global decimal
45
 
46
    send_gdb "set machine h8300s\n"
47
    gdb_expect {
48
        -re "$gdb_prompt $" {}
49
    }
50
}
51
 
52
proc all_movb_tests { } {
53
    global gdb_prompt
54
    global hex
55
    global decimal
56
 
57
    send_gdb "x/9i movb_tests\n"
58
    gdb_expect {
59
        -re "
60
.*mov.b\tr0l,r0h.*
61
.*mov.b\t#0x12,r1l.*
62
.*mov.b\t@er0,r1h.*
63
.*mov.b\t@\\(0x1234:16,er0\\),r2l.*
64
.*mov.b\t@\\(0x12345678:32,er0\\),r2h.*
65
.*mov.b\t@er0\\+,r3l.*
66
.*mov.b\t@0x12:8,r3h.*
67
.*mov.b\t@0x1234:16,r4l.*
68
.*mov.b\t@0x12345678:32,r4h.*
69
.*$gdb_prompt $" { pass "movb_tests" }
70
        -re "$gdb_prompt $" { fail "movb_tests" }
71
        timeout { fail "(timeout) movb_tests" }
72
    }
73
}
74
 
75
proc all_movw_tests { } {
76
    global gdb_prompt
77
    global hex
78
    global decimal
79
 
80
    send_gdb "x/8i movw_tests\n"
81
    gdb_expect {
82
        -re "
83
.*mov.w\te0,r0.*
84
.*mov.w\t#0x1234,r1.*
85
.*mov.w\t@er0,r2.*
86
.*mov.w\t@\\(0x1234:16,er0\\),r3.*
87
.*mov.w\t@\\(0x12345678:32,er0\\),r4.*
88
.*mov.w\t@er0\\+,r5.*
89
.*mov.w\t@0x1234:16,r6.*
90
.*mov.w\t@0x12345678:32,r7.*
91
.*$gdb_prompt $" { pass "movw_tests" }
92
        -re "$gdb_prompt $" { fail "movw_tests" }
93
        timeout { fail "(timeout) movw_tests" }
94
    }
95
}
96
 
97
proc all_movl_tests { } {
98
    global gdb_prompt
99
    global hex
100
    global decimal
101
 
102
    send_gdb "x/8i movl_tests\n"
103
    gdb_expect {
104
        -re "
105
.*mov.l\ter0,er1.*
106
.*mov.l\t#0x12345678,er1.*
107
.*mov.l\t@er0,er2.*
108
.*mov.l\t@\\(0x1234:16,er0\\),er3.*
109
.*mov.l\t@\\(0x12345678:32,er0\\),er4.*
110
.*mov.l\t@er0\\+,er5.*
111
.*mov.l\t@0x1234:16,er6.*
112
.*mov.l\t@0x12345678:32,er7.*
113
.*$gdb_prompt $" { pass "movl_tests" }
114
        -re "$gdb_prompt $" { fail "movl_tests" }
115
        timeout { fail "(timeout) movl_tests" }
116
    }
117
}
118
 
119
proc all_ldm_stm_tests { } {
120
    global gdb_prompt
121
    global hex
122
    global decimal
123
 
124
    send_gdb "x/6i ldm_stm_tests\n"
125
    gdb_expect {
126
        -re "
127
.*ldm.l\t@sp\\+,er0-er1.*
128
.*ldm.l\t@sp\\+,er0-er2.*
129
.*ldm.l\t@sp\\+,er0-er3.*
130
.*stm.l\ter0\\-er1,@-sp.*
131
.*stm.l\ter0\\-er2,@-sp.*
132
.*stm.l\ter0\\-er3,@-sp.*
133
.*$gdb_prompt $" { pass "ldm_stm_tests" }
134
        -re "$gdb_prompt $" { fail "ldm_stm_tests" }
135
        timeout { fail "(timeout) ldm_stm_tests" }
136
    }
137
}
138
 
139
proc all_movfpe_movtpe_tests { } {
140
    global gdb_prompt
141
    global hex
142
    global decimal
143
 
144
    send_gdb "x/2i movfpe_movtpe_tests\n"
145
    gdb_expect {
146
        -re "
147
.*movfpe\t@0x1234:16,r2l.*
148
.*movtpe\tr2l,@0x1234:16.*
149
.*$gdb_prompt $" { pass "movfpe_movtpe_tests" }
150
        -re "$gdb_prompt $" { fail "movfpe_movtpe_tests" }
151
        timeout { fail "(timeout) movfpe_movtpe_tests" }
152
    }
153
}
154
 
155
proc all_add_sub_addx_subx_tests { } {
156
    global gdb_prompt
157
    global hex
158
    global decimal
159
 
160
    send_gdb "x/15i add_sub_addx_subx_tests\n"
161
    gdb_expect {
162
        -re "
163
.*add.b\t#0x12,r0l.*
164
.*add.b\tr1l,r1h.*
165
.*add.w\t#0x1234,r2.*
166
.*add.w\tr3,r4.*
167
.*add.l\t#0x12345678,er5.*
168
.*add.l\ter6,er7.*
169
.*sub.b\tr1l,r1h.*
170
.*sub.w\t#0x1234,r2.*
171
.*sub.w\tr3,r4.*
172
.*sub.l\t#0x12345678,er5.*
173
.*sub.l\ter6,er7.*
174
.*addx\t#0x12,r0l.*
175
.*addx\tr1l,r1h.*
176
.*subx\t#0x12,r0l.*
177
.*subx\tr1l,r1h.*
178
.*$gdb_prompt $" { pass "add_sub_addx_subx_tests" }
179
        -re "$gdb_prompt $" { fail "add_sub_addx_subx_tests" }
180
        timeout { fail "(timeout) add_sub_addx_subx_tests" }
181
    }
182
}
183
 
184
proc all_inc_dec_adds_subs_tests { } {
185
    global gdb_prompt
186
    global hex
187
    global decimal
188
 
189
    send_gdb "x/16i inc_dec_adds_subs_tests\n"
190
    gdb_expect {
191
        -re "
192
.*inc(.b|)\tr0l.*
193
.*inc.w\t#(0x|)1,r4.*
194
.*inc.w\t#(0x|)2,r3.*
195
.*inc.l\t#(0x|)1,er2.*
196
.*inc.l\t#(0x|)2,er1.*
197
.*dec.b\tr0l.*
198
.*dec.w\t#(0x|)1,r4.*
199
.*dec.w\t#(0x|)2,r3.*
200
.*dec.l\t#(0x|)1,er2.*
201
.*dec.l\t#(0x|)2,er1.*
202
.*adds\t#(0x|)1,er7.*
203
.*adds\t#(0x|)2,er6.*
204
.*adds\t#(0x|)4,er5.*
205
.*subs\t#(0x|)1,er7.*
206
.*subs\t#(0x|)2,er6.*
207
.*subs\t#(0x|)4,er5.*
208
.*$gdb_prompt $" { pass "inc_dec_adds_subs_tests" }
209
        -re "$gdb_prompt $" { fail "inc_dec_adds_subs_tests" }
210
        timeout { fail "(timeout) inc_dec_adds_subs_tests" }
211
    }
212
}
213
 
214
proc all_daa_das_tests { } {
215
    global gdb_prompt
216
    global hex
217
    global decimal
218
 
219
    send_gdb "x/2i daa_das_tests\n"
220
    gdb_expect {
221
        -re "
222
.*daa\tr0l.*
223
.*das\tr0h.*
224
.*$gdb_prompt $" { pass "daa_das_tests" }
225
        -re "$gdb_prompt $" { fail "daa_das_tests" }
226
        timeout { fail "(timeout) daa_das_tests" }
227
    }
228
}
229
 
230
proc all_mul_div_tests { } {
231
    global gdb_prompt
232
    global hex
233
    global decimal
234
 
235
    send_gdb "x/8i mul_div_tests\n"
236
    gdb_expect {
237
        -re "
238
.*mulxs.b\tr0l,r1.*
239
.*mulxs.w\tr2,er3.*
240
.*mulxu.b\tr0l,e1.*
241
.*mulxu.w\te2,er3.*
242
.*divxs.b\tr0l,r1.*
243
.*divxs.w\tr2,er3.*
244
.*divxu.b\tr0l,e1.*
245
.*divxu.w\te2,er3.*
246
.*$gdb_prompt $" { pass "mul_div_tests" }
247
        -re "$gdb_prompt $" { fail "mul_div_tests" }
248
        timeout { fail "(timeout) mul_div_tests" }
249
    }
250
}
251
 
252
proc all_cmp_tests { } {
253
    global gdb_prompt
254
    global hex
255
    global decimal
256
 
257
    send_gdb "x/8i cmp_tests\n"
258
    gdb_expect {
259
        -re "
260
.*cmp.b\t#0x12,r0l.*
261
.*cmp.b\tr1l,r1h.*
262
.*cmp.w\t#0x1234,r2.*
263
.*cmp.w\tr3,e3.*
264
.*cmp.l\t#0x12345678,er4.*
265
.*cmp.l\ter5,er6.*
266
.*$gdb_prompt $" { pass "cmp_tests" }
267
        -re "$gdb_prompt $" { fail "cmp_tests" }
268
        timeout { fail "(timeout) cmp_tests" }
269
    }
270
}
271
 
272
proc all_neg_tests { } {
273
    global gdb_prompt
274
    global hex
275
    global decimal
276
 
277
    send_gdb "x/3i neg_tests\n"
278
    gdb_expect {
279
        -re "
280
.*neg.b\tr0l.*
281
.*neg.w\tr2.*
282
.*neg.l\ter3.*
283
.*$gdb_prompt $" { pass "neg_tests" }
284
        -re "$gdb_prompt $" { fail "neg_tests" }
285
        timeout { fail "(timeout) neg_tests" }
286
    }
287
}
288
 
289
proc all_ext_tests { } {
290
    global gdb_prompt
291
    global hex
292
    global decimal
293
 
294
    send_gdb "x/4i ext_tests\n"
295
    gdb_expect {
296
        -re "
297
.*exts.w\tr0.*
298
.*exts.l\ter1.*
299
.*extu.w\tr2.*
300
.*extu.l\ter3.*
301
.*$gdb_prompt $" { pass "ext_tests" }
302
        -re "$gdb_prompt $" { fail "ext_tests" }
303
        timeout { fail "(timeout) ext_tests" }
304
    }
305
}
306
 
307
proc all_tas_mac_tests { } {
308
    global gdb_prompt
309
    global hex
310
    global decimal
311
 
312
    send_gdb "x/7i tas_mac_tests\n"
313
    gdb_expect {
314
        -re "
315
.*tas\t@er0.*
316
.*mac\t@er1\\+,@er2\\+.*
317
.*clrmac.*
318
.*ldmac\ter4,mach.*
319
.*ldmac\ter5,macl.*
320
.*stmac\tmach,er6.*
321
.*stmac\tmacl,er7.*
322
.*$gdb_prompt $" { pass "tas_mac_tests" }
323
        -re "$gdb_prompt $" { fail "tas_mac_tests" }
324
        timeout { fail "(timeout) tas_mac_tests" }
325
    }
326
}
327
 
328
proc all_logic_operations_tests { } {
329
    global gdb_prompt
330
    global hex
331
    global decimal
332
 
333
    send_gdb "x/21i logic_operations_tests\n"
334
    gdb_expect {
335
        -re "
336
.*and.b\t#0x12,r0l.*
337
.*and.b\tr1l,r2h.*
338
.*and.w\t#0x1234,r0.*
339
.*and.w\tr1,r2.*
340
.*and.l\t#0x12345678,er0.*
341
.*and.l\ter1,er2.*
342
.*or.b\t#0x12,r0l.*
343
.*or.b\tr1l,r2h.*
344
.*or.w\t#0x1234,r0.*
345
.*or.w\tr1,r2.*
346
.*or.l\t#0x12345678,er0.*
347
.*or.l\ter1,er2.*
348
.*xor(.b|)\t#0x12,r0l.*
349
.*xor(.b|)\tr1l,r2h.*
350
.*xor.w\t#0x1234,r0.*
351
.*xor.w\tr1,r2.*
352
.*xor.l\t#0x12345678,er0.*
353
.*xor.l\ter1,er2.*
354
.*not.b\tr0l.*
355
.*not.w\tr1.*
356
.*not.l\ter2.*
357
.*$gdb_prompt $" { pass "logic_operations_tests" }
358
        -re "$gdb_prompt $" { fail "logic_operations_tests" }
359
        timeout { fail "(timeout) logic_operations_tests" }
360
    }
361
}
362
 
363
proc all_sha_shl_tests { } {
364
    global gdb_prompt
365
    global hex
366
    global decimal
367
 
368
    send_gdb "x/12i sha_shl_tests\n"
369
    gdb_expect {
370
        -re "
371
.*shal(.b|)\tr0l.*
372
.*shal(.w|)\tr1.*
373
.*shal(.l|)\ter2.*
374
.*shar(.b|)\tr3l.*
375
.*shar(.w|)\tr4.*
376
.*shar(.l|)\ter5.*
377
.*shll(.b|)\tr0l.*
378
.*shll(.w|)\tr1.*
379
.*shll(.l|)\ter2.*
380
.*shlr(.b|)\tr3l.*
381
.*shlr(.w|)\tr4.*
382
.*shlr(.l|)\ter5.*
383
.*$gdb_prompt $" { pass "sha_shl_tests" }
384
        -re "$gdb_prompt $" { fail "sha_shl_tests" }
385
        timeout { fail "(timeout) sha_shl_tests" }
386
    }
387
}
388
 
389
proc all_rot_rotx_tests { } {
390
    global gdb_prompt
391
    global hex
392
    global decimal
393
 
394
    send_gdb "x/12i rot_rotx_tests\n"
395
    gdb_expect {
396
        -re "
397
.*rotl(.b|)\tr0l.*
398
.*rotl(.w|)\tr1.*
399
.*rotl(.l|)\ter2.*
400
.*rotr(.b|)\tr3l.*
401
.*rotr(.w|)\tr4.*
402
.*rotr(.l|)\ter5.*
403
.*rotxl(.b|)\tr0l.*
404
.*rotxl(.w|)\tr1.*
405
.*rotxl(.l|)\ter2.*
406
.*rotxr(.b|)\tr3l.*
407
.*rotxr(.w|)\tr4.*
408
.*rotxr(.l|)\ter5.*
409
.*$gdb_prompt $" { pass "rot_rotx_tests" }
410
        -re "$gdb_prompt $" { fail "rot_rotx_tests" }
411
        timeout { fail "(timeout) rot_rotx_tests" }
412
    }
413
}
414
 
415
proc all_bset_bclr_tests { } {
416
    global gdb_prompt
417
    global hex
418
    global decimal
419
 
420
    send_gdb "x/20i bset_bclr_tests\n"
421
    gdb_expect {
422
        -re "
423
.*bset\t#0x7,r0l.*
424
.*bset\t#0x6,@er1.*
425
.*bset\t#0x5,@0x12:8.*
426
.*bset\t#0x4,@0x1234:16.*
427
.*bset\t#0x3,@0x12345678:32.*
428
.*bset\tr7l,r0h.*
429
.*bset\tr6l,@er1.*
430
.*bset\tr5l,@0x12:8.*
431
.*bset\tr4l,@0x1234:16.*
432
.*bset\tr3l,@0x12345678:32.*
433
.*bclr\t#0x7,r0l.*
434
.*bclr\t#0x6,@er1.*
435
.*bclr\t#0x5,@0x12:8.*
436
.*bclr\t#0x4,@0x1234:16.*
437
.*bclr\t#0x3,@0x12345678:32.*
438
.*bclr\tr7h,r0h.*
439
.*bclr\tr6h,@er1.*
440
.*bclr\tr5h,@0x12:8.*
441
.*bclr\tr4h,@0x1234:16.*
442
.*bclr\tr3h,@0x12345678:32.*
443
.*$gdb_prompt $" { pass "bset_bclr_tests" }
444
        -re "$gdb_prompt $" { fail "bset_bclr_tests" }
445
        timeout { fail "(timeout) bset_bclr_tests" }
446
    }
447
}
448
 
449
proc all_bnot_btst_tests { } {
450
    global gdb_prompt
451
    global hex
452
    global decimal
453
 
454
    send_gdb "x/20i bnot_btst_tests\n"
455
    gdb_expect {
456
        -re "
457
.*bnot\t#0x7,r0l.*
458
.*bnot\t#0x6,@er1.*
459
.*bnot\t#0x5,@0x12:8.*
460
.*bnot\t#0x4,@0x1234:16.*
461
.*bnot\t#0x3,@0x12345678:32.*
462
.*bnot\tr7l,r0h.*
463
.*bnot\tr6l,@er1.*
464
.*bnot\tr5l,@0x12:8.*
465
.*bnot\tr4l,@0x1234:16.*
466
.*bnot\tr3l,@0x12345678:32.*
467
.*btst\t#0x7,r0l.*
468
.*btst\t#0x6,@er1.*
469
.*btst\t#0x5,@0x12:8.*
470
.*btst\t#0x4,@0x1234:16.*
471
.*btst\t#0x3,@0x12345678:32.*
472
.*btst\tr7h,r0h.*
473
.*btst\tr6h,@er1.*
474
.*btst\tr5h,@0x12:8.*
475
.*btst\tr4h,@0x1234:16.*
476
.*btst\tr3h,@0x12345678:32.*
477
.*$gdb_prompt $" { pass "bnot_btst_tests" }
478
        -re "$gdb_prompt $" { fail "bnot_btst_tests" }
479
        timeout { fail "(timeout) bnot_btst_tests" }
480
    }
481
}
482
 
483
proc all_band_bor_bxor_tests { } {
484
    global gdb_prompt
485
    global hex
486
    global decimal
487
 
488
    send_gdb "x/15i band_bor_bxor_tests\n"
489
    gdb_expect {
490
        -re "
491
.*band\t#0x7,r0l.*
492
.*band\t#0x6,@er1.*
493
.*band\t#0x5,@0x12:8.*
494
.*band\t#0x4,@0x1234:16.*
495
.*band\t#0x3,@0x12345678:32.*
496
.*bor\t#0x7,r0l.*
497
.*bor\t#0x6,@er1.*
498
.*bor\t#0x5,@0x12:8.*
499
.*bor\t#0x4,@0x1234:16.*
500
.*bor\t#0x3,@0x12345678:32.*
501
.*bxor\t#0x7,r0l.*
502
.*bxor\t#0x6,@er1.*
503
.*bxor\t#0x5,@0x12:8.*
504
.*bxor\t#0x4,@0x1234:16.*
505
.*bxor\t#0x3,@0x12345678:32.*
506
.*$gdb_prompt $" { pass "band_bor_bxor_tests" }
507
        -re "$gdb_prompt $" { fail "band_bor_bxor_tests" }
508
        timeout { fail "(timeout) band_bor_bxor_tests" }
509
    }
510
}
511
 
512
proc all_bld_bst_tests { } {
513
    global gdb_prompt
514
    global hex
515
    global decimal
516
 
517
    send_gdb "x/20i bld_bst_tests\n"
518
    gdb_expect {
519
        -re "
520
.*bld\t#0x7,r0l.*
521
.*bld\t#0x6,@er1.*
522
.*bld\t#0x5,@0x12:8.*
523
.*bld\t#0x4,@0x1234:16.*
524
.*bld\t#0x3,@0x12345678:32.*
525
.*bild\t#0x7,r0l.*
526
.*bild\t#0x6,@er1.*
527
.*bild\t#0x5,@0x12:8.*
528
.*bild\t#0x4,@0x1234:16.*
529
.*bild\t#0x3,@0x12345678:32.*
530
.*bst\t#0x7,r0l.*
531
.*bst\t#0x6,@er1.*
532
.*bst\t#0x5,@0x12:8.*
533
.*bst\t#0x4,@0x1234:16.*
534
.*bst\t#0x3,@0x12345678:32.*
535
.*bist\t#0x7,r0l.*
536
.*bist\t#0x6,@er1.*
537
.*bist\t#0x5,@0x12:8.*
538
.*bist\t#0x4,@0x1234:16.*
539
.*bist\t#0x3,@0x12345678:32.*
540
.*$gdb_prompt $" { pass "bld_bst_tests" }
541
        -re "$gdb_prompt $" { fail "bld_bst_tests" }
542
        timeout { fail "(timeout) bld_bst_tests" }
543
    }
544
}
545
 
546
proc all_branch_tests { } {
547
    global gdb_prompt
548
    global hex
549
    global decimal
550
 
551
    send_gdb "x/25i branch_tests\n"
552
    gdb_expect {
553
        -re "
554
.*bra\t(branch_tests|.-2 ).*
555
.*brn\t(branch_tests|.-4 ).*
556
.*bhi\t(branch_tests|.-6 ).*
557
.*bls\t(branch_tests|.-8 ).*
558
.*bcc\t(branch_tests|.-10 ).*
559
.*bcs\t(branch_tests|.-12 ).*
560
.*bne\t(branch_tests|.-14 ).*
561
.*beq\t(branch_tests|.-16 ).*
562
.*bvc\t(branch_tests|.-18 ).*
563
.*bvs\t(branch_tests|.-20 ).*
564
.*bpl\t(branch_tests|.-22 ).*
565
.*bmi\t(branch_tests|.-24 ).*
566
.*bge\t(branch_tests|.-26 ).*
567
.*blt\t(branch_tests|.-28 ).*
568
.*bgt\t(branch_tests|.-30 ).*
569
.*ble\t(branch_tests|.-32 ).*
570
.*jmp\t@er0.*
571
.*jmp\t@(branch_tests|0x).*
572
.*jmp\t@@0 \\((0x|)0\\).*
573
.*bsr\t(branch_tests|.-42 ).*
574
.*bsr\t(branch_tests|.-46 ).*
575
.*jsr\t@er0.*
576
.*jsr\t@(branch_tests|0x).*
577
.*jsr\t@@0 \\((0x|)0\\).*
578
.*rts.*
579
.*$gdb_prompt $" { pass "branch_tests" }
580
        -re "$gdb_prompt $" { fail "branch_tests" }
581
        timeout { fail "(timeout) branch_tests" }
582
    }
583
}
584
 
585
proc all_system_control_tests { } {
586
    global gdb_prompt
587
    global hex
588
    global decimal
589
 
590
    send_gdb "x/40i system_control_tests\n"
591
    gdb_expect {
592
        -re "
593
.*trapa\t#0x2.*
594
.*rte.*
595
.*sleep.*
596
.*ldc\t#0x12,ccr*.
597
.*ldc\tr3l,ccr.*
598
.*ldc\t@er0,ccr.*
599
.*ldc\t@\\(0x1234:16,er0\\),ccr.*
600
.*ldc\t@\\(0x12345678:32,er0\\),ccr.*
601
.*ldc\t@er1\\+,ccr.*
602
.*ldc\t@0x1234:16,ccr.*
603
.*ldc\t@0x12345678:32,ccr.*
604
.*stc\tccr,r3l.*
605
.*stc\tccr,@er0.*
606
.*stc\tccr,@\\(0x1234:16,er0\\).*
607
.*stc\tccr,@\\(0x12345678:32,er0\\).*
608
.*stc\tccr,@\\-er1.*
609
.*stc\tccr,@0x1234:16.*
610
.*stc\tccr,@0x12345678:32.*
611
.*andc\t#0x12,ccr.*
612
.*orc\t#0x34,ccr.*
613
.*xorc\t#0x56,ccr.*
614
.*ldc\t#0x12,exr*.
615
.*ldc\tr3l,exr.*
616
.*ldc\t@er0,exr.*
617
.*ldc\t@\\(0x1234:16,er0\\),exr.*
618
.*ldc\t@\\(0x12345678:32,er0\\),exr.*
619
.*ldc\t@er1\\+,exr.*
620
.*ldc\t@0x1234:16,exr.*
621
.*ldc\t@0x12345678:32,exr.*
622
.*stc\texr,r3l.*
623
.*stc\texr,@er0.*
624
.*stc\texr,@\\(0x1234:16,er0\\).*
625
.*stc\texr,@\\(0x12345678:32,er0\\).*
626
.*stc\texr,@\\-er1.*
627
.*stc\texr,@0x1234:16.*
628
.*stc\texr,@0x12345678:32.*
629
.*andc\t#0x12,exr.*
630
.*orc\t#0x34,exr.*
631
.*xorc\t#0x56,exr.*
632
.*nop.*
633
.*$gdb_prompt $" { pass "system_control_tests" }
634
        -re "$gdb_prompt $" { fail "system_control_tests" }
635
        timeout { fail "(timeout) system_control_tests" }
636
    }
637
}
638
 
639
proc all_block_data_transfer_tests { } {
640
    global gdb_prompt
641
    global hex
642
    global decimal
643
 
644
    send_gdb "x/2i block_data_transfer_tests\n"
645
    gdb_expect {
646
        -re "
647
.*eepmov.b.*
648
.*eepmov.w.*
649
.*$gdb_prompt $" { pass "block_data_transfer_tests" }
650
        -re "$gdb_prompt $" { fail "block_data_transfer_tests" }
651
        timeout { fail "(timeout) block_data_transfer_tests" }
652
    }
653
}
654
 
655
gdb_exit
656
gdb_start
657
gdb_reinitialize_dir $srcdir/$subdir
658
all_set_machine_h8300s
659
gdb_load $binfile
660
 
661
# Data transfer
662
all_movb_tests
663
all_movw_tests
664
all_movl_tests
665
all_ldm_stm_tests
666
all_movfpe_movtpe_tests
667
 
668
# Arithmetic operations
669
all_add_sub_addx_subx_tests
670
all_inc_dec_adds_subs_tests
671
all_daa_das_tests
672
all_mul_div_tests
673
all_cmp_tests
674
all_neg_tests
675
all_ext_tests
676
all_tas_mac_tests
677
 
678
# Logic operations
679
all_logic_operations_tests
680
 
681
# Shift
682
all_sha_shl_tests
683
all_rot_rotx_tests
684
 
685
# Bit manipulation
686
all_bset_bclr_tests
687
all_bnot_btst_tests
688
all_band_bor_bxor_tests
689
all_bld_bst_tests
690
 
691
# Branch
692
all_branch_tests
693
 
694
# System control
695
all_system_control_tests
696
 
697
# Block data transfer
698
all_block_data_transfer_tests

powered by: WebSVN 2.1.0

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