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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [gdb/] [testsuite/] [gdb.disasm/] [mn10200.exp] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman
 
2
# Copyright 1997 Free Software Foundation, Inc.
3
 
4
# This program is free software; you can redistribute it and/or modify
5
# it under the terms of the GNU General Public License as published by
6
# the Free Software Foundation; either version 2 of the License, or
7
# (at your option) any later version.
8
#
9
# This program is distributed in the hope that it will be useful,
10
# but WITHOUT ANY WARRANTY; without even the implied warranty of
11
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12
# GNU General Public License for more details.
13
#
14
# You should have received a copy of the GNU General Public License
15
# along with this program; if not, write to the Free Software
16
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17
 
18
# Please email any bugs, comments, and/or additions to this file to:
19
# bug-gdb@prep.ai.mit.edu
20
 
21
# This file was written by Jeff Law. (law@cygnus.com)
22
 
23
if $tracelevel then {
24
        strace $tracelevel
25
}
26
 
27
if ![istarget "mn10200*-*-*"] {
28
    verbose "Tests ignored for all but mn10200 based targets."
29
    return
30
}
31
 
32
global exec_output
33
set prms_id 0
34
set bug_id 0
35
 
36
set testfile "mn10200"
37
set srcfile ${srcdir}/${subdir}/${testfile}.s
38
set binfile ${objdir}/${subdir}/${testfile}
39
if  { [gdb_compile "${srcfile}" "${binfile}" executable ""] != "" } {
40
     gdb_suppress_entire_file "Testcase compile failed, so all tests in this file will automatically fail."
41
}
42
 
43
proc add_tests { } {
44
    global gdb_prompt
45
    global hex
46
    global decimal
47
 
48
    send_gdb "x/12i add_tests\n"
49
    gdb_expect {
50
        -re "
51
.*add   d1,d2.*
52
.*add   d2,a3.*
53
.*add   a2,d1.*
54
.*add   a3,a2.*
55
.*add   16,d1.*
56
.*add   256,d2.*
57
.*add   131071,d3.*
58
.*add   16,a1.*
59
.*add   256,a2.*
60
.*add   131071,a3.*
61
.*addc  d1,d2.*
62
.*addnf 16,a2.*
63
.*$gdb_prompt $" { pass "add tests" }
64
        -re "$gdb_prompt $" { fail "add tests" }
65
        timeout { fail "(timeout) add tests" }
66
    }
67
}
68
 
69
proc bcc_tests { } {
70
    global gdb_prompt
71
    global hex
72
    global decimal
73
 
74
    send_gdb "x/15i bCC_tests\n"
75
    gdb_expect {
76
        -re "
77
.*beq   0x\[0-9a-f]+ .*
78
.*bne   0x\[0-9a-f]+ .*
79
.*bgt   0x\[0-9a-f]+ .*
80
.*bge   0x\[0-9a-f]+ .*
81
.*ble   0x\[0-9a-f]+ .*
82
.*blt   0x\[0-9a-f]+ .*
83
.*bhi   0x\[0-9a-f]+ .*
84
.*bcc   0x\[0-9a-f]+ .*
85
.*bls   0x\[0-9a-f]+ .*
86
.*bcs   0x\[0-9a-f]+ .*
87
.*bvc   0x\[0-9a-f]+ .*
88
.*bvs   0x\[0-9a-f]+ .*
89
.*bnc   0x\[0-9a-f]+ .*
90
.*bns   0x\[0-9a-f]+ .*
91
.*bra   0x\[0-9a-f]+ .*
92
.*$gdb_prompt $" { pass "bCC tests" }
93
        -re "$gdb_prompt $" { fail "bCC tests" }
94
        timeout { fail "(timeout) bCC tests" }
95
    }
96
}
97
 
98
proc bccx_tests { } {
99
    global gdb_prompt
100
    global hex
101
    global decimal
102
 
103
    send_gdb "x/14i bCCx_tests\n"
104
    gdb_expect {
105
        -re "
106
.*beqx  0x\[0-9a-f]+ .*
107
.*bnex  0x\[0-9a-f]+ .*
108
.*bgtx  0x\[0-9a-f]+ .*
109
.*bgex  0x\[0-9a-f]+ .*
110
.*blex  0x\[0-9a-f]+ .*
111
.*bltx  0x\[0-9a-f]+ .*
112
.*bhix  0x\[0-9a-f]+ .*
113
.*bccx  0x\[0-9a-f]+ .*
114
.*blsx  0x\[0-9a-f]+ .*
115
.*bcsx  0x\[0-9a-f]+ .*
116
.*bvcx  0x\[0-9a-f]+ .*
117
.*bvsx  0x\[0-9a-f]+ .*
118
.*bncx  0x\[0-9a-f]+ .*
119
.*bnsx  0x\[0-9a-f]+ .*
120
.*$gdb_prompt $" { pass "bCCx tests" }
121
        -re "$gdb_prompt $" { fail "bCCx tests" }
122
        timeout { fail "(timeout) bCCx tests" }
123
    }
124
}
125
 
126
proc bit_tests { } {
127
    global gdb_prompt
128
    global hex
129
    global decimal
130
 
131
    send_gdb "x/4 bit_tests\n"
132
    gdb_expect {
133
        -re "
134
.*btst  64,d1.*
135
.*btst  8192,d2.*
136
.*bset  d1,\\(a2\\).*
137
.*bclr  d1,\\(a2\\).*
138
.*$gdb_prompt $" { pass "bit tests" }
139
        -re "$gdb_prompt $" { fail "bit tests" }
140
        timeout { fail "(timeout) bit tests" }
141
    }
142
}
143
 
144
proc cmp_tests { } {
145
    global gdb_prompt
146
    global hex
147
    global decimal
148
 
149
    send_gdb "x/9i cmp_tests\n"
150
    gdb_expect {
151
        -re "
152
.*cmp   d1,d2.*
153
.*cmp   d2,a3.*
154
.*cmp   a3,d3.*
155
.*cmp   a3,a2.*
156
.*cmp   16,d3.*
157
.*cmp   256,d2.*
158
.*cmp   131071,d1.*
159
.*cmp   256,a2.*
160
.*cmp   131071,a1.*
161
.*$gdb_prompt $" { pass "cmp tests" }
162
        -re "$gdb_prompt $" { fail "cmp tests" }
163
        timeout { fail "(timeout) cmp tests" }
164
    }
165
}
166
 
167
proc extend_tests { } {
168
    global gdb_prompt
169
    global hex
170
    global decimal
171
 
172
    send_gdb "x/5i extend_tests\n"
173
    gdb_expect {
174
        -re "
175
.*ext   d1.*
176
.*extx  d2.*
177
.*extxu d3.*
178
.*extxb d2.*
179
.*extxbu        d1.*
180
.*$gdb_prompt $" { pass "extend tests" }
181
        -re "$gdb_prompt $" { fail "extend tests" }
182
        timeout { fail "(timeout) extend tests" }
183
    }
184
}
185
 
186
proc logical_tests { } {
187
    global gdb_prompt
188
    global hex
189
    global decimal
190
 
191
    send_gdb "x/11i logical_tests\n"
192
    gdb_expect {
193
        -re "
194
.*and   d1,d2.*
195
.*and   127,d2.*
196
.*and   32767,d3.*
197
.*and   32767,psw.*
198
.*or    d1,d2.*
199
.*or    127,d2.*
200
.*or    32767,d3.*
201
.*or    32767,psw.*
202
.*xor   d1,d2.*
203
.*xor   32767,d3.*
204
.*not   d3.*
205
.*$gdb_prompt $" { pass "logical tests" }
206
        -re "$gdb_prompt $" { fail "logical tests" }
207
        timeout { fail "(timeout) logical tests" }
208
    }
209
}
210
 
211
proc mov_tests_1 { } {
212
    global gdb_prompt
213
    global hex
214
    global decimal
215
 
216
    send_gdb "x/12i mov_tests_1\n"
217
    gdb_expect {
218
        -re "
219
.*mov   d1,a2.*
220
.*mov   a2,d1.*
221
.*mov   d1,d2.*
222
.*mov   a2,a1.*
223
.*mov   psw,d3.*
224
.*mov   d2,psw.*
225
.*mov   mdr,d1.*
226
.*mov   d2,mdr.*
227
.*mov   \\(a2\\),d1.*
228
.*mov   \\(8,a2\\),d1.*
229
.*mov   \\(256,a2\\),d1.*
230
.*mov   \\(131071,a2\\),d1.*
231
.*$gdb_prompt $" { pass "mov1 tests" }
232
        -re "$gdb_prompt $" { fail "mov1 tests" }
233
        timeout { fail "(timeout) mov1 tests" }
234
    }
235
}
236
 
237
proc mov_tests_2 { } {
238
    global gdb_prompt
239
    global hex
240
    global decimal
241
 
242
    send_gdb "x/9 mov_tests_2\n"
243
    gdb_expect {
244
        -re "
245
.*mov   \\(d1,a1\\),d2.*
246
.*mov   \\(0x8000.*\\),d1.*
247
.*mov   \\(0x1ffff.*\\),d1.*
248
.*mov   \\(8,a2\\),a1.*
249
.*mov   \\(256,a2\\),a1.*
250
.*mov   \\(131071,a2\\),a1.*
251
.*mov   \\(d1,a1\\),a2.*
252
.*mov   \\(0x8000.*\\),a1.*
253
.*mov   \\(0x1ffff.*\\),a1.*
254
.*$gdb_prompt $" { pass "mov2 tests" }
255
        -re "$gdb_prompt $" { fail "mov2 tests" }
256
        timeout { fail "(timeout) mov2 tests" }
257
    }
258
}
259
 
260
proc mov_tests_3 { } {
261
    global gdb_prompt
262
    global hex
263
    global decimal
264
 
265
    send_gdb "x/10 mov_tests_3\n"
266
    gdb_expect {
267
        -re "
268
.*mov   d1,\\(a2\\).*
269
.*mov   d1,\\(32,a2\\).*
270
.*mov   d1,\\(256,a2\\).*
271
.*mov   d1,\\(131071,a2\\).*
272
.*mov   d1,\\(d2,a2\\).*
273
.*mov   d1,\\(0x80.*\\).*
274
.*mov   d1,\\(0x1ffff.*\\).*
275
.*mov   a1,\\(32,a2\\).*
276
.*mov   a1,\\(256,a2\\).*
277
.*mov   a1,\\(131071,a2\\).*
278
.*$gdb_prompt $" { pass "mov3 tests" }
279
        -re "$gdb_prompt $" { fail "mov3 tests" }
280
        timeout { fail "(timeout) mov3 tests" }
281
    }
282
}
283
 
284
proc mov_tests_4 { } {
285
    global gdb_prompt
286
    global hex
287
    global decimal
288
 
289
    send_gdb "x/8 mov_tests_4\n"
290
    gdb_expect {
291
        -re "
292
.*mov   a1,\\(d2,a2\\).*
293
.*mov   a1,\\(0x80.*\\).*
294
.*mov   a1,\\(0x1ffff.*\\).*
295
.*mov   8,d1.*
296
.*mov   256,d1.*
297
.*mov   131071,d1.*
298
.*mov   256,a1.*
299
.*mov   131071,a1.*
300
.*$gdb_prompt $" { pass "mov4 tests" }
301
        -re "$gdb_prompt $" { fail "mov4 tests" }
302
        timeout { fail "(timeout) mov4 tests" }
303
    }
304
}
305
 
306
proc movb_tests { } {
307
    global gdb_prompt
308
    global hex
309
    global decimal
310
 
311
    send_gdb "x/12 movb_tests\n"
312
    gdb_expect {
313
        -re "
314
.*movb  \\(8,a2\\),d1.*
315
.*movb  \\(256,a2\\),d1.*
316
.*movb  \\(131071,a2\\),d1.*
317
.*movb  \\(d2,a2\\),d3.*
318
.*movb  \\(0x1ffff.*\\),d2.*
319
.*movb  d1,\\(a2\\).*
320
.*movb  d1,\\(8,a2\\).*
321
.*movb  d1,\\(256,a2\\).*
322
.*movb  d1,\\(131071,a2\\).*
323
.*movb  d1,\\(d2,a2\\).*
324
.*movb  d1,\\(0x100.*\\).*
325
.*movb  d1,\\(0x1ffff.*\\).*
326
.*$gdb_prompt $" { pass "movb tests" }
327
        -re "$gdb_prompt $" { fail "movb tests" }
328
        timeout { fail "(timeout) movb tests" }
329
    }
330
}
331
 
332
proc movbu_tests { } {
333
    global gdb_prompt
334
    global hex
335
    global decimal
336
 
337
    send_gdb "x/7 movbu_tests\n"
338
    gdb_expect {
339
        -re "
340
.*movbu \\(a2\\),d1.*
341
.*movbu \\(8,a2\\),d1.*
342
.*movbu \\(256,a2\\),d1.*
343
.*movbu \\(131071,a2\\),d1.*
344
.*movbu \\(d1,a1\\),d2.*
345
.*movbu \\(0x8000.*\\),d1.*
346
.*movbu \\(0x1ffff.*\\),d1.*
347
.*$gdb_prompt $" { pass "movbu tests" }
348
        -re "$gdb_prompt $" { fail "movbu tests" }
349
        timeout { fail "(timeout) movbu tests" }
350
    }
351
}
352
 
353
proc movx_tests { } {
354
    global gdb_prompt
355
    global hex
356
    global decimal
357
 
358
    send_gdb "x/6 movx_tests\n"
359
    gdb_expect {
360
        -re "
361
.*movx  \\(8,a2\\),d1.*
362
.*movx  \\(256,a2\\),d1.*
363
.*movx  \\(131071,a2\\),d1.*
364
.*movx  d1,\\(8,a2\\).*
365
.*movx  d1,\\(256,a2\\).*
366
.*movx  d1,\\(131071,a2\\).*
367
.*$gdb_prompt $" { pass "movx tests" }
368
        -re "$gdb_prompt $" { fail "movx tests" }
369
        timeout { fail "(timeout) movx tests" }
370
    }
371
}
372
 
373
proc muldiv_tests { } {
374
    global gdb_prompt
375
    global hex
376
    global decimal
377
 
378
    send_gdb "x/3 muldiv_tests\n"
379
    gdb_expect {
380
        -re "
381
.*mul   d1,d2.*
382
.*mulu  d2,d3.*
383
.*divu  d3,d2.*
384
.*$gdb_prompt $" { pass "muldiv tests" }
385
        -re "$gdb_prompt $" { fail "muldiv tests" }
386
        timeout { fail "(timeout) muldiv tests" }
387
    }
388
}
389
 
390
proc misc_tests { } {
391
    global gdb_prompt
392
    global hex
393
    global decimal
394
 
395
    send_gdb "x/9 misc_tests\n"
396
    gdb_expect {
397
        -re "
398
.*jmp   0x\[0-9a-f]+ 
.*
399
.*jmp   0x\[0-9a-f]+ .*
400
.*jmp   \\(a2\\).*
401
.*jsr   0x\[0-9a-f]+ 
.*
402
.*jsr   0x\[0-9a-f]+ .*
403
.*jsr   \\(a2\\).*
404
.*rts.*
405
.*rti.*
406
.*nop.*
407
.*$gdb_prompt $" { pass "misc tests" }
408
        -re "$gdb_prompt $" { fail "misc tests" }
409
        timeout { fail "(timeout) misc tests" }
410
    }
411
}
412
 
413
proc shift_tests { } {
414
    global gdb_prompt
415
    global hex
416
    global decimal
417
 
418
    send_gdb "x/4i shift_tests\n"
419
    gdb_expect {
420
        -re "
421
.*asr   d2.*
422
.*lsr   d3.*
423
.*ror   d1.*
424
.*rol   d2.*
425
.*$gdb_prompt $" { pass "shift tests" }
426
        -re "$gdb_prompt $" { fail "shift tests" }
427
        timeout { fail "(timeout) shift tests" }
428
    }
429
}
430
 
431
proc sub_tests { } {
432
    global gdb_prompt
433
    global hex
434
    global decimal
435
 
436
    send_gdb "x/9i sub_tests\n"
437
    gdb_expect {
438
        -re "
439
.*sub   d1,d2.*
440
.*sub   d2,a3.*
441
.*sub   a3,d3.*
442
.*sub   a3,a2.*
443
.*sub   32767,d2.*
444
.*sub   131071,d2.*
445
.*sub   32767,a2.*
446
.*sub   131071,a2.*
447
.*subc  d1,d2.*
448
.*$gdb_prompt $" { pass "sub tests" }
449
        -re "$gdb_prompt $" { fail "sub tests" }
450
        timeout { fail "(timeout) sub tests" }
451
    }
452
}
453
 
454
# Start with a fresh gdb.
455
 
456
gdb_exit
457
gdb_start
458
gdb_reinitialize_dir $srcdir/$subdir
459
gdb_load $binfile
460
 
461
add_tests
462
bcc_tests
463
bccx_tests
464
bit_tests
465
cmp_tests
466
extend_tests
467
logical_tests
468
mov_tests_1
469
mov_tests_2
470
mov_tests_3
471
mov_tests_4
472
movb_tests
473
movbu_tests
474
movx_tests
475
muldiv_tests
476
misc_tests
477
shift_tests
478
sub_tests

powered by: WebSVN 2.1.0

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