1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
|
# Copyright (C) 1996 Free Software Foundation, Inc.
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
# Please email any bugs, comments, and/or additions to this file to:
# DejaGnu@cygnus.com
# Written by Cygnus Support.
proc do_arith {} {
set testname "arith.s: Arithmetic operations"
set x 0
gas_start "arith.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
# -re "^ +\[0-9\]+ 0000 489A0000\[^\n\]*\n" { set x [expr $x+1] }
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 C531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 4532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 05360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 4530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a E530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c E532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e E5360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 E537A000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 BF32\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 C530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a 2532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c A530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e 65360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 8530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E537C000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 DF32\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002a E5378000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002e 9F32\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 A531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0032 8531\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==20] then { pass $testname } else { fail $testname }
}
proc do_bit {} {
set testname "bit.s: bit operations"
set x 0
gas_start "bit.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 C6AF1000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 C66F1000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 C62F1000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c C6EF1000\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
proc do_branch {} {
set testname "branch.s: branch operations"
set x 0
gas_start "branch.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 8F05\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 FEFD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E6FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 D7FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 CBFD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a B9FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c A1FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 93FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 82FD\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 FAF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 E0F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 D8F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 C4F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a BCF5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c A1F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e 99F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 82F5\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 FAED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E5ED\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0026 DDED\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==20] then { pass $testname } else { fail $testname }
}
proc do_compare {} {
set testname "compare.s: compare operations"
set x 0
gas_start "compare.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 6532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E02F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 E82F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c E12F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 E12F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0014 E92F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0018 E92F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001c E22F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 EA2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0024 E32F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0028 EB2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 002c E42F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0030 E42F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0034 EC2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0038 EC2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 003c E52F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0040 ED2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0044 E62F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0048 EE2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 004c E72F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0050 EF2F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0054 6531\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==23] then { pass $testname } else { fail $testname }
}
proc do_jumps {} {
set testname "jumps.s: jumps operations"
set x 0
gas_start "jumps.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 802F0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 6500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 BF07FAFF\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==3] then { pass $testname } else { fail $testname }
}
proc do_logical {} {
set testname "logical.s: logical operations"
set x 0
gas_start "logical.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 4531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 C5360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0006 2530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 0531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000a 85360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 2531\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 A5360700\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==7] then { pass $testname } else { fail $testname }
}
proc do_mem {} {
set testname "mem.s: memory operations"
set x 0
gas_start "mem.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 05370500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 25370400\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 25370500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 4033\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e 4034\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0010 4035\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 462F0500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 662F0400\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a 662F0500\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e C033\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0020 C034\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0022 4135\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==12] then { pass $testname } else { fail $testname }
}
proc do_misc {} {
set testname "misc.s: misc operations"
set x 0
gas_start "misc.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 E0076001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 E0876001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 E0072001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000c 0000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 000e E0074001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0012 E0070001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0016 FF070001\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001a E72F2000\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 001e E53F4000\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==9] then { pass $testname } else { fail $testname }
}
proc do_move {} {
set testname "move.s: move operations"
set x 0
gas_start "move.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 0530\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0002 0532\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 25360700\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 45360700\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==4] then { pass $testname } else { fail $testname }
}
proc do_hilo {} {
set testname "hilo.s: hilo tests"
set x 0
gas_start "hilo.s" "-al"
# Instead of having a variable for each match string just increment the
# total number of matches seen. That's simpler when testing large numbers
# of instructions (as these tests to).
while 1 {
expect {
-re "^ +\[0-9\]+ 0000 200EEFBE\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0004 410EAEDE\[^\n\]*\n" { set x [expr $x+1] }
-re "^ +\[0-9\]+ 0008 410EADDE\[^\n\]*\n" { set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
gas_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==3] then { pass $testname } else { fail $testname }
}
proc do_simple_reloc_tests {} {
set testname "reloc.s: Test for proper relocations (part 2)"
set x 0
if [gas_test_old "reloc.s" "" "Test for proper relocation (part 1)"] then {
objdump_start_no_subdir "a.out" "-r"
while 1 {
expect {
-re "^00000002\[^\n\]*R_V850_LO16\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^00000006\[^\n\]*R_V850_HI16_S\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0000000a\[^\n\]*R_V850_HI16\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^0000000e\[^\n\]*R_V850_ZDA_16_16_OFFSET\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^00000012\[^\n\]*R_V850_TDA_16_16_OFFSET\[^\n\]*\n"
{ set x [expr $x+1] }
-re "^00000016\[^\n\]*R_V850_SDA_16_16_OFFSET\[^\n\]*\n"
{ set x [expr $x+1] }
-re "\[^\n\]*\n" { }
timeout { perror "timeout\n"; break }
eof { break }
}
}
}
# This was intended to do any cleanup necessary. It kinda looks like it
# isn't needed, but just in case, please keep it in for now.
objdump_finish
# Did we find what we were looking for? If not, flunk it.
if [expr $x==6] then { pass $testname } else { fail $testname }
}
if [istarget v850*-*-*] then {
# Test the basic instruction parser.
do_arith
do_bit
do_branch
do_compare
do_jumps
do_logical
do_mem
do_misc
do_move
# Make sure we handle lo() hi() and hi0() correctly.
do_hilo
# Check for proper relocs on lo, hi, hi0, zdaoff, tdaoff and sdaoff
# expressions
do_simple_reloc_tests
gas_test "hilo2.s" "" "" "hi/lo regression test"
gas_test "fepsw.s" "" "" "eqsw regression test"
gas_test_error "range.s" "-mwarn-signed-overflow" "Check for range error on byte load/store"
}
|
