Commit | Line | Data |
---|---|---|
252b5132 RH |
1 | # Copyright (C) 1993, 1996, 1997 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 2 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, write to the Free Software | |
15 | # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. | |
16 | ||
17 | # Please email any bugs, comments, and/or additions to this file to: | |
18 | # DejaGnu@cygnus.com | |
19 | ||
20 | # Written by the Center for Software Science at the Univeristy of Utah | |
21 | # and by Cygnus Support. | |
22 | ||
23 | proc do_imem {} { | |
24 | set testname "imem.s: integer memory loads and stores" | |
25 | set x 0 | |
26 | ||
27 | gas_start "imem.s" "-al" | |
28 | ||
29 | # Check the assembled instruction against a table built by the HP assembler | |
30 | # Any differences should be checked by hand -- with the number of problems | |
31 | # I've seen in the HP assembler I don't completely trust it. | |
32 | # | |
33 | # Instead of having a variable for each match string just increment the | |
34 | # total number of matches seen. That's simpler when testing large numbers | |
35 | # of instructions (as these tests to). | |
36 | while 1 { | |
37 | expect { | |
38 | -re "^ +\[0-9\]+ 0000 489A0000\[^\n\]*\n" { set x [expr $x+1] } | |
39 | -re "^ +\[0-9\]+ 0000 0C80109A\[^\n\]*\n" { set x [expr $x+1] } | |
40 | -re "^ +\[0-9\]+ 0004 449A0000\[^\n\]*\n" { set x [expr $x+1] } | |
41 | -re "^ +\[0-9\]+ 0004 0C80105A\[^\n\]*\n" { set x [expr $x+1] } | |
42 | -re "^ +\[0-9\]+ 0008 409A0000\[^\n\]*\n" { set x [expr $x+1] } | |
43 | -re "^ +\[0-9\]+ 0008 0C80101A\[^\n\]*\n" { set x [expr $x+1] } | |
44 | -re "^ +\[0-9\]+ 000c 689A0000\[^\n\]*\n" { set x [expr $x+1] } | |
45 | -re "^ +\[0-9\]+ 000c 0C9A1280\[^\n\]*\n" { set x [expr $x+1] } | |
46 | -re "^ +\[0-9\]+ 0010 649A0000\[^\n\]*\n" { set x [expr $x+1] } | |
47 | -re "^ +\[0-9\]+ 0010 0C9A1240\[^\n\]*\n" { set x [expr $x+1] } | |
48 | -re "^ +\[0-9\]+ 0014 609A0000\[^\n\]*\n" { set x [expr $x+1] } | |
49 | -re "^ +\[0-9\]+ 0014 0C9A1200\[^\n\]*\n" { set x [expr $x+1] } | |
50 | -re "^ +\[0-9\]+ 0018 4C9A0000\[^\n\]*\n" { set x [expr $x+1] } | |
51 | -re "^ +\[0-9\]+ 001c 6C9A0000\[^\n\]*\n" { set x [expr $x+1] } | |
52 | -re "^ +\[0-9\]+ 0020 0C85009A\[^\n\]*\n" { set x [expr $x+1] } | |
53 | -re "^ +\[0-9\]+ 0024 0C85209A\[^\n\]*\n" { set x [expr $x+1] } | |
54 | -re "^ +\[0-9\]+ 0028 0C8500BA\[^\n\]*\n" { set x [expr $x+1] } | |
55 | -re "^ +\[0-9\]+ 002c 0C8520BA\[^\n\]*\n" { set x [expr $x+1] } | |
56 | -re "^ +\[0-9\]+ 0030 0C85005A\[^\n\]*\n" { set x [expr $x+1] } | |
57 | -re "^ +\[0-9\]+ 0034 0C85205A\[^\n\]*\n" { set x [expr $x+1] } | |
58 | -re "^ +\[0-9\]+ 0038 0C85007A\[^\n\]*\n" { set x [expr $x+1] } | |
59 | -re "^ +\[0-9\]+ 003c 0C85207A\[^\n\]*\n" { set x [expr $x+1] } | |
60 | -re "^ +\[0-9\]+ 0040 0C85001A\[^\n\]*\n" { set x [expr $x+1] } | |
61 | -re "^ +\[0-9\]+ 0044 0C85201A\[^\n\]*\n" { set x [expr $x+1] } | |
62 | -re "^ +\[0-9\]+ 0048 0C85003A\[^\n\]*\n" { set x [expr $x+1] } | |
63 | -re "^ +\[0-9\]+ 004c 0C85203A\[^\n\]*\n" { set x [expr $x+1] } | |
64 | -re "^ +\[0-9\]+ 0050 0C85019A\[^\n\]*\n" { set x [expr $x+1] } | |
65 | -re "^ +\[0-9\]+ 0054 0C85219A\[^\n\]*\n" { set x [expr $x+1] } | |
66 | -re "^ +\[0-9\]+ 0058 0C8501BA\[^\n\]*\n" { set x [expr $x+1] } | |
67 | -re "^ +\[0-9\]+ 005c 0C8521BA\[^\n\]*\n" { set x [expr $x+1] } | |
68 | -re "^ +\[0-9\]+ 0060 0C8501DA\[^\n\]*\n" { set x [expr $x+1] } | |
69 | -re "^ +\[0-9\]+ 0064 0C8521DA\[^\n\]*\n" { set x [expr $x+1] } | |
70 | -re "^ +\[0-9\]+ 0068 0C8501FA\[^\n\]*\n" { set x [expr $x+1] } | |
71 | -re "^ +\[0-9\]+ 006c 0C8521FA\[^\n\]*\n" { set x [expr $x+1] } | |
72 | -re "^ +\[0-9\]+ 0070 0C80109A\[^\n\]*\n" { set x [expr $x+1] } | |
73 | -re "^ +\[0-9\]+ 0074 0C8030BA\[^\n\]*\n" { set x [expr $x+1] } | |
74 | -re "^ +\[0-9\]+ 0078 0C8010BA\[^\n\]*\n" { set x [expr $x+1] } | |
75 | -re "^ +\[0-9\]+ 007c 0C80105A\[^\n\]*\n" { set x [expr $x+1] } | |
76 | -re "^ +\[0-9\]+ 0080 0C80307A\[^\n\]*\n" { set x [expr $x+1] } | |
77 | -re "^ +\[0-9\]+ 0084 0C80107A\[^\n\]*\n" { set x [expr $x+1] } | |
78 | -re "^ +\[0-9\]+ 0088 0C80101A\[^\n\]*\n" { set x [expr $x+1] } | |
79 | -re "^ +\[0-9\]+ 008c 0C80303A\[^\n\]*\n" { set x [expr $x+1] } | |
80 | -re "^ +\[0-9\]+ 0090 0C80103A\[^\n\]*\n" { set x [expr $x+1] } | |
81 | -re "^ +\[0-9\]+ 0094 0C80119A\[^\n\]*\n" { set x [expr $x+1] } | |
82 | -re "^ +\[0-9\]+ 0098 0C8031BA\[^\n\]*\n" { set x [expr $x+1] } | |
83 | -re "^ +\[0-9\]+ 009c 0C8011BA\[^\n\]*\n" { set x [expr $x+1] } | |
84 | -re "^ +\[0-9\]+ 00a0 0C8011DA\[^\n\]*\n" { set x [expr $x+1] } | |
85 | -re "^ +\[0-9\]+ 00a4 0C8031FA\[^\n\]*\n" { set x [expr $x+1] } | |
86 | -re "^ +\[0-9\]+ 00a8 0C8011FA\[^\n\]*\n" { set x [expr $x+1] } | |
87 | -re "^ +\[0-9\]+ 00ac 0C9A1280\[^\n\]*\n" { set x [expr $x+1] } | |
88 | -re "^ +\[0-9\]+ 00b0 0C9A32A0\[^\n\]*\n" { set x [expr $x+1] } | |
89 | -re "^ +\[0-9\]+ 00b4 0C9A12A0\[^\n\]*\n" { set x [expr $x+1] } | |
90 | -re "^ +\[0-9\]+ 00b8 0C9A1240\[^\n\]*\n" { set x [expr $x+1] } | |
91 | -re "^ +\[0-9\]+ 00bc 0C9A3260\[^\n\]*\n" { set x [expr $x+1] } | |
92 | -re "^ +\[0-9\]+ 00c0 0C9A1260\[^\n\]*\n" { set x [expr $x+1] } | |
93 | -re "^ +\[0-9\]+ 00c4 0C9A1200\[^\n\]*\n" { set x [expr $x+1] } | |
94 | -re "^ +\[0-9\]+ 00c8 0C9A3220\[^\n\]*\n" { set x [expr $x+1] } | |
95 | -re "^ +\[0-9\]+ 00cc 0C9A1220\[^\n\]*\n" { set x [expr $x+1] } | |
96 | -re "^ +\[0-9\]+ 00d0 0C9A1380\[^\n\]*\n" { set x [expr $x+1] } | |
97 | -re "^ +\[0-9\]+ 00d4 0C9A33A0\[^\n\]*\n" { set x [expr $x+1] } | |
98 | -re "^ +\[0-9\]+ 00d8 0C9A13A0\[^\n\]*\n" { set x [expr $x+1] } | |
99 | -re "^ +\[0-9\]+ 00dc 0C9A1300\[^\n\]*\n" { set x [expr $x+1] } | |
100 | -re "^ +\[0-9\]+ 00e0 0C9A1300\[^\n\]*\n" { set x [expr $x+1] } | |
101 | -re "^ +\[0-9\]+ 00e4 0C9A3300\[^\n\]*\n" { set x [expr $x+1] } | |
102 | -re "^ +\[0-9\]+ 00e8 0C9A1320\[^\n\]*\n" { set x [expr $x+1] } | |
103 | -re "^ +\[0-9\]+ 00ec 0C9A3320\[^\n\]*\n" { set x [expr $x+1] } | |
104 | -re "\[^\n\]*\n" { } | |
105 | timeout { perror "timeout\n"; break } | |
106 | eof { break } | |
107 | } | |
108 | } | |
109 | ||
110 | # This was intended to do any cleanup necessary. It kinda looks like it | |
111 | # isn't needed, but just in case, please keep it in for now. | |
112 | gas_finish | |
113 | ||
114 | # Did we find what we were looking for? If not, flunk it. | |
115 | if [expr $x==60] then { pass $testname } else { fail $testname } | |
116 | } | |
117 | ||
118 | proc do_immed {} { | |
119 | set testname "immed.s: immediate tests" | |
120 | set x 0 | |
121 | ||
122 | gas_start "immed.s" "-al" | |
123 | ||
124 | # Check the assembled instruction against a table built by the HP assembler | |
125 | # Any differences should be checked by hand -- with the number of problems | |
126 | # I've seen in the HP assembler I don't completely trust it. | |
127 | # | |
128 | # Instead of having a variable for each match string just increment the | |
129 | # total number of matches seen. That's simpler when testing large numbers | |
130 | # of instructions (as these tests to). | |
131 | while 1 { | |
132 | expect { | |
133 | -re "^ +\[0-9\]+ 0000 375A000A\[^\n\]*\n" { set x [expr $x+1] } | |
134 | -re "^ +\[0-9\]+ 0004 234DFBD5\[^\n\]*\n" { set x [expr $x+1] } | |
135 | -re "^ +\[0-9\]+ 0008 28ADFBD5\[^\n\]*\n" { set x [expr $x+1] } | |
136 | -re "\[^\n\]*\n" { } | |
137 | timeout { perror "timeout\n"; break } | |
138 | eof { break } | |
139 | } | |
140 | } | |
141 | ||
142 | # This was intended to do any cleanup necessary. It kinda looks like it | |
143 | # isn't needed, but just in case, please keep it in for now. | |
144 | gas_finish | |
145 | ||
146 | # Did we find what we were looking for? If not, flunk it. | |
147 | if [expr $x==3] then { pass $testname } else { fail $testname } | |
148 | } | |
149 | ||
150 | proc do_branch {} { | |
151 | set testname "branch.s: branch tests" | |
152 | set x 0 | |
153 | ||
154 | gas_start "branch.s" "-al" | |
155 | ||
156 | # Check the assembled instruction against a table built by the HP assembler | |
157 | # Any differences should be checked by hand -- with the number of problems | |
158 | # I've seen in the HP assembler I don't completely trust it. | |
159 | # | |
160 | # Instead of having a variable for each match string just increment the | |
161 | # total number of matches seen. That's simpler when testing large numbers | |
162 | # of instructions (as these tests to). | |
163 | while 1 { | |
164 | expect { | |
165 | -re "^ +\[0-9\]+ 0000 E85F1FF5\[^\n\]*\n" { set x [expr $x+1] } | |
166 | -re "^ +\[0-9\]+ 0004 E85F1FEF\[^\n\]*\n" { set x [expr $x+1] } | |
167 | -re "^ +\[0-9\]+ 0008 E81F1FE5\[^\n\]*\n" { set x [expr $x+1] } | |
168 | -re "^ +\[0-9\]+ 000c E81F1FDF\[^\n\]*\n" { set x [expr $x+1] } | |
169 | -re "^ +\[0-9\]+ 0010 E85F3FD5\[^\n\]*\n" { set x [expr $x+1] } | |
170 | -re "^ +\[0-9\]+ 0014 E85F3FCF\[^\n\]*\n" { set x [expr $x+1] } | |
171 | -re "^ +\[0-9\]+ 0018 E8444000\[^\n\]*\n" { set x [expr $x+1] } | |
172 | -re "^ +\[0-9\]+ 001c E8444002\[^\n\]*\n" { set x [expr $x+1] } | |
173 | -re "^ +\[0-9\]+ 0020 E8044000\[^\n\]*\n" { set x [expr $x+1] } | |
174 | -re "^ +\[0-9\]+ 0024 E8044002\[^\n\]*\n" { set x [expr $x+1] } | |
175 | -re "^ +\[0-9\]+ 0028 E840C000\[^\n\]*\n" { set x [expr $x+1] } | |
176 | -re "^ +\[0-9\]+ 002c E840C002\[^\n\]*\n" { set x [expr $x+1] } | |
177 | -re "^ +\[0-9\]+ 0030 E040446C\[^\n\]*\n" { set x [expr $x+1] } | |
178 | -re "^ +\[0-9\]+ 0034 E040446E\[^\n\]*\n" { set x [expr $x+1] } | |
179 | -re "^ +\[0-9\]+ 0038 E440446C\[^\n\]*\n" { set x [expr $x+1] } | |
180 | -re "^ +\[0-9\]+ 003c E440446E\[^\n\]*\n" { set x [expr $x+1] } | |
181 | -re "^ +\[0-9\]+ 0040 CB441FF5\[^\n\]*\n" { set x [expr $x+1] } | |
182 | -re "^ +\[0-9\]+ 0044 CB443FED\[^\n\]*\n" { set x [expr $x+1] } | |
183 | -re "^ +\[0-9\]+ 0048 CB445FE5\[^\n\]*\n" { set x [expr $x+1] } | |
184 | -re "^ +\[0-9\]+ 004c CB447FDD\[^\n\]*\n" { set x [expr $x+1] } | |
185 | -re "^ +\[0-9\]+ 0050 CB449FD5\[^\n\]*\n" { set x [expr $x+1] } | |
186 | -re "^ +\[0-9\]+ 0054 CB44BFCD\[^\n\]*\n" { set x [expr $x+1] } | |
187 | -re "^ +\[0-9\]+ 0058 CB44DFC5\[^\n\]*\n" { set x [expr $x+1] } | |
188 | -re "^ +\[0-9\]+ 005c CB44FFBD\[^\n\]*\n" { set x [expr $x+1] } | |
189 | -re "^ +\[0-9\]+ 0060 CB441FB7\[^\n\]*\n" { set x [expr $x+1] } | |
190 | -re "^ +\[0-9\]+ 0064 CB443FAF\[^\n\]*\n" { set x [expr $x+1] } | |
191 | -re "^ +\[0-9\]+ 0068 CB445FA7\[^\n\]*\n" { set x [expr $x+1] } | |
192 | -re "^ +\[0-9\]+ 006c CB447F9F\[^\n\]*\n" { set x [expr $x+1] } | |
193 | -re "^ +\[0-9\]+ 0070 CB449F97\[^\n\]*\n" { set x [expr $x+1] } | |
194 | -re "^ +\[0-9\]+ 0074 CB44BF8F\[^\n\]*\n" { set x [expr $x+1] } | |
195 | -re "^ +\[0-9\]+ 0078 CB44DF87\[^\n\]*\n" { set x [expr $x+1] } | |
196 | -re "^ +\[0-9\]+ 007c CB44FF7F\[^\n\]*\n" { set x [expr $x+1] } | |
197 | -re "^ +\[0-9\]+ 0080 CF4A1FF5\[^\n\]*\n" { set x [expr $x+1] } | |
198 | -re "^ +\[0-9\]+ 0084 CF4A3FED\[^\n\]*\n" { set x [expr $x+1] } | |
199 | -re "^ +\[0-9\]+ 0088 CF4A5FE5\[^\n\]*\n" { set x [expr $x+1] } | |
200 | -re "^ +\[0-9\]+ 008c CF4A7FDD\[^\n\]*\n" { set x [expr $x+1] } | |
201 | -re "^ +\[0-9\]+ 0090 CF4A9FD5\[^\n\]*\n" { set x [expr $x+1] } | |
202 | -re "^ +\[0-9\]+ 0094 CF4ABFCD\[^\n\]*\n" { set x [expr $x+1] } | |
203 | -re "^ +\[0-9\]+ 0098 CF4ADFC5\[^\n\]*\n" { set x [expr $x+1] } | |
204 | -re "^ +\[0-9\]+ 009c CF4AFFBD\[^\n\]*\n" { set x [expr $x+1] } | |
205 | -re "^ +\[0-9\]+ 00a0 CF4A1FB7\[^\n\]*\n" { set x [expr $x+1] } | |
206 | -re "^ +\[0-9\]+ 00a4 CF4A3FAF\[^\n\]*\n" { set x [expr $x+1] } | |
207 | -re "^ +\[0-9\]+ 00a8 CF4A5FA7\[^\n\]*\n" { set x [expr $x+1] } | |
208 | -re "^ +\[0-9\]+ 00ac CF4A7F9F\[^\n\]*\n" { set x [expr $x+1] } | |
209 | -re "^ +\[0-9\]+ 00b0 CF4A9F97\[^\n\]*\n" { set x [expr $x+1] } | |
210 | -re "^ +\[0-9\]+ 00b4 CF4ABF8F\[^\n\]*\n" { set x [expr $x+1] } | |
211 | -re "^ +\[0-9\]+ 00b8 CF4ADF87\[^\n\]*\n" { set x [expr $x+1] } | |
212 | -re "^ +\[0-9\]+ 00bc CF4AFF7F\[^\n\]*\n" { set x [expr $x+1] } | |
213 | -re "^ +\[0-9\]+ 00c0 80801FF5\[^\n\]*\n" { set x [expr $x+1] } | |
214 | -re "^ +\[0-9\]+ 00c4 80803FED\[^\n\]*\n" { set x [expr $x+1] } | |
215 | -re "^ +\[0-9\]+ 00c8 80805FE5\[^\n\]*\n" { set x [expr $x+1] } | |
216 | -re "^ +\[0-9\]+ 00cc 80807FDD\[^\n\]*\n" { set x [expr $x+1] } | |
217 | -re "^ +\[0-9\]+ 00d0 80809FD5\[^\n\]*\n" { set x [expr $x+1] } | |
218 | -re "^ +\[0-9\]+ 00d4 8080BFCD\[^\n\]*\n" { set x [expr $x+1] } | |
219 | -re "^ +\[0-9\]+ 00d8 8080DFC5\[^\n\]*\n" { set x [expr $x+1] } | |
220 | -re "^ +\[0-9\]+ 00dc 8080FFBD\[^\n\]*\n" { set x [expr $x+1] } | |
221 | -re "^ +\[0-9\]+ 00e0 88801FB5\[^\n\]*\n" { set x [expr $x+1] } | |
222 | -re "^ +\[0-9\]+ 00e4 88803FAD\[^\n\]*\n" { set x [expr $x+1] } | |
223 | -re "^ +\[0-9\]+ 00e8 88805FA5\[^\n\]*\n" { set x [expr $x+1] } | |
224 | -re "^ +\[0-9\]+ 00ec 88807F9D\[^\n\]*\n" { set x [expr $x+1] } | |
225 | -re "^ +\[0-9\]+ 00f0 88809F95\[^\n\]*\n" { set x [expr $x+1] } | |
226 | -re "^ +\[0-9\]+ 00f4 8880BF8D\[^\n\]*\n" { set x [expr $x+1] } | |
227 | -re "^ +\[0-9\]+ 00f8 8880DF85\[^\n\]*\n" { set x [expr $x+1] } | |
228 | -re "^ +\[0-9\]+ 00fc 8880FF7D\[^\n\]*\n" { set x [expr $x+1] } | |
229 | -re "^ +\[0-9\]+ 0100 80801F77\[^\n\]*\n" { set x [expr $x+1] } | |
230 | -re "^ +\[0-9\]+ 0104 80803F6F\[^\n\]*\n" { set x [expr $x+1] } | |
231 | -re "^ +\[0-9\]+ 0108 80805F67\[^\n\]*\n" { set x [expr $x+1] } | |
232 | -re "^ +\[0-9\]+ 010c 80807F5F\[^\n\]*\n" { set x [expr $x+1] } | |
233 | -re "^ +\[0-9\]+ 0110 80809F57\[^\n\]*\n" { set x [expr $x+1] } | |
234 | -re "^ +\[0-9\]+ 0114 8080BF4F\[^\n\]*\n" { set x [expr $x+1] } | |
235 | -re "^ +\[0-9\]+ 0118 8080DF47\[^\n\]*\n" { set x [expr $x+1] } | |
236 | -re "^ +\[0-9\]+ 011c 8080FF3F\[^\n\]*\n" { set x [expr $x+1] } | |
237 | -re "^ +\[0-9\]+ 0120 88801F37\[^\n\]*\n" { set x [expr $x+1] } | |
238 | -re "^ +\[0-9\]+ 0124 88803F2F\[^\n\]*\n" { set x [expr $x+1] } | |
239 | -re "^ +\[0-9\]+ 0128 88805F27\[^\n\]*\n" { set x [expr $x+1] } | |
240 | -re "^ +\[0-9\]+ 012c 88807F1F\[^\n\]*\n" { set x [expr $x+1] } | |
241 | -re "^ +\[0-9\]+ 0130 88809F17\[^\n\]*\n" { set x [expr $x+1] } | |
242 | -re "^ +\[0-9\]+ 0134 8880BF0F\[^\n\]*\n" { set x [expr $x+1] } | |
243 | -re "^ +\[0-9\]+ 0138 8880DF07\[^\n\]*\n" { set x [expr $x+1] } | |
244 | -re "^ +\[0-9\]+ 013c 8880FEFF\[^\n\]*\n" { set x [expr $x+1] } | |
245 | -re "^ +\[0-9\]+ 0140 84801FF5\[^\n\]*\n" { set x [expr $x+1] } | |
246 | -re "^ +\[0-9\]+ 0144 84805FED\[^\n\]*\n" { set x [expr $x+1] } | |
247 | -re "^ +\[0-9\]+ 0148 84807FE5\[^\n\]*\n" { set x [expr $x+1] } | |
248 | -re "^ +\[0-9\]+ 014c 84809FDD\[^\n\]*\n" { set x [expr $x+1] } | |
249 | -re "^ +\[0-9\]+ 0150 8480BFD5\[^\n\]*\n" { set x [expr $x+1] } | |
250 | -re "^ +\[0-9\]+ 0154 8480DFCD\[^\n\]*\n" { set x [expr $x+1] } | |
251 | -re "^ +\[0-9\]+ 0158 8480FFC5\[^\n\]*\n" { set x [expr $x+1] } | |
252 | -re "^ +\[0-9\]+ 015c 8C801FBD\[^\n\]*\n" { set x [expr $x+1] } | |
253 | -re "^ +\[0-9\]+ 0160 8C803FB5\[^\n\]*\n" { set x [expr $x+1] } | |
254 | -re "^ +\[0-9\]+ 0164 8C805FAD\[^\n\]*\n" { set x [expr $x+1] } | |
255 | -re "^ +\[0-9\]+ 0168 8C807FA5\[^\n\]*\n" { set x [expr $x+1] } | |
256 | -re "^ +\[0-9\]+ 016c 8C809F9D\[^\n\]*\n" { set x [expr $x+1] } | |
257 | -re "^ +\[0-9\]+ 0170 8C80BF95\[^\n\]*\n" { set x [expr $x+1] } | |
258 | -re "^ +\[0-9\]+ 0174 8C80DF8D\[^\n\]*\n" { set x [expr $x+1] } | |
259 | -re "^ +\[0-9\]+ 0178 8C80FE85\[^\n\]*\n" { set x [expr $x+1] } | |
260 | -re "^ +\[0-9\]+ 017c 84801F7F\[^\n\]*\n" { set x [expr $x+1] } | |
261 | -re "^ +\[0-9\]+ 0180 84803F77\[^\n\]*\n" { set x [expr $x+1] } | |
262 | -re "^ +\[0-9\]+ 0184 84805F6F\[^\n\]*\n" { set x [expr $x+1] } | |
263 | -re "^ +\[0-9\]+ 0188 84807F67\[^\n\]*\n" { set x [expr $x+1] } | |
264 | -re "^ +\[0-9\]+ 018c 84809F5F\[^\n\]*\n" { set x [expr $x+1] } | |
265 | -re "^ +\[0-9\]+ 0190 8480BF57\[^\n\]*\n" { set x [expr $x+1] } | |
266 | -re "^ +\[0-9\]+ 0194 8480DF4F\[^\n\]*\n" { set x [expr $x+1] } | |
267 | -re "^ +\[0-9\]+ 0198 8480FF47\[^\n\]*\n" { set x [expr $x+1] } | |
268 | -re "^ +\[0-9\]+ 019c 8C801F3F\[^\n\]*\n" { set x [expr $x+1] } | |
269 | -re "^ +\[0-9\]+ 01a0 8C803F37\[^\n\]*\n" { set x [expr $x+1] } | |
270 | -re "^ +\[0-9\]+ 01a4 8C805F2F\[^\n\]*\n" { set x [expr $x+1] } | |
271 | -re "^ +\[0-9\]+ 01a8 8C807F27\[^\n\]*\n" { set x [expr $x+1] } | |
272 | -re "^ +\[0-9\]+ 01ac 8C809F1F\[^\n\]*\n" { set x [expr $x+1] } | |
273 | -re "^ +\[0-9\]+ 01b0 8C80BF17\[^\n\]*\n" { set x [expr $x+1] } | |
274 | -re "^ +\[0-9\]+ 01b4 8C80DF0F\[^\n\]*\n" { set x [expr $x+1] } | |
275 | -re "^ +\[0-9\]+ 01b8 8C80FF07\[^\n\]*\n" { set x [expr $x+1] } | |
276 | -re "^ +\[0-9\]+ 01bc A0811FF5\[^\n\]*\n" { set x [expr $x+1] } | |
277 | -re "^ +\[0-9\]+ 01c0 A0813FED\[^\n\]*\n" { set x [expr $x+1] } | |
278 | -re "^ +\[0-9\]+ 01c4 A0815FE5\[^\n\]*\n" { set x [expr $x+1] } | |
279 | -re "^ +\[0-9\]+ 01c8 A0817FDD\[^\n\]*\n" { set x [expr $x+1] } | |
280 | -re "^ +\[0-9\]+ 01cc A0819FD5\[^\n\]*\n" { set x [expr $x+1] } | |
281 | -re "^ +\[0-9\]+ 01d0 A081BFCD\[^\n\]*\n" { set x [expr $x+1] } | |
282 | -re "^ +\[0-9\]+ 01d4 A081DFC5\[^\n\]*\n" { set x [expr $x+1] } | |
283 | -re "^ +\[0-9\]+ 01d8 A081FFBD\[^\n\]*\n" { set x [expr $x+1] } | |
284 | -re "^ +\[0-9\]+ 01dc A8811FB5\[^\n\]*\n" { set x [expr $x+1] } | |
285 | -re "^ +\[0-9\]+ 01e0 A8813FAD\[^\n\]*\n" { set x [expr $x+1] } | |
286 | -re "^ +\[0-9\]+ 01e4 A8815FA5\[^\n\]*\n" { set x [expr $x+1] } | |
287 | -re "^ +\[0-9\]+ 01e8 A8817F9D\[^\n\]*\n" { set x [expr $x+1] } | |
288 | -re "^ +\[0-9\]+ 01ec A8819F95\[^\n\]*\n" { set x [expr $x+1] } | |
289 | -re "^ +\[0-9\]+ 01f0 A881BF8D\[^\n\]*\n" { set x [expr $x+1] } | |
290 | -re "^ +\[0-9\]+ 01f4 A881DF85\[^\n\]*\n" { set x [expr $x+1] } | |
291 | -re "^ +\[0-9\]+ 01f8 A881FF7D\[^\n\]*\n" { set x [expr $x+1] } | |
292 | -re "^ +\[0-9\]+ 01fc A0811F77\[^\n\]*\n" { set x [expr $x+1] } | |
293 | -re "^ +\[0-9\]+ 0200 A0813F6F\[^\n\]*\n" { set x [expr $x+1] } | |
294 | -re "^ +\[0-9\]+ 0204 A0815F67\[^\n\]*\n" { set x [expr $x+1] } | |
295 | -re "^ +\[0-9\]+ 0208 A0817F5F\[^\n\]*\n" { set x [expr $x+1] } | |
296 | -re "^ +\[0-9\]+ 020c A0819F57\[^\n\]*\n" { set x [expr $x+1] } | |
297 | -re "^ +\[0-9\]+ 0210 A081BF4F\[^\n\]*\n" { set x [expr $x+1] } | |
298 | -re "^ +\[0-9\]+ 0214 A081DF47\[^\n\]*\n" { set x [expr $x+1] } | |
299 | -re "^ +\[0-9\]+ 0218 A081FF3F\[^\n\]*\n" { set x [expr $x+1] } | |
300 | -re "^ +\[0-9\]+ 021c A8811F37\[^\n\]*\n" { set x [expr $x+1] } | |
301 | -re "^ +\[0-9\]+ 0220 A8813F2F\[^\n\]*\n" { set x [expr $x+1] } | |
302 | -re "^ +\[0-9\]+ 0224 A8815F27\[^\n\]*\n" { set x [expr $x+1] } | |
303 | -re "^ +\[0-9\]+ 0228 A8817F1F\[^\n\]*\n" { set x [expr $x+1] } | |
304 | -re "^ +\[0-9\]+ 022c A8819F17\[^\n\]*\n" { set x [expr $x+1] } | |
305 | -re "^ +\[0-9\]+ 0230 A881BF0F\[^\n\]*\n" { set x [expr $x+1] } | |
306 | -re "^ +\[0-9\]+ 0234 A881DF07\[^\n\]*\n" { set x [expr $x+1] } | |
307 | -re "^ +\[0-9\]+ 0238 A881FEFF\[^\n\]*\n" { set x [expr $x+1] } | |
308 | -re "^ +\[0-9\]+ 023c A49F1FF5\[^\n\]*\n" { set x [expr $x+1] } | |
309 | -re "^ +\[0-9\]+ 0240 A49F3FED\[^\n\]*\n" { set x [expr $x+1] } | |
310 | -re "^ +\[0-9\]+ 0244 A49F5FE5\[^\n\]*\n" { set x [expr $x+1] } | |
311 | -re "^ +\[0-9\]+ 0248 A49F7FDD\[^\n\]*\n" { set x [expr $x+1] } | |
312 | -re "^ +\[0-9\]+ 024c A49F9FD5\[^\n\]*\n" { set x [expr $x+1] } | |
313 | -re "^ +\[0-9\]+ 0250 A49FBFCD\[^\n\]*\n" { set x [expr $x+1] } | |
314 | -re "^ +\[0-9\]+ 0254 A49FDFC5\[^\n\]*\n" { set x [expr $x+1] } | |
315 | -re "^ +\[0-9\]+ 0258 A49FFFBD\[^\n\]*\n" { set x [expr $x+1] } | |
316 | -re "^ +\[0-9\]+ 025c AC9F1FB5\[^\n\]*\n" { set x [expr $x+1] } | |
317 | -re "^ +\[0-9\]+ 0260 AC9F3FAD\[^\n\]*\n" { set x [expr $x+1] } | |
318 | -re "^ +\[0-9\]+ 0264 AC9F5FA5\[^\n\]*\n" { set x [expr $x+1] } | |
319 | -re "^ +\[0-9\]+ 0268 AC9F7F9D\[^\n\]*\n" { set x [expr $x+1] } | |
320 | -re "^ +\[0-9\]+ 026c AC9F9F95\[^\n\]*\n" { set x [expr $x+1] } | |
321 | -re "^ +\[0-9\]+ 0270 AC9FBF8D\[^\n\]*\n" { set x [expr $x+1] } | |
322 | -re "^ +\[0-9\]+ 0274 AC9FDF85\[^\n\]*\n" { set x [expr $x+1] } | |
323 | -re "^ +\[0-9\]+ 0278 AC9FFC85\[^\n\]*\n" { set x [expr $x+1] } | |
324 | -re "^ +\[0-9\]+ 027c A49F1F77\[^\n\]*\n" { set x [expr $x+1] } | |
325 | -re "^ +\[0-9\]+ 0280 A49F3F6F\[^\n\]*\n" { set x [expr $x+1] } | |
326 | -re "^ +\[0-9\]+ 0284 A49F5F67\[^\n\]*\n" { set x [expr $x+1] } | |
327 | -re "^ +\[0-9\]+ 0288 A49F7F5F\[^\n\]*\n" { set x [expr $x+1] } | |
328 | -re "^ +\[0-9\]+ 028c A49F9F57\[^\n\]*\n" { set x [expr $x+1] } | |
329 | -re "^ +\[0-9\]+ 0290 A49FBF4F\[^\n\]*\n" { set x [expr $x+1] } | |
330 | -re "^ +\[0-9\]+ 0294 A49FDF47\[^\n\]*\n" { set x [expr $x+1] } | |
331 | -re "^ +\[0-9\]+ 0298 A49FFF3F\[^\n\]*\n" { set x [expr $x+1] } | |
332 | -re "^ +\[0-9\]+ 029c AC9F1F37\[^\n\]*\n" { set x [expr $x+1] } | |
333 | -re "^ +\[0-9\]+ 02a0 AC9F3F2F\[^\n\]*\n" { set x [expr $x+1] } | |
334 | -re "^ +\[0-9\]+ 02a4 AC9F5F27\[^\n\]*\n" { set x [expr $x+1] } | |
335 | -re "^ +\[0-9\]+ 02a8 AC9F7F1F\[^\n\]*\n" { set x [expr $x+1] } | |
336 | -re "^ +\[0-9\]+ 02ac AC9F9F17\[^\n\]*\n" { set x [expr $x+1] } | |
337 | -re "^ +\[0-9\]+ 02b0 AC9FBF0F\[^\n\]*\n" { set x [expr $x+1] } | |
338 | -re "^ +\[0-9\]+ 02b4 AC9FDF07\[^\n\]*\n" { set x [expr $x+1] } | |
339 | -re "^ +\[0-9\]+ 02b8 AC9FFEFF\[^\n\]*\n" { set x [expr $x+1] } | |
340 | -re "^ +\[0-9\]+ 02bc C0045FF5\[^\n\]*\n" { set x [expr $x+1] } | |
341 | -re "^ +\[0-9\]+ 02c0 C004DFED\[^\n\]*\n" { set x [expr $x+1] } | |
342 | -re "^ +\[0-9\]+ 02c4 C0045FE7\[^\n\]*\n" { set x [expr $x+1] } | |
343 | -re "^ +\[0-9\]+ 02c8 C004DFDF\[^\n\]*\n" { set x [expr $x+1] } | |
344 | -re "^ +\[0-9\]+ 02cc C4A45FD5\[^\n\]*\n" { set x [expr $x+1] } | |
345 | -re "^ +\[0-9\]+ 02d0 C4A4DFCD\[^\n\]*\n" { set x [expr $x+1] } | |
346 | -re "^ +\[0-9\]+ 02d4 C4A45FC7\[^\n\]*\n" { set x [expr $x+1] } | |
347 | -re "^ +\[0-9\]+ 02d8 C4A4DFBF\[^\n\]*\n" { set x [expr $x+1] } | |
348 | -re "\[^\n\]*\n" { } | |
349 | timeout { perror "timeout\n"; break } | |
350 | eof { break } | |
351 | } | |
352 | } | |
353 | ||
354 | # This was intended to do any cleanup necessary. It kinda looks like it | |
355 | # isn't needed, but just in case, please keep it in for now. | |
356 | gas_finish | |
357 | ||
358 | # Did we find what we were looking for? If not, flunk it. | |
359 | if [expr $x==183] then { pass $testname } else { fail $testname } | |
360 | } | |
361 | ||
362 | proc do_add {} { | |
363 | set testname "add.s: add tests" | |
364 | set x 0 | |
365 | ||
366 | gas_start "add.s" "-al" | |
367 | ||
368 | # Check the assembled instruction against a table built by the HP assembler | |
369 | # Any differences should be checked by hand -- with the number of problems | |
370 | # I've seen in the HP assembler I don't completely trust it. | |
371 | # | |
372 | # Instead of having a variable for each match string just increment the | |
373 | # total number of matches seen. That's simpler when testing large numbers | |
374 | # of instructions (as these tests to). | |
375 | while 1 { | |
376 | expect { | |
377 | -re "^ +\[0-9\]+ 0000 08A40606\[^\n\]*\n" { set x [expr $x+1] } | |
378 | -re "^ +\[0-9\]+ 0004 08A42606\[^\n\]*\n" { set x [expr $x+1] } | |
379 | -re "^ +\[0-9\]+ 0008 08A44606\[^\n\]*\n" { set x [expr $x+1] } | |
380 | -re "^ +\[0-9\]+ 000c 08A46606\[^\n\]*\n" { set x [expr $x+1] } | |
381 | -re "^ +\[0-9\]+ 0010 08A48606\[^\n\]*\n" { set x [expr $x+1] } | |
382 | -re "^ +\[0-9\]+ 0014 08A4A606\[^\n\]*\n" { set x [expr $x+1] } | |
383 | -re "^ +\[0-9\]+ 0018 08A4C606\[^\n\]*\n" { set x [expr $x+1] } | |
384 | -re "^ +\[0-9\]+ 001c 08A4E606\[^\n\]*\n" { set x [expr $x+1] } | |
385 | -re "^ +\[0-9\]+ 0020 08A41606\[^\n\]*\n" { set x [expr $x+1] } | |
386 | -re "^ +\[0-9\]+ 0024 08A43606\[^\n\]*\n" { set x [expr $x+1] } | |
387 | -re "^ +\[0-9\]+ 0028 08A45606\[^\n\]*\n" { set x [expr $x+1] } | |
388 | -re "^ +\[0-9\]+ 002c 08A47606\[^\n\]*\n" { set x [expr $x+1] } | |
389 | -re "^ +\[0-9\]+ 0030 08A49606\[^\n\]*\n" { set x [expr $x+1] } | |
390 | -re "^ +\[0-9\]+ 0034 08A4B606\[^\n\]*\n" { set x [expr $x+1] } | |
391 | -re "^ +\[0-9\]+ 0038 08A4D606\[^\n\]*\n" { set x [expr $x+1] } | |
392 | -re "^ +\[0-9\]+ 003c 08A4F606\[^\n\]*\n" { set x [expr $x+1] } | |
393 | -re "^ +\[0-9\]+ 0040 08A40A06\[^\n\]*\n" { set x [expr $x+1] } | |
394 | -re "^ +\[0-9\]+ 0044 08A42A06\[^\n\]*\n" { set x [expr $x+1] } | |
395 | -re "^ +\[0-9\]+ 0048 08A44A06\[^\n\]*\n" { set x [expr $x+1] } | |
396 | -re "^ +\[0-9\]+ 004c 08A46A06\[^\n\]*\n" { set x [expr $x+1] } | |
397 | -re "^ +\[0-9\]+ 0050 08A48A06\[^\n\]*\n" { set x [expr $x+1] } | |
398 | -re "^ +\[0-9\]+ 0054 08A4AA06\[^\n\]*\n" { set x [expr $x+1] } | |
399 | -re "^ +\[0-9\]+ 0058 08A4CA06\[^\n\]*\n" { set x [expr $x+1] } | |
400 | -re "^ +\[0-9\]+ 005c 08A4EA06\[^\n\]*\n" { set x [expr $x+1] } | |
401 | -re "^ +\[0-9\]+ 0060 08A41A06\[^\n\]*\n" { set x [expr $x+1] } | |
402 | -re "^ +\[0-9\]+ 0064 08A43A06\[^\n\]*\n" { set x [expr $x+1] } | |
403 | -re "^ +\[0-9\]+ 0068 08A45A06\[^\n\]*\n" { set x [expr $x+1] } | |
404 | -re "^ +\[0-9\]+ 006c 08A47A06\[^\n\]*\n" { set x [expr $x+1] } | |
405 | -re "^ +\[0-9\]+ 0070 08A49A06\[^\n\]*\n" { set x [expr $x+1] } | |
406 | -re "^ +\[0-9\]+ 0074 08A4BA06\[^\n\]*\n" { set x [expr $x+1] } | |
407 | -re "^ +\[0-9\]+ 0078 08A4DA06\[^\n\]*\n" { set x [expr $x+1] } | |
408 | -re "^ +\[0-9\]+ 007c 08A4FA06\[^\n\]*\n" { set x [expr $x+1] } | |
409 | -re "^ +\[0-9\]+ 0080 08A40E06\[^\n\]*\n" { set x [expr $x+1] } | |
410 | -re "^ +\[0-9\]+ 0084 08A42E06\[^\n\]*\n" { set x [expr $x+1] } | |
411 | -re "^ +\[0-9\]+ 0088 08A44E06\[^\n\]*\n" { set x [expr $x+1] } | |
412 | -re "^ +\[0-9\]+ 008c 08A46E06\[^\n\]*\n" { set x [expr $x+1] } | |
413 | -re "^ +\[0-9\]+ 0090 08A48E06\[^\n\]*\n" { set x [expr $x+1] } | |
414 | -re "^ +\[0-9\]+ 0094 08A4AE06\[^\n\]*\n" { set x [expr $x+1] } | |
415 | -re "^ +\[0-9\]+ 0098 08A4CE06\[^\n\]*\n" { set x [expr $x+1] } | |
416 | -re "^ +\[0-9\]+ 009c 08A4EE06\[^\n\]*\n" { set x [expr $x+1] } | |
417 | -re "^ +\[0-9\]+ 00a0 08A41E06\[^\n\]*\n" { set x [expr $x+1] } | |
418 | -re "^ +\[0-9\]+ 00a4 08A43E06\[^\n\]*\n" { set x [expr $x+1] } | |
419 | -re "^ +\[0-9\]+ 00a8 08A45E06\[^\n\]*\n" { set x [expr $x+1] } | |
420 | -re "^ +\[0-9\]+ 00ac 08A47E06\[^\n\]*\n" { set x [expr $x+1] } | |
421 | -re "^ +\[0-9\]+ 00b0 08A49E06\[^\n\]*\n" { set x [expr $x+1] } | |
422 | -re "^ +\[0-9\]+ 00b4 08A4BE06\[^\n\]*\n" { set x [expr $x+1] } | |
423 | -re "^ +\[0-9\]+ 00b8 08A4DE06\[^\n\]*\n" { set x [expr $x+1] } | |
424 | -re "^ +\[0-9\]+ 00bc 08A4FE06\[^\n\]*\n" { set x [expr $x+1] } | |
425 | -re "^ +\[0-9\]+ 00c0 08A40706\[^\n\]*\n" { set x [expr $x+1] } | |
426 | -re "^ +\[0-9\]+ 00c4 08A42706\[^\n\]*\n" { set x [expr $x+1] } | |
427 | -re "^ +\[0-9\]+ 00c8 08A44706\[^\n\]*\n" { set x [expr $x+1] } | |
428 | -re "^ +\[0-9\]+ 00cc 08A46706\[^\n\]*\n" { set x [expr $x+1] } | |
429 | -re "^ +\[0-9\]+ 00d0 08A48706\[^\n\]*\n" { set x [expr $x+1] } | |
430 | -re "^ +\[0-9\]+ 00d4 08A4A706\[^\n\]*\n" { set x [expr $x+1] } | |
431 | -re "^ +\[0-9\]+ 00d8 08A4C706\[^\n\]*\n" { set x [expr $x+1] } | |
432 | -re "^ +\[0-9\]+ 00dc 08A4E706\[^\n\]*\n" { set x [expr $x+1] } | |
433 | -re "^ +\[0-9\]+ 00e0 08A41706\[^\n\]*\n" { set x [expr $x+1] } | |
434 | -re "^ +\[0-9\]+ 00e4 08A43706\[^\n\]*\n" { set x [expr $x+1] } | |
435 | -re "^ +\[0-9\]+ 00e8 08A45706\[^\n\]*\n" { set x [expr $x+1] } | |
436 | -re "^ +\[0-9\]+ 00ec 08A47706\[^\n\]*\n" { set x [expr $x+1] } | |
437 | -re "^ +\[0-9\]+ 00f0 08A49706\[^\n\]*\n" { set x [expr $x+1] } | |
438 | -re "^ +\[0-9\]+ 00f4 08A4B706\[^\n\]*\n" { set x [expr $x+1] } | |
439 | -re "^ +\[0-9\]+ 00f8 08A4D706\[^\n\]*\n" { set x [expr $x+1] } | |
440 | -re "^ +\[0-9\]+ 00fc 08A4F706\[^\n\]*\n" { set x [expr $x+1] } | |
441 | -re "^ +\[0-9\]+ 0100 08A40F06\[^\n\]*\n" { set x [expr $x+1] } | |
442 | -re "^ +\[0-9\]+ 0104 08A42F06\[^\n\]*\n" { set x [expr $x+1] } | |
443 | -re "^ +\[0-9\]+ 0108 08A44F06\[^\n\]*\n" { set x [expr $x+1] } | |
444 | -re "^ +\[0-9\]+ 010c 08A46F06\[^\n\]*\n" { set x [expr $x+1] } | |
445 | -re "^ +\[0-9\]+ 0110 08A48F06\[^\n\]*\n" { set x [expr $x+1] } | |
446 | -re "^ +\[0-9\]+ 0114 08A4AF06\[^\n\]*\n" { set x [expr $x+1] } | |
447 | -re "^ +\[0-9\]+ 0118 08A4CF06\[^\n\]*\n" { set x [expr $x+1] } | |
448 | -re "^ +\[0-9\]+ 011c 08A4EF06\[^\n\]*\n" { set x [expr $x+1] } | |
449 | -re "^ +\[0-9\]+ 0120 08A41F06\[^\n\]*\n" { set x [expr $x+1] } | |
450 | -re "^ +\[0-9\]+ 0124 08A43F06\[^\n\]*\n" { set x [expr $x+1] } | |
451 | -re "^ +\[0-9\]+ 0128 08A45F06\[^\n\]*\n" { set x [expr $x+1] } | |
452 | -re "^ +\[0-9\]+ 012c 08A47F06\[^\n\]*\n" { set x [expr $x+1] } | |
453 | -re "^ +\[0-9\]+ 0130 08A49F06\[^\n\]*\n" { set x [expr $x+1] } | |
454 | -re "^ +\[0-9\]+ 0134 08A4BF06\[^\n\]*\n" { set x [expr $x+1] } | |
455 | -re "^ +\[0-9\]+ 0138 08A4DF06\[^\n\]*\n" { set x [expr $x+1] } | |
456 | -re "^ +\[0-9\]+ 013c 08A4FF06\[^\n\]*\n" { set x [expr $x+1] } | |
457 | -re "\[^\n\]*\n" { } | |
458 | timeout { perror "timeout\n"; break } | |
459 | eof { break } | |
460 | } | |
461 | } | |
462 | ||
463 | # This was intended to do any cleanup necessary. It kinda looks like it | |
464 | # isn't needed, but just in case, please keep it in for now. | |
465 | gas_finish | |
466 | ||
467 | # Did we find what we were looking for? If not, flunk it. | |
468 | if [expr $x==80] then { pass $testname } else { fail $testname } | |
469 | } | |
470 | ||
471 | proc do_sh1add {} { | |
472 | set testname "sh1add.s: sh1add tests" | |
473 | set x 0 | |
474 | ||
475 | gas_start "sh1add.s" "-al" | |
476 | ||
477 | # Check the assembled instruction against a table built by the HP assembler | |
478 | # Any differences should be checked by hand -- with the number of problems | |
479 | # I've seen in the HP assembler I don't completely trust it. | |
480 | # | |
481 | # Instead of having a variable for each match string just increment the | |
482 | # total number of matches seen. That's simpler when testing large numbers | |
483 | # of instructions (as these tests to). | |
484 | while 1 { | |
485 | expect { | |
486 | -re "^ +\[0-9\]+ 0000 08A40646\[^\n\]*\n" { set x [expr $x+1] } | |
487 | -re "^ +\[0-9\]+ 0004 08A42646\[^\n\]*\n" { set x [expr $x+1] } | |
488 | -re "^ +\[0-9\]+ 0008 08A44646\[^\n\]*\n" { set x [expr $x+1] } | |
489 | -re "^ +\[0-9\]+ 000c 08A46646\[^\n\]*\n" { set x [expr $x+1] } | |
490 | -re "^ +\[0-9\]+ 0010 08A48646\[^\n\]*\n" { set x [expr $x+1] } | |
491 | -re "^ +\[0-9\]+ 0014 08A4A646\[^\n\]*\n" { set x [expr $x+1] } | |
492 | -re "^ +\[0-9\]+ 0018 08A4C646\[^\n\]*\n" { set x [expr $x+1] } | |
493 | -re "^ +\[0-9\]+ 001c 08A4E646\[^\n\]*\n" { set x [expr $x+1] } | |
494 | -re "^ +\[0-9\]+ 0020 08A41646\[^\n\]*\n" { set x [expr $x+1] } | |
495 | -re "^ +\[0-9\]+ 0024 08A43646\[^\n\]*\n" { set x [expr $x+1] } | |
496 | -re "^ +\[0-9\]+ 0028 08A45646\[^\n\]*\n" { set x [expr $x+1] } | |
497 | -re "^ +\[0-9\]+ 002c 08A47646\[^\n\]*\n" { set x [expr $x+1] } | |
498 | -re "^ +\[0-9\]+ 0030 08A49646\[^\n\]*\n" { set x [expr $x+1] } | |
499 | -re "^ +\[0-9\]+ 0034 08A4B646\[^\n\]*\n" { set x [expr $x+1] } | |
500 | -re "^ +\[0-9\]+ 0038 08A4D646\[^\n\]*\n" { set x [expr $x+1] } | |
501 | -re "^ +\[0-9\]+ 003c 08A4F646\[^\n\]*\n" { set x [expr $x+1] } | |
502 | -re "^ +\[0-9\]+ 0040 08A40A46\[^\n\]*\n" { set x [expr $x+1] } | |
503 | -re "^ +\[0-9\]+ 0044 08A42A46\[^\n\]*\n" { set x [expr $x+1] } | |
504 | -re "^ +\[0-9\]+ 0048 08A44A46\[^\n\]*\n" { set x [expr $x+1] } | |
505 | -re "^ +\[0-9\]+ 004c 08A46A46\[^\n\]*\n" { set x [expr $x+1] } | |
506 | -re "^ +\[0-9\]+ 0050 08A48A46\[^\n\]*\n" { set x [expr $x+1] } | |
507 | -re "^ +\[0-9\]+ 0054 08A4AA46\[^\n\]*\n" { set x [expr $x+1] } | |
508 | -re "^ +\[0-9\]+ 0058 08A4CA46\[^\n\]*\n" { set x [expr $x+1] } | |
509 | -re "^ +\[0-9\]+ 005c 08A4EA46\[^\n\]*\n" { set x [expr $x+1] } | |
510 | -re "^ +\[0-9\]+ 0060 08A41A46\[^\n\]*\n" { set x [expr $x+1] } | |
511 | -re "^ +\[0-9\]+ 0064 08A43A46\[^\n\]*\n" { set x [expr $x+1] } | |
512 | -re "^ +\[0-9\]+ 0068 08A45A46\[^\n\]*\n" { set x [expr $x+1] } | |
513 | -re "^ +\[0-9\]+ 006c 08A47A46\[^\n\]*\n" { set x [expr $x+1] } | |
514 | -re "^ +\[0-9\]+ 0070 08A49A46\[^\n\]*\n" { set x [expr $x+1] } | |
515 | -re "^ +\[0-9\]+ 0074 08A4BA46\[^\n\]*\n" { set x [expr $x+1] } | |
516 | -re "^ +\[0-9\]+ 0078 08A4DA46\[^\n\]*\n" { set x [expr $x+1] } | |
517 | -re "^ +\[0-9\]+ 007c 08A4FA46\[^\n\]*\n" { set x [expr $x+1] } | |
518 | -re "^ +\[0-9\]+ 0080 08A40E46\[^\n\]*\n" { set x [expr $x+1] } | |
519 | -re "^ +\[0-9\]+ 0084 08A42E46\[^\n\]*\n" { set x [expr $x+1] } | |
520 | -re "^ +\[0-9\]+ 0088 08A44E46\[^\n\]*\n" { set x [expr $x+1] } | |
521 | -re "^ +\[0-9\]+ 008c 08A46E46\[^\n\]*\n" { set x [expr $x+1] } | |
522 | -re "^ +\[0-9\]+ 0090 08A48E46\[^\n\]*\n" { set x [expr $x+1] } | |
523 | -re "^ +\[0-9\]+ 0094 08A4AE46\[^\n\]*\n" { set x [expr $x+1] } | |
524 | -re "^ +\[0-9\]+ 0098 08A4CE46\[^\n\]*\n" { set x [expr $x+1] } | |
525 | -re "^ +\[0-9\]+ 009c 08A4EE46\[^\n\]*\n" { set x [expr $x+1] } | |
526 | -re "^ +\[0-9\]+ 00a0 08A41E46\[^\n\]*\n" { set x [expr $x+1] } | |
527 | -re "^ +\[0-9\]+ 00a4 08A43E46\[^\n\]*\n" { set x [expr $x+1] } | |
528 | -re "^ +\[0-9\]+ 00a8 08A45E46\[^\n\]*\n" { set x [expr $x+1] } | |
529 | -re "^ +\[0-9\]+ 00ac 08A47E46\[^\n\]*\n" { set x [expr $x+1] } | |
530 | -re "^ +\[0-9\]+ 00b0 08A49E46\[^\n\]*\n" { set x [expr $x+1] } | |
531 | -re "^ +\[0-9\]+ 00b4 08A4BE46\[^\n\]*\n" { set x [expr $x+1] } | |
532 | -re "^ +\[0-9\]+ 00b8 08A4DE46\[^\n\]*\n" { set x [expr $x+1] } | |
533 | -re "^ +\[0-9\]+ 00bc 08A4FE46\[^\n\]*\n" { set x [expr $x+1] } | |
534 | -re "\[^\n\]*\n" { } | |
535 | timeout { perror "timeout\n"; break } | |
536 | eof { break } | |
537 | } | |
538 | } | |
539 | ||
540 | # This was intended to do any cleanup necessary. It kinda looks like it | |
541 | # isn't needed, but just in case, please keep it in for now. | |
542 | gas_finish | |
543 | ||
544 | # Did we find what we were looking for? If not, flunk it. | |
545 | if [expr $x==48] then { pass $testname } else { fail $testname } | |
546 | } | |
547 | ||
548 | proc do_sh2add {} { | |
549 | set testname "sh2add.s: sh2add tests" | |
550 | set x 0 | |
551 | ||
552 | gas_start "sh2add.s" "-al" | |
553 | ||
554 | # Check the assembled instruction against a table built by the HP assembler | |
555 | # Any differences should be checked by hand -- with the number of problems | |
556 | # I've seen in the HP assembler I don't completely trust it. | |
557 | # | |
558 | # Instead of having a variable for each match string just increment the | |
559 | # total number of matches seen. That's simpler when testing large numbers | |
560 | # of instructions (as these tests to). | |
561 | while 1 { | |
562 | expect { | |
563 | -re "^ +\[0-9\]+ 0000 08A40686\[^\n\]*\n" { set x [expr $x+1] } | |
564 | -re "^ +\[0-9\]+ 0004 08A42686\[^\n\]*\n" { set x [expr $x+1] } | |
565 | -re "^ +\[0-9\]+ 0008 08A44686\[^\n\]*\n" { set x [expr $x+1] } | |
566 | -re "^ +\[0-9\]+ 000c 08A46686\[^\n\]*\n" { set x [expr $x+1] } | |
567 | -re "^ +\[0-9\]+ 0010 08A48686\[^\n\]*\n" { set x [expr $x+1] } | |
568 | -re "^ +\[0-9\]+ 0014 08A4A686\[^\n\]*\n" { set x [expr $x+1] } | |
569 | -re "^ +\[0-9\]+ 0018 08A4C686\[^\n\]*\n" { set x [expr $x+1] } | |
570 | -re "^ +\[0-9\]+ 001c 08A4E686\[^\n\]*\n" { set x [expr $x+1] } | |
571 | -re "^ +\[0-9\]+ 0020 08A41686\[^\n\]*\n" { set x [expr $x+1] } | |
572 | -re "^ +\[0-9\]+ 0024 08A43686\[^\n\]*\n" { set x [expr $x+1] } | |
573 | -re "^ +\[0-9\]+ 0028 08A45686\[^\n\]*\n" { set x [expr $x+1] } | |
574 | -re "^ +\[0-9\]+ 002c 08A47686\[^\n\]*\n" { set x [expr $x+1] } | |
575 | -re "^ +\[0-9\]+ 0030 08A49686\[^\n\]*\n" { set x [expr $x+1] } | |
576 | -re "^ +\[0-9\]+ 0034 08A4B686\[^\n\]*\n" { set x [expr $x+1] } | |
577 | -re "^ +\[0-9\]+ 0038 08A4D686\[^\n\]*\n" { set x [expr $x+1] } | |
578 | -re "^ +\[0-9\]+ 003c 08A4F686\[^\n\]*\n" { set x [expr $x+1] } | |
579 | -re "^ +\[0-9\]+ 0040 08A40A86\[^\n\]*\n" { set x [expr $x+1] } | |
580 | -re "^ +\[0-9\]+ 0044 08A42A86\[^\n\]*\n" { set x [expr $x+1] } | |
581 | -re "^ +\[0-9\]+ 0048 08A44A86\[^\n\]*\n" { set x [expr $x+1] } | |
582 | -re "^ +\[0-9\]+ 004c 08A46A86\[^\n\]*\n" { set x [expr $x+1] } | |
583 | -re "^ +\[0-9\]+ 0050 08A48A86\[^\n\]*\n" { set x [expr $x+1] } | |
584 | -re "^ +\[0-9\]+ 0054 08A4AA86\[^\n\]*\n" { set x [expr $x+1] } | |
585 | -re "^ +\[0-9\]+ 0058 08A4CA86\[^\n\]*\n" { set x [expr $x+1] } | |
586 | -re "^ +\[0-9\]+ 005c 08A4EA86\[^\n\]*\n" { set x [expr $x+1] } | |
587 | -re "^ +\[0-9\]+ 0060 08A41A86\[^\n\]*\n" { set x [expr $x+1] } | |
588 | -re "^ +\[0-9\]+ 0064 08A43A86\[^\n\]*\n" { set x [expr $x+1] } | |
589 | -re "^ +\[0-9\]+ 0068 08A45A86\[^\n\]*\n" { set x [expr $x+1] } | |
590 | -re "^ +\[0-9\]+ 006c 08A47A86\[^\n\]*\n" { set x [expr $x+1] } | |
591 | -re "^ +\[0-9\]+ 0070 08A49A86\[^\n\]*\n" { set x [expr $x+1] } | |
592 | -re "^ +\[0-9\]+ 0074 08A4BA86\[^\n\]*\n" { set x [expr $x+1] } | |
593 | -re "^ +\[0-9\]+ 0078 08A4DA86\[^\n\]*\n" { set x [expr $x+1] } | |
594 | -re "^ +\[0-9\]+ 007c 08A4FA86\[^\n\]*\n" { set x [expr $x+1] } | |
595 | -re "^ +\[0-9\]+ 0080 08A40E86\[^\n\]*\n" { set x [expr $x+1] } | |
596 | -re "^ +\[0-9\]+ 0084 08A42E86\[^\n\]*\n" { set x [expr $x+1] } | |
597 | -re "^ +\[0-9\]+ 0088 08A44E86\[^\n\]*\n" { set x [expr $x+1] } | |
598 | -re "^ +\[0-9\]+ 008c 08A46E86\[^\n\]*\n" { set x [expr $x+1] } | |
599 | -re "^ +\[0-9\]+ 0090 08A48E86\[^\n\]*\n" { set x [expr $x+1] } | |
600 | -re "^ +\[0-9\]+ 0094 08A4AE86\[^\n\]*\n" { set x [expr $x+1] } | |
601 | -re "^ +\[0-9\]+ 0098 08A4CE86\[^\n\]*\n" { set x [expr $x+1] } | |
602 | -re "^ +\[0-9\]+ 009c 08A4EE86\[^\n\]*\n" { set x [expr $x+1] } | |
603 | -re "^ +\[0-9\]+ 00a0 08A41E86\[^\n\]*\n" { set x [expr $x+1] } | |
604 | -re "^ +\[0-9\]+ 00a4 08A43E86\[^\n\]*\n" { set x [expr $x+1] } | |
605 | -re "^ +\[0-9\]+ 00a8 08A45E86\[^\n\]*\n" { set x [expr $x+1] } | |
606 | -re "^ +\[0-9\]+ 00ac 08A47E86\[^\n\]*\n" { set x [expr $x+1] } | |
607 | -re "^ +\[0-9\]+ 00b0 08A49E86\[^\n\]*\n" { set x [expr $x+1] } | |
608 | -re "^ +\[0-9\]+ 00b4 08A4BE86\[^\n\]*\n" { set x [expr $x+1] } | |
609 | -re "^ +\[0-9\]+ 00b8 08A4DE86\[^\n\]*\n" { set x [expr $x+1] } | |
610 | -re "^ +\[0-9\]+ 00bc 08A4FE86\[^\n\]*\n" { set x [expr $x+1] } | |
611 | -re "\[^\n\]*\n" { } | |
612 | timeout { perror "timeout\n"; break } | |
613 | eof { break } | |
614 | } | |
615 | } | |
616 | ||
617 | # This was intended to do any cleanup necessary. It kinda looks like it | |
618 | # isn't needed, but just in case, please keep it in for now. | |
619 | gas_finish | |
620 | ||
621 | # Did we find what we were looking for? If not, flunk it. | |
622 | if [expr $x==48] then { pass $testname } else { fail $testname } | |
623 | } | |
624 | ||
625 | proc do_sh3add {} { | |
626 | set testname "sh3add.s: sh3add tests" | |
627 | set x 0 | |
628 | ||
629 | gas_start "sh3add.s" "-al" | |
630 | ||
631 | # Check the assembled instruction against a table built by the HP assembler | |
632 | # Any differences should be checked by hand -- with the number of problems | |
633 | # I've seen in the HP assembler I don't completely trust it. | |
634 | # | |
635 | # Instead of having a variable for each match string just increment the | |
636 | # total number of matches seen. That's simpler when testing large numbers | |
637 | # of instructions (as these tests to). | |
638 | while 1 { | |
639 | expect { | |
640 | -re "^ +\[0-9\]+ 0000 08A406C6\[^\n\]*\n" { set x [expr $x+1] } | |
641 | -re "^ +\[0-9\]+ 0004 08A426C6\[^\n\]*\n" { set x [expr $x+1] } | |
642 | -re "^ +\[0-9\]+ 0008 08A446C6\[^\n\]*\n" { set x [expr $x+1] } | |
643 | -re "^ +\[0-9\]+ 000c 08A466C6\[^\n\]*\n" { set x [expr $x+1] } | |
644 | -re "^ +\[0-9\]+ 0010 08A486C6\[^\n\]*\n" { set x [expr $x+1] } | |
645 | -re "^ +\[0-9\]+ 0014 08A4A6C6\[^\n\]*\n" { set x [expr $x+1] } | |
646 | -re "^ +\[0-9\]+ 0018 08A4C6C6\[^\n\]*\n" { set x [expr $x+1] } | |
647 | -re "^ +\[0-9\]+ 001c 08A4E6C6\[^\n\]*\n" { set x [expr $x+1] } | |
648 | -re "^ +\[0-9\]+ 0020 08A416C6\[^\n\]*\n" { set x [expr $x+1] } | |
649 | -re "^ +\[0-9\]+ 0024 08A436C6\[^\n\]*\n" { set x [expr $x+1] } | |
650 | -re "^ +\[0-9\]+ 0028 08A456C6\[^\n\]*\n" { set x [expr $x+1] } | |
651 | -re "^ +\[0-9\]+ 002c 08A476C6\[^\n\]*\n" { set x [expr $x+1] } | |
652 | -re "^ +\[0-9\]+ 0030 08A496C6\[^\n\]*\n" { set x [expr $x+1] } | |
653 | -re "^ +\[0-9\]+ 0034 08A4B6C6\[^\n\]*\n" { set x [expr $x+1] } | |
654 | -re "^ +\[0-9\]+ 0038 08A4D6C6\[^\n\]*\n" { set x [expr $x+1] } | |
655 | -re "^ +\[0-9\]+ 003c 08A4F6C6\[^\n\]*\n" { set x [expr $x+1] } | |
656 | -re "^ +\[0-9\]+ 0040 08A40AC6\[^\n\]*\n" { set x [expr $x+1] } | |
657 | -re "^ +\[0-9\]+ 0044 08A42AC6\[^\n\]*\n" { set x [expr $x+1] } | |
658 | -re "^ +\[0-9\]+ 0048 08A44AC6\[^\n\]*\n" { set x [expr $x+1] } | |
659 | -re "^ +\[0-9\]+ 004c 08A46AC6\[^\n\]*\n" { set x [expr $x+1] } | |
660 | -re "^ +\[0-9\]+ 0050 08A48AC6\[^\n\]*\n" { set x [expr $x+1] } | |
661 | -re "^ +\[0-9\]+ 0054 08A4AAC6\[^\n\]*\n" { set x [expr $x+1] } | |
662 | -re "^ +\[0-9\]+ 0058 08A4CAC6\[^\n\]*\n" { set x [expr $x+1] } | |
663 | -re "^ +\[0-9\]+ 005c 08A4EAC6\[^\n\]*\n" { set x [expr $x+1] } | |
664 | -re "^ +\[0-9\]+ 0060 08A41AC6\[^\n\]*\n" { set x [expr $x+1] } | |
665 | -re "^ +\[0-9\]+ 0064 08A43AC6\[^\n\]*\n" { set x [expr $x+1] } | |
666 | -re "^ +\[0-9\]+ 0068 08A45AC6\[^\n\]*\n" { set x [expr $x+1] } | |
667 | -re "^ +\[0-9\]+ 006c 08A47AC6\[^\n\]*\n" { set x [expr $x+1] } | |
668 | -re "^ +\[0-9\]+ 0070 08A49AC6\[^\n\]*\n" { set x [expr $x+1] } | |
669 | -re "^ +\[0-9\]+ 0074 08A4BAC6\[^\n\]*\n" { set x [expr $x+1] } | |
670 | -re "^ +\[0-9\]+ 0078 08A4DAC6\[^\n\]*\n" { set x [expr $x+1] } | |
671 | -re "^ +\[0-9\]+ 007c 08A4FAC6\[^\n\]*\n" { set x [expr $x+1] } | |
672 | -re "^ +\[0-9\]+ 0080 08A40EC6\[^\n\]*\n" { set x [expr $x+1] } | |
673 | -re "^ +\[0-9\]+ 0084 08A42EC6\[^\n\]*\n" { set x [expr $x+1] } | |
674 | -re "^ +\[0-9\]+ 0088 08A44EC6\[^\n\]*\n" { set x [expr $x+1] } | |
675 | -re "^ +\[0-9\]+ 008c 08A46EC6\[^\n\]*\n" { set x [expr $x+1] } | |
676 | -re "^ +\[0-9\]+ 0090 08A48EC6\[^\n\]*\n" { set x [expr $x+1] } | |
677 | -re "^ +\[0-9\]+ 0094 08A4AEC6\[^\n\]*\n" { set x [expr $x+1] } | |
678 | -re "^ +\[0-9\]+ 0098 08A4CEC6\[^\n\]*\n" { set x [expr $x+1] } | |
679 | -re "^ +\[0-9\]+ 009c 08A4EEC6\[^\n\]*\n" { set x [expr $x+1] } | |
680 | -re "^ +\[0-9\]+ 00a0 08A41EC6\[^\n\]*\n" { set x [expr $x+1] } | |
681 | -re "^ +\[0-9\]+ 00a4 08A43EC6\[^\n\]*\n" { set x [expr $x+1] } | |
682 | -re "^ +\[0-9\]+ 00a8 08A45EC6\[^\n\]*\n" { set x [expr $x+1] } | |
683 | -re "^ +\[0-9\]+ 00ac 08A47EC6\[^\n\]*\n" { set x [expr $x+1] } | |
684 | -re "^ +\[0-9\]+ 00b0 08A49EC6\[^\n\]*\n" { set x [expr $x+1] } | |
685 | -re "^ +\[0-9\]+ 00b4 08A4BEC6\[^\n\]*\n" { set x [expr $x+1] } | |
686 | -re "^ +\[0-9\]+ 00b8 08A4DEC6\[^\n\]*\n" { set x [expr $x+1] } | |
687 | -re "^ +\[0-9\]+ 00bc 08A4FEC6\[^\n\]*\n" { set x [expr $x+1] } | |
688 | -re "\[^\n\]*\n" { } | |
689 | timeout { perror "timeout\n"; break } | |
690 | eof { break } | |
691 | } | |
692 | } | |
693 | ||
694 | # This was intended to do any cleanup necessary. It kinda looks like it | |
695 | # isn't needed, but just in case, please keep it in for now. | |
696 | gas_finish | |
697 | ||
698 | # Did we find what we were looking for? If not, flunk it. | |
699 | if [expr $x==48] then { pass $testname } else { fail $testname } | |
700 | } | |
701 | ||
702 | proc do_sub {} { | |
703 | set testname "sub.s: sub tests" | |
704 | set x 0 | |
705 | ||
706 | gas_start "sub.s" "-al" | |
707 | ||
708 | # Check the assembled instruction against a table built by the HP assembler | |
709 | # Any differences should be checked by hand -- with the number of problems | |
710 | # I've seen in the HP assembler I don't completely trust it. | |
711 | # | |
712 | # Instead of having a variable for each match string just increment the | |
713 | # total number of matches seen. That's simpler when testing large numbers | |
714 | # of instructions (as these tests to). | |
715 | while 1 { | |
716 | expect { | |
717 | -re "^ +\[0-9\]+ 0000 08A40406\[^\n\]*\n" { set x [expr $x+1] } | |
718 | -re "^ +\[0-9\]+ 0004 08A42406\[^\n\]*\n" { set x [expr $x+1] } | |
719 | -re "^ +\[0-9\]+ 0008 08A44406\[^\n\]*\n" { set x [expr $x+1] } | |
720 | -re "^ +\[0-9\]+ 000c 08A46406\[^\n\]*\n" { set x [expr $x+1] } | |
721 | -re "^ +\[0-9\]+ 0010 08A48406\[^\n\]*\n" { set x [expr $x+1] } | |
722 | -re "^ +\[0-9\]+ 0014 08A4A406\[^\n\]*\n" { set x [expr $x+1] } | |
723 | -re "^ +\[0-9\]+ 0018 08A4C406\[^\n\]*\n" { set x [expr $x+1] } | |
724 | -re "^ +\[0-9\]+ 001c 08A4E406\[^\n\]*\n" { set x [expr $x+1] } | |
725 | -re "^ +\[0-9\]+ 0020 08A41406\[^\n\]*\n" { set x [expr $x+1] } | |
726 | -re "^ +\[0-9\]+ 0024 08A43406\[^\n\]*\n" { set x [expr $x+1] } | |
727 | -re "^ +\[0-9\]+ 0028 08A45406\[^\n\]*\n" { set x [expr $x+1] } | |
728 | -re "^ +\[0-9\]+ 002c 08A47406\[^\n\]*\n" { set x [expr $x+1] } | |
729 | -re "^ +\[0-9\]+ 0030 08A49406\[^\n\]*\n" { set x [expr $x+1] } | |
730 | -re "^ +\[0-9\]+ 0034 08A4B406\[^\n\]*\n" { set x [expr $x+1] } | |
731 | -re "^ +\[0-9\]+ 0038 08A4D406\[^\n\]*\n" { set x [expr $x+1] } | |
732 | -re "^ +\[0-9\]+ 003c 08A4F406\[^\n\]*\n" { set x [expr $x+1] } | |
733 | -re "^ +\[0-9\]+ 0040 08A40C06\[^\n\]*\n" { set x [expr $x+1] } | |
734 | -re "^ +\[0-9\]+ 0044 08A42C06\[^\n\]*\n" { set x [expr $x+1] } | |
735 | -re "^ +\[0-9\]+ 0048 08A44C06\[^\n\]*\n" { set x [expr $x+1] } | |
736 | -re "^ +\[0-9\]+ 004c 08A46C06\[^\n\]*\n" { set x [expr $x+1] } | |
737 | -re "^ +\[0-9\]+ 0050 08A48C06\[^\n\]*\n" { set x [expr $x+1] } | |
738 | -re "^ +\[0-9\]+ 0054 08A4AC06\[^\n\]*\n" { set x [expr $x+1] } | |
739 | -re "^ +\[0-9\]+ 0058 08A4CC06\[^\n\]*\n" { set x [expr $x+1] } | |
740 | -re "^ +\[0-9\]+ 005c 08A4EC06\[^\n\]*\n" { set x [expr $x+1] } | |
741 | -re "^ +\[0-9\]+ 0060 08A41C06\[^\n\]*\n" { set x [expr $x+1] } | |
742 | -re "^ +\[0-9\]+ 0064 08A43C06\[^\n\]*\n" { set x [expr $x+1] } | |
743 | -re "^ +\[0-9\]+ 0068 08A45C06\[^\n\]*\n" { set x [expr $x+1] } | |
744 | -re "^ +\[0-9\]+ 006c 08A47C06\[^\n\]*\n" { set x [expr $x+1] } | |
745 | -re "^ +\[0-9\]+ 0070 08A49C06\[^\n\]*\n" { set x [expr $x+1] } | |
746 | -re "^ +\[0-9\]+ 0074 08A4BC06\[^\n\]*\n" { set x [expr $x+1] } | |
747 | -re "^ +\[0-9\]+ 0078 08A4DC06\[^\n\]*\n" { set x [expr $x+1] } | |
748 | -re "^ +\[0-9\]+ 007c 08A4FC06\[^\n\]*\n" { set x [expr $x+1] } | |
749 | -re "^ +\[0-9\]+ 0080 08A40506\[^\n\]*\n" { set x [expr $x+1] } | |
750 | -re "^ +\[0-9\]+ 0084 08A42506\[^\n\]*\n" { set x [expr $x+1] } | |
751 | -re "^ +\[0-9\]+ 0088 08A44506\[^\n\]*\n" { set x [expr $x+1] } | |
752 | -re "^ +\[0-9\]+ 008c 08A46506\[^\n\]*\n" { set x [expr $x+1] } | |
753 | -re "^ +\[0-9\]+ 0090 08A48506\[^\n\]*\n" { set x [expr $x+1] } | |
754 | -re "^ +\[0-9\]+ 0094 08A4A506\[^\n\]*\n" { set x [expr $x+1] } | |
755 | -re "^ +\[0-9\]+ 0098 08A4C506\[^\n\]*\n" { set x [expr $x+1] } | |
756 | -re "^ +\[0-9\]+ 009c 08A4E506\[^\n\]*\n" { set x [expr $x+1] } | |
757 | -re "^ +\[0-9\]+ 00a0 08A41506\[^\n\]*\n" { set x [expr $x+1] } | |
758 | -re "^ +\[0-9\]+ 00a4 08A43506\[^\n\]*\n" { set x [expr $x+1] } | |
759 | -re "^ +\[0-9\]+ 00a8 08A45506\[^\n\]*\n" { set x [expr $x+1] } | |
760 | -re "^ +\[0-9\]+ 00ac 08A47506\[^\n\]*\n" { set x [expr $x+1] } | |
761 | -re "^ +\[0-9\]+ 00b0 08A49506\[^\n\]*\n" { set x [expr $x+1] } | |
762 | -re "^ +\[0-9\]+ 00b4 08A4B506\[^\n\]*\n" { set x [expr $x+1] } | |
763 | -re "^ +\[0-9\]+ 00b8 08A4D506\[^\n\]*\n" { set x [expr $x+1] } | |
764 | -re "^ +\[0-9\]+ 00bc 08A4F506\[^\n\]*\n" { set x [expr $x+1] } | |
765 | -re "^ +\[0-9\]+ 00c0 08A40D06\[^\n\]*\n" { set x [expr $x+1] } | |
766 | -re "^ +\[0-9\]+ 00c4 08A42D06\[^\n\]*\n" { set x [expr $x+1] } | |
767 | -re "^ +\[0-9\]+ 00c8 08A44D06\[^\n\]*\n" { set x [expr $x+1] } | |
768 | -re "^ +\[0-9\]+ 00cc 08A46D06\[^\n\]*\n" { set x [expr $x+1] } | |
769 | -re "^ +\[0-9\]+ 00d0 08A48D06\[^\n\]*\n" { set x [expr $x+1] } | |
770 | -re "^ +\[0-9\]+ 00d4 08A4AD06\[^\n\]*\n" { set x [expr $x+1] } | |
771 | -re "^ +\[0-9\]+ 00d8 08A4CD06\[^\n\]*\n" { set x [expr $x+1] } | |
772 | -re "^ +\[0-9\]+ 00dc 08A4ED06\[^\n\]*\n" { set x [expr $x+1] } | |
773 | -re "^ +\[0-9\]+ 00e0 08A41D06\[^\n\]*\n" { set x [expr $x+1] } | |
774 | -re "^ +\[0-9\]+ 00e4 08A43D06\[^\n\]*\n" { set x [expr $x+1] } | |
775 | -re "^ +\[0-9\]+ 00e8 08A45D06\[^\n\]*\n" { set x [expr $x+1] } | |
776 | -re "^ +\[0-9\]+ 00ec 08A47D06\[^\n\]*\n" { set x [expr $x+1] } | |
777 | -re "^ +\[0-9\]+ 00f0 08A49D06\[^\n\]*\n" { set x [expr $x+1] } | |
778 | -re "^ +\[0-9\]+ 00f4 08A4BD06\[^\n\]*\n" { set x [expr $x+1] } | |
779 | -re "^ +\[0-9\]+ 00f8 08A4DD06\[^\n\]*\n" { set x [expr $x+1] } | |
780 | -re "^ +\[0-9\]+ 00fc 08A4FD06\[^\n\]*\n" { set x [expr $x+1] } | |
781 | -re "^ +\[0-9\]+ 0100 08A404C6\[^\n\]*\n" { set x [expr $x+1] } | |
782 | -re "^ +\[0-9\]+ 0104 08A424C6\[^\n\]*\n" { set x [expr $x+1] } | |
783 | -re "^ +\[0-9\]+ 0108 08A444C6\[^\n\]*\n" { set x [expr $x+1] } | |
784 | -re "^ +\[0-9\]+ 010c 08A464C6\[^\n\]*\n" { set x [expr $x+1] } | |
785 | -re "^ +\[0-9\]+ 0110 08A484C6\[^\n\]*\n" { set x [expr $x+1] } | |
786 | -re "^ +\[0-9\]+ 0114 08A4A4C6\[^\n\]*\n" { set x [expr $x+1] } | |
787 | -re "^ +\[0-9\]+ 0118 08A4C4C6\[^\n\]*\n" { set x [expr $x+1] } | |
788 | -re "^ +\[0-9\]+ 011c 08A4E4C6\[^\n\]*\n" { set x [expr $x+1] } | |
789 | -re "^ +\[0-9\]+ 0120 08A414C6\[^\n\]*\n" { set x [expr $x+1] } | |
790 | -re "^ +\[0-9\]+ 0124 08A434C6\[^\n\]*\n" { set x [expr $x+1] } | |
791 | -re "^ +\[0-9\]+ 0128 08A454C6\[^\n\]*\n" { set x [expr $x+1] } | |
792 | -re "^ +\[0-9\]+ 012c 08A474C6\[^\n\]*\n" { set x [expr $x+1] } | |
793 | -re "^ +\[0-9\]+ 0130 08A494C6\[^\n\]*\n" { set x [expr $x+1] } | |
794 | -re "^ +\[0-9\]+ 0134 08A4B4C6\[^\n\]*\n" { set x [expr $x+1] } | |
795 | -re "^ +\[0-9\]+ 0138 08A4D4C6\[^\n\]*\n" { set x [expr $x+1] } | |
796 | -re "^ +\[0-9\]+ 013c 08A4F4C6\[^\n\]*\n" { set x [expr $x+1] } | |
797 | -re "^ +\[0-9\]+ 0140 08A40CC6\[^\n\]*\n" { set x [expr $x+1] } | |
798 | -re "^ +\[0-9\]+ 0144 08A42CC6\[^\n\]*\n" { set x [expr $x+1] } | |
799 | -re "^ +\[0-9\]+ 0148 08A44CC6\[^\n\]*\n" { set x [expr $x+1] } | |
800 | -re "^ +\[0-9\]+ 014c 08A46CC6\[^\n\]*\n" { set x [expr $x+1] } | |
801 | -re "^ +\[0-9\]+ 0150 08A48CC6\[^\n\]*\n" { set x [expr $x+1] } | |
802 | -re "^ +\[0-9\]+ 0154 08A4ACC6\[^\n\]*\n" { set x [expr $x+1] } | |
803 | -re "^ +\[0-9\]+ 0158 08A4CCC6\[^\n\]*\n" { set x [expr $x+1] } | |
804 | -re "^ +\[0-9\]+ 015c 08A4ECC6\[^\n\]*\n" { set x [expr $x+1] } | |
805 | -re "^ +\[0-9\]+ 0160 08A41CC6\[^\n\]*\n" { set x [expr $x+1] } | |
806 | -re "^ +\[0-9\]+ 0164 08A43CC6\[^\n\]*\n" { set x [expr $x+1] } | |
807 | -re "^ +\[0-9\]+ 0168 08A45CC6\[^\n\]*\n" { set x [expr $x+1] } | |
808 | -re "^ +\[0-9\]+ 016c 08A47CC6\[^\n\]*\n" { set x [expr $x+1] } | |
809 | -re "^ +\[0-9\]+ 0170 08A49CC6\[^\n\]*\n" { set x [expr $x+1] } | |
810 | -re "^ +\[0-9\]+ 0174 08A4BCC6\[^\n\]*\n" { set x [expr $x+1] } | |
811 | -re "^ +\[0-9\]+ 0178 08A4DCC6\[^\n\]*\n" { set x [expr $x+1] } | |
812 | -re "^ +\[0-9\]+ 017c 08A4FCC6\[^\n\]*\n" { set x [expr $x+1] } | |
813 | -re "\[^\n\]*\n" { } | |
814 | timeout { perror "timeout\n"; break } | |
815 | eof { break } | |
816 | } | |
817 | } | |
818 | ||
819 | # This was intended to do any cleanup necessary. It kinda looks like it | |
820 | # isn't needed, but just in case, please keep it in for now. | |
821 | gas_finish | |
822 | ||
823 | # Did we find what we were looking for? If not, flunk it. | |
824 | if [expr $x==96] then { pass $testname } else { fail $testname } | |
825 | } | |
826 | ||
827 | proc do_ds {} { | |
828 | set testname "ds.s: ds tests" | |
829 | set x 0 | |
830 | ||
831 | gas_start "ds.s" "-al" | |
832 | ||
833 | # Check the assembled instruction against a table built by the HP assembler | |
834 | # Any differences should be checked by hand -- with the number of problems | |
835 | # I've seen in the HP assembler I don't completely trust it. | |
836 | # | |
837 | # Instead of having a variable for each match string just increment the | |
838 | # total number of matches seen. That's simpler when testing large numbers | |
839 | # of instructions (as these tests to). | |
840 | while 1 { | |
841 | expect { | |
842 | -re "^ +\[0-9\]+ 0000 08A40446\[^\n\]*\n" { set x [expr $x+1] } | |
843 | -re "^ +\[0-9\]+ 0004 08A42446\[^\n\]*\n" { set x [expr $x+1] } | |
844 | -re "^ +\[0-9\]+ 0008 08A44446\[^\n\]*\n" { set x [expr $x+1] } | |
845 | -re "^ +\[0-9\]+ 000c 08A46446\[^\n\]*\n" { set x [expr $x+1] } | |
846 | -re "^ +\[0-9\]+ 0010 08A48446\[^\n\]*\n" { set x [expr $x+1] } | |
847 | -re "^ +\[0-9\]+ 0014 08A4A446\[^\n\]*\n" { set x [expr $x+1] } | |
848 | -re "^ +\[0-9\]+ 0018 08A4C446\[^\n\]*\n" { set x [expr $x+1] } | |
849 | -re "^ +\[0-9\]+ 001c 08A4E446\[^\n\]*\n" { set x [expr $x+1] } | |
850 | -re "^ +\[0-9\]+ 0020 08A41446\[^\n\]*\n" { set x [expr $x+1] } | |
851 | -re "^ +\[0-9\]+ 0024 08A43446\[^\n\]*\n" { set x [expr $x+1] } | |
852 | -re "^ +\[0-9\]+ 0028 08A45446\[^\n\]*\n" { set x [expr $x+1] } | |
853 | -re "^ +\[0-9\]+ 002c 08A47446\[^\n\]*\n" { set x [expr $x+1] } | |
854 | -re "^ +\[0-9\]+ 0030 08A49446\[^\n\]*\n" { set x [expr $x+1] } | |
855 | -re "^ +\[0-9\]+ 0034 08A4B446\[^\n\]*\n" { set x [expr $x+1] } | |
856 | -re "^ +\[0-9\]+ 0038 08A4D446\[^\n\]*\n" { set x [expr $x+1] } | |
857 | -re "^ +\[0-9\]+ 003c 08A4F446\[^\n\]*\n" { set x [expr $x+1] } | |
858 | -re "\[^\n\]*\n" { } | |
859 | timeout { perror "timeout\n"; break } | |
860 | eof { break } | |
861 | } | |
862 | } | |
863 | ||
864 | # This was intended to do any cleanup necessary. It kinda looks like it | |
865 | # isn't needed, but just in case, please keep it in for now. | |
866 | gas_finish | |
867 | ||
868 | # Did we find what we were looking for? If not, flunk it. | |
869 | if [expr $x==16] then { pass $testname } else { fail $testname } | |
870 | } | |
871 | ||
872 | proc do_comclr {} { | |
873 | set testname "comclr.s: comclr tests" | |
874 | set x 0 | |
875 | ||
876 | gas_start "comclr.s" "-al" | |
877 | ||
878 | # Check the assembled instruction against a table built by the HP assembler | |
879 | # Any differences should be checked by hand -- with the number of problems | |
880 | # I've seen in the HP assembler I don't completely trust it. | |
881 | # | |
882 | # Instead of having a variable for each match string just increment the | |
883 | # total number of matches seen. That's simpler when testing large numbers | |
884 | # of instructions (as these tests to). | |
885 | while 1 { | |
886 | expect { | |
887 | -re "^ +\[0-9\]+ 0000 08A40886\[^\n\]*\n" { set x [expr $x+1] } | |
888 | -re "^ +\[0-9\]+ 0004 08A42886\[^\n\]*\n" { set x [expr $x+1] } | |
889 | -re "^ +\[0-9\]+ 0008 08A44886\[^\n\]*\n" { set x [expr $x+1] } | |
890 | -re "^ +\[0-9\]+ 000c 08A46886\[^\n\]*\n" { set x [expr $x+1] } | |
891 | -re "^ +\[0-9\]+ 0010 08A48886\[^\n\]*\n" { set x [expr $x+1] } | |
892 | -re "^ +\[0-9\]+ 0014 08A4A886\[^\n\]*\n" { set x [expr $x+1] } | |
893 | -re "^ +\[0-9\]+ 0018 08A4C886\[^\n\]*\n" { set x [expr $x+1] } | |
894 | -re "^ +\[0-9\]+ 001c 08A4E886\[^\n\]*\n" { set x [expr $x+1] } | |
895 | -re "^ +\[0-9\]+ 0020 08A41886\[^\n\]*\n" { set x [expr $x+1] } | |
896 | -re "^ +\[0-9\]+ 0024 08A43886\[^\n\]*\n" { set x [expr $x+1] } | |
897 | -re "^ +\[0-9\]+ 0028 08A45886\[^\n\]*\n" { set x [expr $x+1] } | |
898 | -re "^ +\[0-9\]+ 002c 08A47886\[^\n\]*\n" { set x [expr $x+1] } | |
899 | -re "^ +\[0-9\]+ 0030 08A49886\[^\n\]*\n" { set x [expr $x+1] } | |
900 | -re "^ +\[0-9\]+ 0034 08A4B886\[^\n\]*\n" { set x [expr $x+1] } | |
901 | -re "^ +\[0-9\]+ 0038 08A4D886\[^\n\]*\n" { set x [expr $x+1] } | |
902 | -re "^ +\[0-9\]+ 003c 08A4F886\[^\n\]*\n" { set x [expr $x+1] } | |
903 | -re "^ +\[0-9\]+ 0040 90A600F6\[^\n\]*\n" { set x [expr $x+1] } | |
904 | -re "^ +\[0-9\]+ 0044 90A620F6\[^\n\]*\n" { set x [expr $x+1] } | |
905 | -re "^ +\[0-9\]+ 0048 90A640F6\[^\n\]*\n" { set x [expr $x+1] } | |
906 | -re "^ +\[0-9\]+ 004c 90A660F6\[^\n\]*\n" { set x [expr $x+1] } | |
907 | -re "^ +\[0-9\]+ 0050 90A680F6\[^\n\]*\n" { set x [expr $x+1] } | |
908 | -re "^ +\[0-9\]+ 0054 90A6A0F6\[^\n\]*\n" { set x [expr $x+1] } | |
909 | -re "^ +\[0-9\]+ 0058 90A6C0F6\[^\n\]*\n" { set x [expr $x+1] } | |
910 | -re "^ +\[0-9\]+ 005c 90A6E0F6\[^\n\]*\n" { set x [expr $x+1] } | |
911 | -re "^ +\[0-9\]+ 0060 90A610F6\[^\n\]*\n" { set x [expr $x+1] } | |
912 | -re "^ +\[0-9\]+ 0064 90A630F6\[^\n\]*\n" { set x [expr $x+1] } | |
913 | -re "^ +\[0-9\]+ 0068 90A650F6\[^\n\]*\n" { set x [expr $x+1] } | |
914 | -re "^ +\[0-9\]+ 006c 90A670F6\[^\n\]*\n" { set x [expr $x+1] } | |
915 | -re "^ +\[0-9\]+ 0070 90A690F6\[^\n\]*\n" { set x [expr $x+1] } | |
916 | -re "^ +\[0-9\]+ 0074 90A6B0F6\[^\n\]*\n" { set x [expr $x+1] } | |
917 | -re "^ +\[0-9\]+ 0078 90A6D0F6\[^\n\]*\n" { set x [expr $x+1] } | |
918 | -re "^ +\[0-9\]+ 007c 90A6F0F6\[^\n\]*\n" { set x [expr $x+1] } | |
919 | -re "\[^\n\]*\n" { } | |
920 | timeout { perror "timeout\n"; break } | |
921 | eof { break } | |
922 | } | |
923 | } | |
924 | ||
925 | # This was intended to do any cleanup necessary. It kinda looks like it | |
926 | # isn't needed, but just in case, please keep it in for now. | |
927 | gas_finish | |
928 | ||
929 | # Did we find what we were looking for? If not, flunk it. | |
930 | if [expr $x==32] then { pass $testname } else { fail $testname } | |
931 | } | |
932 | ||
933 | proc do_logical {} { | |
934 | set testname "logical.s: logical tests" | |
935 | set x 0 | |
936 | ||
937 | gas_start "logical.s" "-al" | |
938 | ||
939 | # Check the assembled instruction against a table built by the HP assembler | |
940 | # Any differences should be checked by hand -- with the number of problems | |
941 | # I've seen in the HP assembler I don't completely trust it. | |
942 | # | |
943 | # Instead of having a variable for each match string just increment the | |
944 | # total number of matches seen. That's simpler when testing large numbers | |
945 | # of instructions (as these tests to). | |
946 | while 1 { | |
947 | expect { | |
948 | -re "^ +\[0-9\]+ 0000 08A40246\[^\n\]*\n" { set x [expr $x+1] } | |
949 | -re "^ +\[0-9\]+ 0004 08A42246\[^\n\]*\n" { set x [expr $x+1] } | |
950 | -re "^ +\[0-9\]+ 0008 08A44246\[^\n\]*\n" { set x [expr $x+1] } | |
951 | -re "^ +\[0-9\]+ 000c 08A46246\[^\n\]*\n" { set x [expr $x+1] } | |
952 | -re "^ +\[0-9\]+ 0010 08A4E246\[^\n\]*\n" { set x [expr $x+1] } | |
953 | -re "^ +\[0-9\]+ 0014 08A41246\[^\n\]*\n" { set x [expr $x+1] } | |
954 | -re "^ +\[0-9\]+ 0018 08A43246\[^\n\]*\n" { set x [expr $x+1] } | |
955 | -re "^ +\[0-9\]+ 001c 08A45246\[^\n\]*\n" { set x [expr $x+1] } | |
956 | -re "^ +\[0-9\]+ 0020 08A47246\[^\n\]*\n" { set x [expr $x+1] } | |
957 | -re "^ +\[0-9\]+ 0024 08A4F246\[^\n\]*\n" { set x [expr $x+1] } | |
958 | -re "^ +\[0-9\]+ 0028 08A40286\[^\n\]*\n" { set x [expr $x+1] } | |
959 | -re "^ +\[0-9\]+ 002c 08A42286\[^\n\]*\n" { set x [expr $x+1] } | |
960 | -re "^ +\[0-9\]+ 0030 08A44286\[^\n\]*\n" { set x [expr $x+1] } | |
961 | -re "^ +\[0-9\]+ 0034 08A46286\[^\n\]*\n" { set x [expr $x+1] } | |
962 | -re "^ +\[0-9\]+ 0038 08A4E286\[^\n\]*\n" { set x [expr $x+1] } | |
963 | -re "^ +\[0-9\]+ 003c 08A41286\[^\n\]*\n" { set x [expr $x+1] } | |
964 | -re "^ +\[0-9\]+ 0040 08A43286\[^\n\]*\n" { set x [expr $x+1] } | |
965 | -re "^ +\[0-9\]+ 0044 08A45286\[^\n\]*\n" { set x [expr $x+1] } | |
966 | -re "^ +\[0-9\]+ 0048 08A47286\[^\n\]*\n" { set x [expr $x+1] } | |
967 | -re "^ +\[0-9\]+ 004c 08A4F286\[^\n\]*\n" { set x [expr $x+1] } | |
968 | -re "^ +\[0-9\]+ 0050 08A40206\[^\n\]*\n" { set x [expr $x+1] } | |
969 | -re "^ +\[0-9\]+ 0054 08A42206\[^\n\]*\n" { set x [expr $x+1] } | |
970 | -re "^ +\[0-9\]+ 0058 08A44206\[^\n\]*\n" { set x [expr $x+1] } | |
971 | -re "^ +\[0-9\]+ 005c 08A46206\[^\n\]*\n" { set x [expr $x+1] } | |
972 | -re "^ +\[0-9\]+ 0060 08A4E206\[^\n\]*\n" { set x [expr $x+1] } | |
973 | -re "^ +\[0-9\]+ 0064 08A41206\[^\n\]*\n" { set x [expr $x+1] } | |
974 | -re "^ +\[0-9\]+ 0068 08A43206\[^\n\]*\n" { set x [expr $x+1] } | |
975 | -re "^ +\[0-9\]+ 006c 08A45206\[^\n\]*\n" { set x [expr $x+1] } | |
976 | -re "^ +\[0-9\]+ 0070 08A47206\[^\n\]*\n" { set x [expr $x+1] } | |
977 | -re "^ +\[0-9\]+ 0074 08A4F206\[^\n\]*\n" { set x [expr $x+1] } | |
978 | -re "^ +\[0-9\]+ 0078 08A40006\[^\n\]*\n" { set x [expr $x+1] } | |
979 | -re "^ +\[0-9\]+ 007c 08A42006\[^\n\]*\n" { set x [expr $x+1] } | |
980 | -re "^ +\[0-9\]+ 0080 08A44006\[^\n\]*\n" { set x [expr $x+1] } | |
981 | -re "^ +\[0-9\]+ 0084 08A46006\[^\n\]*\n" { set x [expr $x+1] } | |
982 | -re "^ +\[0-9\]+ 0088 08A4E006\[^\n\]*\n" { set x [expr $x+1] } | |
983 | -re "^ +\[0-9\]+ 008c 08A41006\[^\n\]*\n" { set x [expr $x+1] } | |
984 | -re "^ +\[0-9\]+ 0090 08A43006\[^\n\]*\n" { set x [expr $x+1] } | |
985 | -re "^ +\[0-9\]+ 0094 08A45006\[^\n\]*\n" { set x [expr $x+1] } | |
986 | -re "^ +\[0-9\]+ 0098 08A47006\[^\n\]*\n" { set x [expr $x+1] } | |
987 | -re "^ +\[0-9\]+ 009c 08A4F006\[^\n\]*\n" { set x [expr $x+1] } | |
988 | -re "\[^\n\]*\n" { } | |
989 | timeout { perror "timeout\n"; break } | |
990 | eof { break } | |
991 | } | |
992 | } | |
993 | ||
994 | # This was intended to do any cleanup necessary. It kinda looks like it | |
995 | # isn't needed, but just in case, please keep it in for now. | |
996 | gas_finish | |
997 | ||
998 | # Did we find what we were looking for? If not, flunk it. | |
999 | if [expr $x==40] then { pass $testname } else { fail $testname } | |
1000 | } | |
1001 | ||
1002 | proc do_unit {} { | |
1003 | set testname "unit.s: unit tests" | |
1004 | set x 0 | |
1005 | ||
1006 | gas_start "unit.s" "-al" | |
1007 | ||
1008 | # Check the assembled instruction against a table built by the HP assembler | |
1009 | # Any differences should be checked by hand -- with the number of problems | |
1010 | # I've seen in the HP assembler I don't completely trust it. | |
1011 | # | |
1012 | # Instead of having a variable for each match string just increment the | |
1013 | # total number of matches seen. That's simpler when testing large numbers | |
1014 | # of instructions (as these tests to). | |
1015 | while 1 { | |
1016 | expect { | |
1017 | -re "^ +\[0-9\]+ 0000 08A40386\[^\n]*\n" { set x [expr $x+1] } | |
1018 | -re "^ +\[0-9\]+ 0004 08A44386\[^\n]*\n" { set x [expr $x+1] } | |
1019 | -re "^ +\[0-9\]+ 0008 08A46386\[^\n]*\n" { set x [expr $x+1] } | |
1020 | -re "^ +\[0-9\]+ 000c 08A48386\[^\n]*\n" { set x [expr $x+1] } | |
1021 | -re "^ +\[0-9\]+ 0010 08A4C386\[^\n]*\n" { set x [expr $x+1] } | |
1022 | -re "^ +\[0-9\]+ 0014 08A4E386\[^\n]*\n" { set x [expr $x+1] } | |
1023 | -re "^ +\[0-9\]+ 0018 08A41386\[^\n]*\n" { set x [expr $x+1] } | |
1024 | -re "^ +\[0-9\]+ 001c 08A45386\[^\n]*\n" { set x [expr $x+1] } | |
1025 | -re "^ +\[0-9\]+ 0020 08A47386\[^\n]*\n" { set x [expr $x+1] } | |
1026 | -re "^ +\[0-9\]+ 0024 08A49386\[^\n]*\n" { set x [expr $x+1] } | |
1027 | -re "^ +\[0-9\]+ 0028 08A4D386\[^\n]*\n" { set x [expr $x+1] } | |
1028 | -re "^ +\[0-9\]+ 002c 08A4F386\[^\n]*\n" { set x [expr $x+1] } | |
1029 | -re "^ +\[0-9\]+ 0030 08A40986\[^\n]*\n" { set x [expr $x+1] } | |
1030 | -re "^ +\[0-9\]+ 0034 08A44986\[^\n]*\n" { set x [expr $x+1] } | |
1031 | -re "^ +\[0-9\]+ 0038 08A46986\[^\n]*\n" { set x [expr $x+1] } | |
1032 | -re "^ +\[0-9\]+ 003c 08A48986\[^\n]*\n" { set x [expr $x+1] } | |
1033 | -re "^ +\[0-9\]+ 0040 08A4C986\[^\n]*\n" { set x [expr $x+1] } | |
1034 | -re "^ +\[0-9\]+ 0044 08A4E986\[^\n]*\n" { set x [expr $x+1] } | |
1035 | -re "^ +\[0-9\]+ 0048 08A41986\[^\n]*\n" { set x [expr $x+1] } | |
1036 | -re "^ +\[0-9\]+ 004c 08A45986\[^\n]*\n" { set x [expr $x+1] } | |
1037 | -re "^ +\[0-9\]+ 0050 08A47986\[^\n]*\n" { set x [expr $x+1] } | |
1038 | -re "^ +\[0-9\]+ 0054 08A49986\[^\n]*\n" { set x [expr $x+1] } | |
1039 | -re "^ +\[0-9\]+ 0058 08A4D986\[^\n]*\n" { set x [expr $x+1] } | |
1040 | -re "^ +\[0-9\]+ 005c 08A4F986\[^\n]*\n" { set x [expr $x+1] } | |
1041 | -re "^ +\[0-9\]+ 0060 08A409C6\[^\n]*\n" { set x [expr $x+1] } | |
1042 | -re "^ +\[0-9\]+ 0064 08A449C6\[^\n]*\n" { set x [expr $x+1] } | |
1043 | -re "^ +\[0-9\]+ 0068 08A469C6\[^\n]*\n" { set x [expr $x+1] } | |
1044 | -re "^ +\[0-9\]+ 006c 08A489C6\[^\n]*\n" { set x [expr $x+1] } | |
1045 | -re "^ +\[0-9\]+ 0070 08A4C9C6\[^\n]*\n" { set x [expr $x+1] } | |
1046 | -re "^ +\[0-9\]+ 0074 08A4E9C6\[^\n]*\n" { set x [expr $x+1] } | |
1047 | -re "^ +\[0-9\]+ 0078 08A419C6\[^\n]*\n" { set x [expr $x+1] } | |
1048 | -re "^ +\[0-9\]+ 007c 08A459C6\[^\n]*\n" { set x [expr $x+1] } | |
1049 | -re "^ +\[0-9\]+ 0080 08A479C6\[^\n]*\n" { set x [expr $x+1] } | |
1050 | -re "^ +\[0-9\]+ 0084 08A499C6\[^\n]*\n" { set x [expr $x+1] } | |
1051 | -re "^ +\[0-9\]+ 0088 08A4D9C6\[^\n]*\n" { set x [expr $x+1] } | |
1052 | -re "^ +\[0-9\]+ 008c 08A4F9C6\[^\n]*\n" { set x [expr $x+1] } | |
1053 | -re "\[^\n\]*\n" { } | |
1054 | timeout { perror "timeout\n"; break } | |
1055 | eof { break } | |
1056 | } | |
1057 | } | |
1058 | ||
1059 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1060 | # isn't needed, but just in case, please keep it in for now. | |
1061 | gas_finish | |
1062 | ||
1063 | # Did we find what we were looking for? If not, flunk it. | |
1064 | if [expr $x==36] then { pass $testname } else { fail $testname } | |
1065 | } | |
1066 | ||
1067 | proc do_dcor {} { | |
1068 | set testname "dcor.s: dcor tests" | |
1069 | set x 0 | |
1070 | ||
1071 | gas_start "dcor.s" "-al" | |
1072 | ||
1073 | # Check the assembled instruction against a table built by the HP assembler | |
1074 | # Any differences should be checked by hand -- with the number of problems | |
1075 | # I've seen in the HP assembler I don't completely trust it. | |
1076 | # | |
1077 | # Instead of having a variable for each match string just increment the | |
1078 | # total number of matches seen. That's simpler when testing large numbers | |
1079 | # of instructions (as these tests to). | |
1080 | while 1 { | |
1081 | expect { | |
1082 | -re "^ +\[0-9\]+ 0000 08800B85\[^\n]*\n" { set x [expr $x+1] } | |
1083 | -re "^ +\[0-9\]+ 0004 08804B85\[^\n]*\n" { set x [expr $x+1] } | |
1084 | -re "^ +\[0-9\]+ 0008 08806B85\[^\n]*\n" { set x [expr $x+1] } | |
1085 | -re "^ +\[0-9\]+ 000c 08808B85\[^\n]*\n" { set x [expr $x+1] } | |
1086 | -re "^ +\[0-9\]+ 0010 0880CB85\[^\n]*\n" { set x [expr $x+1] } | |
1087 | -re "^ +\[0-9\]+ 0014 0880EB85\[^\n]*\n" { set x [expr $x+1] } | |
1088 | -re "^ +\[0-9\]+ 0018 08801B85\[^\n]*\n" { set x [expr $x+1] } | |
1089 | -re "^ +\[0-9\]+ 001c 08805B85\[^\n]*\n" { set x [expr $x+1] } | |
1090 | -re "^ +\[0-9\]+ 0020 08807B85\[^\n]*\n" { set x [expr $x+1] } | |
1091 | -re "^ +\[0-9\]+ 0024 08809B85\[^\n]*\n" { set x [expr $x+1] } | |
1092 | -re "^ +\[0-9\]+ 0028 0880DB85\[^\n]*\n" { set x [expr $x+1] } | |
1093 | -re "^ +\[0-9\]+ 002c 0880FB85\[^\n]*\n" { set x [expr $x+1] } | |
1094 | -re "^ +\[0-9\]+ 0030 08800BC5\[^\n]*\n" { set x [expr $x+1] } | |
1095 | -re "^ +\[0-9\]+ 0034 08804BC5\[^\n]*\n" { set x [expr $x+1] } | |
1096 | -re "^ +\[0-9\]+ 0038 08806BC5\[^\n]*\n" { set x [expr $x+1] } | |
1097 | -re "^ +\[0-9\]+ 003c 08808BC5\[^\n]*\n" { set x [expr $x+1] } | |
1098 | -re "^ +\[0-9\]+ 0040 0880CBC5\[^\n]*\n" { set x [expr $x+1] } | |
1099 | -re "^ +\[0-9\]+ 0044 0880EBC5\[^\n]*\n" { set x [expr $x+1] } | |
1100 | -re "^ +\[0-9\]+ 0048 08801BC5\[^\n]*\n" { set x [expr $x+1] } | |
1101 | -re "^ +\[0-9\]+ 004c 08805BC5\[^\n]*\n" { set x [expr $x+1] } | |
1102 | -re "^ +\[0-9\]+ 0050 08807BC5\[^\n]*\n" { set x [expr $x+1] } | |
1103 | -re "^ +\[0-9\]+ 0054 08809BC5\[^\n]*\n" { set x [expr $x+1] } | |
1104 | -re "^ +\[0-9\]+ 0058 0880DBC5\[^\n]*\n" { set x [expr $x+1] } | |
1105 | -re "^ +\[0-9\]+ 005c 0880FBC5\[^\n]*\n" { set x [expr $x+1] } | |
1106 | -re "\[^\n\]*\n" { } | |
1107 | timeout { perror "timeout\n"; break } | |
1108 | eof { break } | |
1109 | } | |
1110 | } | |
1111 | ||
1112 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1113 | # isn't needed, but just in case, please keep it in for now. | |
1114 | gas_finish | |
1115 | ||
1116 | # Did we find what we were looking for? If not, flunk it. | |
1117 | if [expr $x==24] then { pass $testname } else { fail $testname } | |
1118 | } | |
1119 | ||
1120 | proc do_addi {} { | |
1121 | set testname "addi.s: addi tests" | |
1122 | set x 0 | |
1123 | ||
1124 | gas_start "addi.s" "-al" | |
1125 | ||
1126 | # Check the assembled instruction against a table built by the HP assembler | |
1127 | # Any differences should be checked by hand -- with the number of problems | |
1128 | # I've seen in the HP assembler I don't completely trust it. | |
1129 | # | |
1130 | # Instead of having a variable for each match string just increment the | |
1131 | # total number of matches seen. That's simpler when testing large numbers | |
1132 | # of instructions (as these tests to). | |
1133 | while 1 { | |
1134 | expect { | |
1135 | -re "^ +\[0-9\]+ 0000 B4A600F6\[^\n\]*\n" { set x [expr $x+1] } | |
1136 | -re "^ +\[0-9\]+ 0004 B4A620F6\[^\n\]*\n" { set x [expr $x+1] } | |
1137 | -re "^ +\[0-9\]+ 0008 B4A640F6\[^\n\]*\n" { set x [expr $x+1] } | |
1138 | -re "^ +\[0-9\]+ 000c B4A660F6\[^\n\]*\n" { set x [expr $x+1] } | |
1139 | -re "^ +\[0-9\]+ 0010 B4A680F6\[^\n\]*\n" { set x [expr $x+1] } | |
1140 | -re "^ +\[0-9\]+ 0014 B4A6A0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1141 | -re "^ +\[0-9\]+ 0018 B4A6C0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1142 | -re "^ +\[0-9\]+ 001c B4A6E0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1143 | -re "^ +\[0-9\]+ 0020 B4A610F6\[^\n\]*\n" { set x [expr $x+1] } | |
1144 | -re "^ +\[0-9\]+ 0024 B4A630F6\[^\n\]*\n" { set x [expr $x+1] } | |
1145 | -re "^ +\[0-9\]+ 0028 B4A650F6\[^\n\]*\n" { set x [expr $x+1] } | |
1146 | -re "^ +\[0-9\]+ 002c B4A670F6\[^\n\]*\n" { set x [expr $x+1] } | |
1147 | -re "^ +\[0-9\]+ 0030 B4A690F6\[^\n\]*\n" { set x [expr $x+1] } | |
1148 | -re "^ +\[0-9\]+ 0034 B4A6B0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1149 | -re "^ +\[0-9\]+ 0038 B4A6D0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1150 | -re "^ +\[0-9\]+ 003c B4A6F0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1151 | -re "^ +\[0-9\]+ 0040 B4A608F6\[^\n\]*\n" { set x [expr $x+1] } | |
1152 | -re "^ +\[0-9\]+ 0044 B4A628F6\[^\n\]*\n" { set x [expr $x+1] } | |
1153 | -re "^ +\[0-9\]+ 0048 B4A648F6\[^\n\]*\n" { set x [expr $x+1] } | |
1154 | -re "^ +\[0-9\]+ 004c B4A668F6\[^\n\]*\n" { set x [expr $x+1] } | |
1155 | -re "^ +\[0-9\]+ 0050 B4A688F6\[^\n\]*\n" { set x [expr $x+1] } | |
1156 | -re "^ +\[0-9\]+ 0054 B4A6A8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1157 | -re "^ +\[0-9\]+ 0058 B4A6C8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1158 | -re "^ +\[0-9\]+ 005c B4A6E8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1159 | -re "^ +\[0-9\]+ 0060 B4A618F6\[^\n\]*\n" { set x [expr $x+1] } | |
1160 | -re "^ +\[0-9\]+ 0064 B4A638F6\[^\n\]*\n" { set x [expr $x+1] } | |
1161 | -re "^ +\[0-9\]+ 0068 B4A658F6\[^\n\]*\n" { set x [expr $x+1] } | |
1162 | -re "^ +\[0-9\]+ 006c B4A678F6\[^\n\]*\n" { set x [expr $x+1] } | |
1163 | -re "^ +\[0-9\]+ 0070 B4A698F6\[^\n\]*\n" { set x [expr $x+1] } | |
1164 | -re "^ +\[0-9\]+ 0074 B4A6B8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1165 | -re "^ +\[0-9\]+ 0078 B4A6D8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1166 | -re "^ +\[0-9\]+ 007c B4A6F8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1167 | -re "^ +\[0-9\]+ 0080 B0A600F6\[^\n\]*\n" { set x [expr $x+1] } | |
1168 | -re "^ +\[0-9\]+ 0084 B0A620F6\[^\n\]*\n" { set x [expr $x+1] } | |
1169 | -re "^ +\[0-9\]+ 0088 B0A640F6\[^\n\]*\n" { set x [expr $x+1] } | |
1170 | -re "^ +\[0-9\]+ 008c B0A660F6\[^\n\]*\n" { set x [expr $x+1] } | |
1171 | -re "^ +\[0-9\]+ 0090 B0A680F6\[^\n\]*\n" { set x [expr $x+1] } | |
1172 | -re "^ +\[0-9\]+ 0094 B0A6A0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1173 | -re "^ +\[0-9\]+ 0098 B0A6C0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1174 | -re "^ +\[0-9\]+ 009c B0A6E0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1175 | -re "^ +\[0-9\]+ 00a0 B0A610F6\[^\n\]*\n" { set x [expr $x+1] } | |
1176 | -re "^ +\[0-9\]+ 00a4 B0A630F6\[^\n\]*\n" { set x [expr $x+1] } | |
1177 | -re "^ +\[0-9\]+ 00a8 B0A650F6\[^\n\]*\n" { set x [expr $x+1] } | |
1178 | -re "^ +\[0-9\]+ 00ac B0A670F6\[^\n\]*\n" { set x [expr $x+1] } | |
1179 | -re "^ +\[0-9\]+ 00b0 B0A690F6\[^\n\]*\n" { set x [expr $x+1] } | |
1180 | -re "^ +\[0-9\]+ 00b4 B0A6B0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1181 | -re "^ +\[0-9\]+ 00b8 B0A6D0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1182 | -re "^ +\[0-9\]+ 00bc B0A6F0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1183 | -re "^ +\[0-9\]+ 00c0 B0A608F6\[^\n\]*\n" { set x [expr $x+1] } | |
1184 | -re "^ +\[0-9\]+ 00c4 B0A628F6\[^\n\]*\n" { set x [expr $x+1] } | |
1185 | -re "^ +\[0-9\]+ 00c8 B0A648F6\[^\n\]*\n" { set x [expr $x+1] } | |
1186 | -re "^ +\[0-9\]+ 00cc B0A668F6\[^\n\]*\n" { set x [expr $x+1] } | |
1187 | -re "^ +\[0-9\]+ 00d0 B0A688F6\[^\n\]*\n" { set x [expr $x+1] } | |
1188 | -re "^ +\[0-9\]+ 00d4 B0A6A8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1189 | -re "^ +\[0-9\]+ 00d8 B0A6C8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1190 | -re "^ +\[0-9\]+ 00dc B0A6E8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1191 | -re "^ +\[0-9\]+ 00e0 B0A618F6\[^\n\]*\n" { set x [expr $x+1] } | |
1192 | -re "^ +\[0-9\]+ 00e4 B0A638F6\[^\n\]*\n" { set x [expr $x+1] } | |
1193 | -re "^ +\[0-9\]+ 00e8 B0A658F6\[^\n\]*\n" { set x [expr $x+1] } | |
1194 | -re "^ +\[0-9\]+ 00ec B0A678F6\[^\n\]*\n" { set x [expr $x+1] } | |
1195 | -re "^ +\[0-9\]+ 00f0 B0A698F6\[^\n\]*\n" { set x [expr $x+1] } | |
1196 | -re "^ +\[0-9\]+ 00f4 B0A6B8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1197 | -re "^ +\[0-9\]+ 00f8 B0A6D8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1198 | -re "^ +\[0-9\]+ 00fc B0A6F8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1199 | -re "\[^\n\]*\n" { } | |
1200 | timeout { perror "timeout\n"; break } | |
1201 | eof { break } | |
1202 | } | |
1203 | } | |
1204 | ||
1205 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1206 | # isn't needed, but just in case, please keep it in for now. | |
1207 | gas_finish | |
1208 | ||
1209 | # Did we find what we were looking for? If not, flunk it. | |
1210 | if [expr $x==64] then { pass $testname } else { fail $testname } | |
1211 | } | |
1212 | ||
1213 | proc do_subi {} { | |
1214 | set testname "subi.s: subi tests" | |
1215 | set x 0 | |
1216 | ||
1217 | gas_start "subi.s" "-al" | |
1218 | ||
1219 | # Check the assembled instruction against a table built by the HP assembler | |
1220 | # Any differences should be checked by hand -- with the number of problems | |
1221 | # I've seen in the HP assembler I don't completely trust it. | |
1222 | # | |
1223 | # Instead of having a variable for each match string just increment the | |
1224 | # total number of matches seen. That's simpler when testing large numbers | |
1225 | # of instructions (as these tests to). | |
1226 | while 1 { | |
1227 | expect { | |
1228 | -re "^ +\[0-9\]+ 0000 94A600F6\[^\n\]*\n" { set x [expr $x+1] } | |
1229 | -re "^ +\[0-9\]+ 0004 94A620F6\[^\n\]*\n" { set x [expr $x+1] } | |
1230 | -re "^ +\[0-9\]+ 0008 94A640F6\[^\n\]*\n" { set x [expr $x+1] } | |
1231 | -re "^ +\[0-9\]+ 000c 94A660F6\[^\n\]*\n" { set x [expr $x+1] } | |
1232 | -re "^ +\[0-9\]+ 0010 94A680F6\[^\n\]*\n" { set x [expr $x+1] } | |
1233 | -re "^ +\[0-9\]+ 0014 94A6A0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1234 | -re "^ +\[0-9\]+ 0018 94A6C0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1235 | -re "^ +\[0-9\]+ 001c 94A6E0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1236 | -re "^ +\[0-9\]+ 0020 94A610F6\[^\n\]*\n" { set x [expr $x+1] } | |
1237 | -re "^ +\[0-9\]+ 0024 94A630F6\[^\n\]*\n" { set x [expr $x+1] } | |
1238 | -re "^ +\[0-9\]+ 0028 94A650F6\[^\n\]*\n" { set x [expr $x+1] } | |
1239 | -re "^ +\[0-9\]+ 002c 94A670F6\[^\n\]*\n" { set x [expr $x+1] } | |
1240 | -re "^ +\[0-9\]+ 0030 94A690F6\[^\n\]*\n" { set x [expr $x+1] } | |
1241 | -re "^ +\[0-9\]+ 0034 94A6B0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1242 | -re "^ +\[0-9\]+ 0038 94A6D0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1243 | -re "^ +\[0-9\]+ 003c 94A6F0F6\[^\n\]*\n" { set x [expr $x+1] } | |
1244 | -re "^ +\[0-9\]+ 0040 94A608F6\[^\n\]*\n" { set x [expr $x+1] } | |
1245 | -re "^ +\[0-9\]+ 0044 94A628F6\[^\n\]*\n" { set x [expr $x+1] } | |
1246 | -re "^ +\[0-9\]+ 0048 94A648F6\[^\n\]*\n" { set x [expr $x+1] } | |
1247 | -re "^ +\[0-9\]+ 004c 94A668F6\[^\n\]*\n" { set x [expr $x+1] } | |
1248 | -re "^ +\[0-9\]+ 0050 94A688F6\[^\n\]*\n" { set x [expr $x+1] } | |
1249 | -re "^ +\[0-9\]+ 0054 94A6A8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1250 | -re "^ +\[0-9\]+ 0058 94A6C8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1251 | -re "^ +\[0-9\]+ 005c 94A6E8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1252 | -re "^ +\[0-9\]+ 0060 94A618F6\[^\n\]*\n" { set x [expr $x+1] } | |
1253 | -re "^ +\[0-9\]+ 0064 94A638F6\[^\n\]*\n" { set x [expr $x+1] } | |
1254 | -re "^ +\[0-9\]+ 0068 94A658F6\[^\n\]*\n" { set x [expr $x+1] } | |
1255 | -re "^ +\[0-9\]+ 006c 94A678F6\[^\n\]*\n" { set x [expr $x+1] } | |
1256 | -re "^ +\[0-9\]+ 0070 94A698F6\[^\n\]*\n" { set x [expr $x+1] } | |
1257 | -re "^ +\[0-9\]+ 0074 94A6B8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1258 | -re "^ +\[0-9\]+ 0078 94A6D8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1259 | -re "^ +\[0-9\]+ 007c 94A6F8F6\[^\n\]*\n" { set x [expr $x+1] } | |
1260 | -re "\[^\n\]*\n" { } | |
1261 | timeout { perror "timeout\n"; break } | |
1262 | eof { break } | |
1263 | } | |
1264 | } | |
1265 | ||
1266 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1267 | # isn't needed, but just in case, please keep it in for now. | |
1268 | gas_finish | |
1269 | ||
1270 | # Did we find what we were looking for? If not, flunk it. | |
1271 | if [expr $x==32] then { pass $testname } else { fail $testname } | |
1272 | } | |
1273 | ||
1274 | proc do_shift {} { | |
1275 | set testname "shift.s: shift tests" | |
1276 | set x 0 | |
1277 | ||
1278 | gas_start "shift.s" "-al" | |
1279 | ||
1280 | # Check the assembled instruction against a table built by the HP assembler | |
1281 | # Any differences should be checked by hand -- with the number of problems | |
1282 | # I've seen in the HP assembler I don't completely trust it. | |
1283 | # | |
1284 | # Instead of having a variable for each match string just increment the | |
1285 | # total number of matches seen. That's simpler when testing large numbers | |
1286 | # of instructions (as these tests to). | |
1287 | while 1 { | |
1288 | expect { | |
1289 | -re "^ +\[0-9\]+ 0000 D0A40006\[^\n]*\n" { set x [expr $x+1] } | |
1290 | -re "^ +\[0-9\]+ 0004 D0A42006\[^\n]*\n" { set x [expr $x+1] } | |
1291 | -re "^ +\[0-9\]+ 0008 D0A44006\[^\n]*\n" { set x [expr $x+1] } | |
1292 | -re "^ +\[0-9\]+ 000c D0A46006\[^\n]*\n" { set x [expr $x+1] } | |
1293 | -re "^ +\[0-9\]+ 0010 D0A48006\[^\n]*\n" { set x [expr $x+1] } | |
1294 | -re "^ +\[0-9\]+ 0014 D0A4A006\[^\n]*\n" { set x [expr $x+1] } | |
1295 | -re "^ +\[0-9\]+ 0018 D0A4C006\[^\n]*\n" { set x [expr $x+1] } | |
1296 | -re "^ +\[0-9\]+ 001c D0A4E006\[^\n]*\n" { set x [expr $x+1] } | |
1297 | -re "^ +\[0-9\]+ 0020 D0A40B46\[^\n]*\n" { set x [expr $x+1] } | |
1298 | -re "^ +\[0-9\]+ 0024 D0A42B46\[^\n]*\n" { set x [expr $x+1] } | |
1299 | -re "^ +\[0-9\]+ 0028 D0A44B46\[^\n]*\n" { set x [expr $x+1] } | |
1300 | -re "^ +\[0-9\]+ 002c D0A46B46\[^\n]*\n" { set x [expr $x+1] } | |
1301 | -re "^ +\[0-9\]+ 0030 D0A48B46\[^\n]*\n" { set x [expr $x+1] } | |
1302 | -re "^ +\[0-9\]+ 0034 D0A4AB46\[^\n]*\n" { set x [expr $x+1] } | |
1303 | -re "^ +\[0-9\]+ 0038 D0A4CB46\[^\n]*\n" { set x [expr $x+1] } | |
1304 | -re "^ +\[0-9\]+ 003c D0A4EB46\[^\n]*\n" { set x [expr $x+1] } | |
1305 | -re "\[^\n\]*\n" { } | |
1306 | timeout { perror "timeout\n"; break } | |
1307 | eof { break } | |
1308 | } | |
1309 | } | |
1310 | ||
1311 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1312 | # isn't needed, but just in case, please keep it in for now. | |
1313 | gas_finish | |
1314 | ||
1315 | # Did we find what we were looking for? If not, flunk it. | |
1316 | if [expr $x==16] then { pass $testname } else { fail $testname } | |
1317 | } | |
1318 | ||
1319 | proc do_extract {} { | |
1320 | set testname "extract.s: extract tests" | |
1321 | set x 0 | |
1322 | ||
1323 | gas_start "extract.s" "-al" | |
1324 | ||
1325 | # Check the assembled instruction against a table built by the HP assembler | |
1326 | # Any differences should be checked by hand -- with the number of problems | |
1327 | # I've seen in the HP assembler I don't completely trust it. | |
1328 | # | |
1329 | # Instead of having a variable for each match string just increment the | |
1330 | # total number of matches seen. That's simpler when testing large numbers | |
1331 | # of instructions (as these tests to). | |
1332 | while 1 { | |
1333 | expect { | |
1334 | -re "^ +\[0-9\]+ 0000 D08618B6\[^\n]*\n" { set x [expr $x+1] } | |
1335 | -re "^ +\[0-9\]+ 0004 D08638B6\[^\n]*\n" { set x [expr $x+1] } | |
1336 | -re "^ +\[0-9\]+ 0008 D08658B6\[^\n]*\n" { set x [expr $x+1] } | |
1337 | -re "^ +\[0-9\]+ 000c D08678B6\[^\n]*\n" { set x [expr $x+1] } | |
1338 | -re "^ +\[0-9\]+ 0010 D08698B6\[^\n]*\n" { set x [expr $x+1] } | |
1339 | -re "^ +\[0-9\]+ 0014 D086B8B6\[^\n]*\n" { set x [expr $x+1] } | |
1340 | -re "^ +\[0-9\]+ 0018 D086D8B6\[^\n]*\n" { set x [expr $x+1] } | |
1341 | -re "^ +\[0-9\]+ 001c D086F8B6\[^\n]*\n" { set x [expr $x+1] } | |
1342 | -re "^ +\[0-9\]+ 0020 D0861CB6\[^\n]*\n" { set x [expr $x+1] } | |
1343 | -re "^ +\[0-9\]+ 0024 D0863CB6\[^\n]*\n" { set x [expr $x+1] } | |
1344 | -re "^ +\[0-9\]+ 0028 D0865CB6\[^\n]*\n" { set x [expr $x+1] } | |
1345 | -re "^ +\[0-9\]+ 002c D0867CB6\[^\n]*\n" { set x [expr $x+1] } | |
1346 | -re "^ +\[0-9\]+ 0030 D0869CB6\[^\n]*\n" { set x [expr $x+1] } | |
1347 | -re "^ +\[0-9\]+ 0034 D086BCB6\[^\n]*\n" { set x [expr $x+1] } | |
1348 | -re "^ +\[0-9\]+ 0038 D086DCB6\[^\n]*\n" { set x [expr $x+1] } | |
1349 | -re "^ +\[0-9\]+ 003c D086FCB6\[^\n]*\n" { set x [expr $x+1] } | |
1350 | -re "^ +\[0-9\]+ 0040 D086101B\[^\n]*\n" { set x [expr $x+1] } | |
1351 | -re "^ +\[0-9\]+ 0044 D086301B\[^\n]*\n" { set x [expr $x+1] } | |
1352 | -re "^ +\[0-9\]+ 0048 D086501B\[^\n]*\n" { set x [expr $x+1] } | |
1353 | -re "^ +\[0-9\]+ 004c D086701B\[^\n]*\n" { set x [expr $x+1] } | |
1354 | -re "^ +\[0-9\]+ 0050 D086901B\[^\n]*\n" { set x [expr $x+1] } | |
1355 | -re "^ +\[0-9\]+ 0054 D086B01B\[^\n]*\n" { set x [expr $x+1] } | |
1356 | -re "^ +\[0-9\]+ 0058 D086D01B\[^\n]*\n" { set x [expr $x+1] } | |
1357 | -re "^ +\[0-9\]+ 005c D086F01B\[^\n]*\n" { set x [expr $x+1] } | |
1358 | -re "^ +\[0-9\]+ 0060 D086141B\[^\n]*\n" { set x [expr $x+1] } | |
1359 | -re "^ +\[0-9\]+ 0064 D086341B\[^\n]*\n" { set x [expr $x+1] } | |
1360 | -re "^ +\[0-9\]+ 0068 D086541B\[^\n]*\n" { set x [expr $x+1] } | |
1361 | -re "^ +\[0-9\]+ 006c D086741B\[^\n]*\n" { set x [expr $x+1] } | |
1362 | -re "^ +\[0-9\]+ 0070 D086941B\[^\n]*\n" { set x [expr $x+1] } | |
1363 | -re "^ +\[0-9\]+ 0074 D086B41B\[^\n]*\n" { set x [expr $x+1] } | |
1364 | -re "^ +\[0-9\]+ 0078 D086D41B\[^\n]*\n" { set x [expr $x+1] } | |
1365 | -re "^ +\[0-9\]+ 007c D086F41B\[^\n]*\n" { set x [expr $x+1] } | |
1366 | -re "\[^\n\]*\n" { } | |
1367 | timeout { perror "timeout\n"; break } | |
1368 | eof { break } | |
1369 | } | |
1370 | } | |
1371 | ||
1372 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1373 | # isn't needed, but just in case, please keep it in for now. | |
1374 | gas_finish | |
1375 | ||
1376 | # Did we find what we were looking for? If not, flunk it. | |
1377 | if [expr $x==32] then { pass $testname } else { fail $testname } | |
1378 | } | |
1379 | ||
1380 | proc do_deposit {} { | |
1381 | set testname "deposit.s: deposit tests" | |
1382 | set x 0 | |
1383 | ||
1384 | gas_start "deposit.s" "-al" | |
1385 | ||
1386 | # Check the assembled instruction against a table built by the HP assembler | |
1387 | # Any differences should be checked by hand -- with the number of problems | |
1388 | # I've seen in the HP assembler I don't completely trust it. | |
1389 | # | |
1390 | # Instead of having a variable for each match string just increment the | |
1391 | # total number of matches seen. That's simpler when testing large numbers | |
1392 | # of instructions (as these tests to). | |
1393 | while 1 { | |
1394 | expect { | |
1395 | -re "^ +\[0-9\]+ 0000 D4C40B56\[^\n]*\n" { set x [expr $x+1] } | |
1396 | -re "^ +\[0-9\]+ 0004 D4C42B56\[^\n]*\n" { set x [expr $x+1] } | |
1397 | -re "^ +\[0-9\]+ 0008 D4C44B56\[^\n]*\n" { set x [expr $x+1] } | |
1398 | -re "^ +\[0-9\]+ 000c D4C46B56\[^\n]*\n" { set x [expr $x+1] } | |
1399 | -re "^ +\[0-9\]+ 0010 D4C48B56\[^\n]*\n" { set x [expr $x+1] } | |
1400 | -re "^ +\[0-9\]+ 0014 D4C4AB56\[^\n]*\n" { set x [expr $x+1] } | |
1401 | -re "^ +\[0-9\]+ 0018 D4C4CB56\[^\n]*\n" { set x [expr $x+1] } | |
1402 | -re "^ +\[0-9\]+ 001c D4C4EB56\[^\n]*\n" { set x [expr $x+1] } | |
1403 | -re "^ +\[0-9\]+ 0020 D4C40F56\[^\n]*\n" { set x [expr $x+1] } | |
1404 | -re "^ +\[0-9\]+ 0024 D4C42F56\[^\n]*\n" { set x [expr $x+1] } | |
1405 | -re "^ +\[0-9\]+ 0028 D4C44F56\[^\n]*\n" { set x [expr $x+1] } | |
1406 | -re "^ +\[0-9\]+ 002c D4C46F56\[^\n]*\n" { set x [expr $x+1] } | |
1407 | -re "^ +\[0-9\]+ 0030 D4C48F56\[^\n]*\n" { set x [expr $x+1] } | |
1408 | -re "^ +\[0-9\]+ 0034 D4C4AF56\[^\n]*\n" { set x [expr $x+1] } | |
1409 | -re "^ +\[0-9\]+ 0038 D4C4CF56\[^\n]*\n" { set x [expr $x+1] } | |
1410 | -re "^ +\[0-9\]+ 003c D4C4EF56\[^\n]*\n" { set x [expr $x+1] } | |
1411 | -re "^ +\[0-9\]+ 0040 D4C4001B\[^\n]*\n" { set x [expr $x+1] } | |
1412 | -re "^ +\[0-9\]+ 0044 D4C4201B\[^\n]*\n" { set x [expr $x+1] } | |
1413 | -re "^ +\[0-9\]+ 0048 D4C4401B\[^\n]*\n" { set x [expr $x+1] } | |
1414 | -re "^ +\[0-9\]+ 004c D4C4601B\[^\n]*\n" { set x [expr $x+1] } | |
1415 | -re "^ +\[0-9\]+ 0050 D4C4801B\[^\n]*\n" { set x [expr $x+1] } | |
1416 | -re "^ +\[0-9\]+ 0054 D4C4A01B\[^\n]*\n" { set x [expr $x+1] } | |
1417 | -re "^ +\[0-9\]+ 0058 D4C4C01B\[^\n]*\n" { set x [expr $x+1] } | |
1418 | -re "^ +\[0-9\]+ 005c D4C4E01B\[^\n]*\n" { set x [expr $x+1] } | |
1419 | -re "^ +\[0-9\]+ 0060 D4C4041B\[^\n]*\n" { set x [expr $x+1] } | |
1420 | -re "^ +\[0-9\]+ 0064 D4C4241B\[^\n]*\n" { set x [expr $x+1] } | |
1421 | -re "^ +\[0-9\]+ 0068 D4C4441B\[^\n]*\n" { set x [expr $x+1] } | |
1422 | -re "^ +\[0-9\]+ 006c D4C4641B\[^\n]*\n" { set x [expr $x+1] } | |
1423 | -re "^ +\[0-9\]+ 0070 D4C4841B\[^\n]*\n" { set x [expr $x+1] } | |
1424 | -re "^ +\[0-9\]+ 0074 D4C4A41B\[^\n]*\n" { set x [expr $x+1] } | |
1425 | -re "^ +\[0-9\]+ 0078 D4C4C41B\[^\n]*\n" { set x [expr $x+1] } | |
1426 | -re "^ +\[0-9\]+ 007c D4C4E41B\[^\n]*\n" { set x [expr $x+1] } | |
1427 | -re "^ +\[0-9\]+ 0080 D4DF141B\[^\n]*\n" { set x [expr $x+1] } | |
1428 | -re "^ +\[0-9\]+ 0084 D4DF341B\[^\n]*\n" { set x [expr $x+1] } | |
1429 | -re "^ +\[0-9\]+ 0088 D4DF541B\[^\n]*\n" { set x [expr $x+1] } | |
1430 | -re "^ +\[0-9\]+ 008c D4DF741B\[^\n]*\n" { set x [expr $x+1] } | |
1431 | -re "^ +\[0-9\]+ 0090 D4DF941B\[^\n]*\n" { set x [expr $x+1] } | |
1432 | -re "^ +\[0-9\]+ 0094 D4DFB41B\[^\n]*\n" { set x [expr $x+1] } | |
1433 | -re "^ +\[0-9\]+ 0098 D4DFD41B\[^\n]*\n" { set x [expr $x+1] } | |
1434 | -re "^ +\[0-9\]+ 009c D4DFF41B\[^\n]*\n" { set x [expr $x+1] } | |
1435 | -re "^ +\[0-9\]+ 00a0 D4DF101B\[^\n]*\n" { set x [expr $x+1] } | |
1436 | -re "^ +\[0-9\]+ 00a4 D4DF301B\[^\n]*\n" { set x [expr $x+1] } | |
1437 | -re "^ +\[0-9\]+ 00a8 D4DF501B\[^\n]*\n" { set x [expr $x+1] } | |
1438 | -re "^ +\[0-9\]+ 00ac D4DF701B\[^\n]*\n" { set x [expr $x+1] } | |
1439 | -re "^ +\[0-9\]+ 00b0 D4DF901B\[^\n]*\n" { set x [expr $x+1] } | |
1440 | -re "^ +\[0-9\]+ 00b4 D4DFB01B\[^\n]*\n" { set x [expr $x+1] } | |
1441 | -re "^ +\[0-9\]+ 00b8 D4DFD01B\[^\n]*\n" { set x [expr $x+1] } | |
1442 | -re "^ +\[0-9\]+ 00bc D4DFF01B\[^\n]*\n" { set x [expr $x+1] } | |
1443 | -re "^ +\[0-9\]+ 00c0 D4DF1F76\[^\n]*\n" { set x [expr $x+1] } | |
1444 | -re "^ +\[0-9\]+ 00c4 D4DF3F76\[^\n]*\n" { set x [expr $x+1] } | |
1445 | -re "^ +\[0-9\]+ 00c8 D4DF5F76\[^\n]*\n" { set x [expr $x+1] } | |
1446 | -re "^ +\[0-9\]+ 00cc D4DF7F76\[^\n]*\n" { set x [expr $x+1] } | |
1447 | -re "^ +\[0-9\]+ 00d0 D4DF9F76\[^\n]*\n" { set x [expr $x+1] } | |
1448 | -re "^ +\[0-9\]+ 00d4 D4DFBF76\[^\n]*\n" { set x [expr $x+1] } | |
1449 | -re "^ +\[0-9\]+ 00d8 D4DFDF76\[^\n]*\n" { set x [expr $x+1] } | |
1450 | -re "^ +\[0-9\]+ 00dc D4DFFF76\[^\n]*\n" { set x [expr $x+1] } | |
1451 | -re "^ +\[0-9\]+ 00e0 D4DF1B76\[^\n]*\n" { set x [expr $x+1] } | |
1452 | -re "^ +\[0-9\]+ 00e4 D4DF3B76\[^\n]*\n" { set x [expr $x+1] } | |
1453 | -re "^ +\[0-9\]+ 00e8 D4DF5B76\[^\n]*\n" { set x [expr $x+1] } | |
1454 | -re "^ +\[0-9\]+ 00ec D4DF7B76\[^\n]*\n" { set x [expr $x+1] } | |
1455 | -re "^ +\[0-9\]+ 00f0 D4DF9B76\[^\n]*\n" { set x [expr $x+1] } | |
1456 | -re "^ +\[0-9\]+ 00f4 D4DFBB76\[^\n]*\n" { set x [expr $x+1] } | |
1457 | -re "^ +\[0-9\]+ 00f8 D4DFDB76\[^\n]*\n" { set x [expr $x+1] } | |
1458 | -re "^ +\[0-9\]+ 00fc D4DFFB76\[^\n]*\n" { set x [expr $x+1] } | |
1459 | -re "\[^\n\]*\n" { } | |
1460 | timeout { perror "timeout\n"; break } | |
1461 | eof { break } | |
1462 | } | |
1463 | } | |
1464 | ||
1465 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1466 | # isn't needed, but just in case, please keep it in for now. | |
1467 | gas_finish | |
1468 | ||
1469 | # Did we find what we were looking for? If not, flunk it. | |
1470 | if [expr $x==64] then { pass $testname } else { fail $testname } | |
1471 | } | |
1472 | ||
1473 | proc do_system {} { | |
1474 | set testname "system.s: system tests" | |
1475 | set x 0 | |
1476 | ||
1477 | gas_start "system.s" "-al" | |
1478 | ||
1479 | # Check the assembled instruction against a table built by the HP assembler | |
1480 | # Any differences should be checked by hand -- with the number of problems | |
1481 | # I've seen in the HP assembler I don't completely trust it. | |
1482 | # | |
1483 | # Instead of having a variable for each match string just increment the | |
1484 | # total number of matches seen. That's simpler when testing large numbers | |
1485 | # of instructions (as these tests to). | |
1486 | while 1 { | |
1487 | expect { | |
1488 | -re "^ +\[0-9\]+ 0000 00018005\[^\n]*\n" { set x [expr $x+1] } | |
1489 | -re "^ +\[0-9\]+ 0004 00000C00\[^\n]*\n" { set x [expr $x+1] } | |
1490 | -re "^ +\[0-9\]+ 0008 00000CA0\[^\n]*\n" { set x [expr $x+1] } | |
1491 | -re "^ +\[0-9\]+ 000c 00050D64\[^\n]*\n" { set x [expr $x+1] } | |
1492 | -re "^ +\[0-9\]+ 0010 00050E64\[^\n]*\n" { set x [expr $x+1] } | |
1493 | -re "^ +\[0-9\]+ 0014 00041860\[^\n]*\n" { set x [expr $x+1] } | |
1494 | -re "^ +\[0-9\]+ 0018 00A010A4\[^\n]*\n" { set x [expr $x+1] } | |
1495 | -re "^ +\[0-9\]+ 001c 00041820\[^\n]*\n" { set x [expr $x+1] } | |
1496 | -re "^ +\[0-9\]+ 0020 01441840\[^\n]*\n" { set x [expr $x+1] } | |
1497 | -re "^ +\[0-9\]+ 0024 000004A4\[^\n]*\n" { set x [expr $x+1] } | |
1498 | -re "^ +\[0-9\]+ 0028 014008A4\[^\n]*\n" { set x [expr $x+1] } | |
1499 | -re "^ +\[0-9\]+ 002c 00000400\[^\n]*\n" { set x [expr $x+1] } | |
1500 | -re "^ +\[0-9\]+ 0030 00100400\[^\n]*\n" { set x [expr $x+1] } | |
1501 | -re "^ +\[0-9\]+ 0034 140004D2\[^\n]*\n" { set x [expr $x+1] } | |
1502 | -re "^ +\[0-9\]+ 0038 04A61187\[^\n]*\n" { set x [expr $x+1] } | |
1503 | -re "^ +\[0-9\]+ 003c 04A13187\[^\n]*\n" { set x [expr $x+1] } | |
1504 | -re "^ +\[0-9\]+ 0040 04A611C7\[^\n]*\n" { set x [expr $x+1] } | |
1505 | -re "^ +\[0-9\]+ 0044 04A131C7\[^\n]*\n" { set x [expr $x+1] } | |
1506 | -re "^ +\[0-9\]+ 0048 04A41346\[^\n]*\n" { set x [expr $x+1] } | |
1507 | -re "^ +\[0-9\]+ 004c 04A41366\[^\n]*\n" { set x [expr $x+1] } | |
1508 | -re "^ +\[0-9\]+ 0050 04A41306\[^\n]*\n" { set x [expr $x+1] } | |
1509 | -re "^ +\[0-9\]+ 0054 04A41326\[^\n]*\n" { set x [expr $x+1] } | |
1510 | -re "^ +\[0-9\]+ 0058 04A41306\[^\n]*\n" { set x [expr $x+1] } | |
1511 | -re "^ +\[0-9\]+ 005c 04A41040\[^\n]*\n" { set x [expr $x+1] } | |
1512 | -re "^ +\[0-9\]+ 0060 04A42040\[^\n]*\n" { set x [expr $x+1] } | |
1513 | -re "^ +\[0-9\]+ 0064 04A41000\[^\n]*\n" { set x [expr $x+1] } | |
1514 | -re "^ +\[0-9\]+ 0068 04A42000\[^\n]*\n" { set x [expr $x+1] } | |
1515 | -re "\[^\n\]*\n" { } | |
1516 | timeout { perror "timeout\n"; break } | |
1517 | eof { break } | |
1518 | } | |
1519 | } | |
1520 | ||
1521 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1522 | # isn't needed, but just in case, please keep it in for now. | |
1523 | gas_finish | |
1524 | ||
1525 | # Did we find what we were looking for? If not, flunk it. | |
1526 | if [expr $x==27] then { pass $testname } else { fail $testname } | |
1527 | } | |
1528 | ||
1529 | proc do_purge {} { | |
1530 | set testname "purge.s: purge tests" | |
1531 | set x 0 | |
1532 | ||
1533 | gas_start "purge.s" "-al" | |
1534 | ||
1535 | # Check the assembled instruction against a table built by the HP assembler | |
1536 | # Any differences should be checked by hand -- with the number of problems | |
1537 | # I've seen in the HP assembler I don't completely trust it. | |
1538 | # | |
1539 | # Instead of having a variable for each match string just increment the | |
1540 | # total number of matches seen. That's simpler when testing large numbers | |
1541 | # of instructions (as these tests to). | |
1542 | while 1 { | |
1543 | expect { | |
1544 | -re "^ +\[0-9\]+ 0000 04A41200\[^\n]*\n" { set x [expr $x+1] } | |
1545 | -re "^ +\[0-9\]+ 0004 04A41220\[^\n]*\n" { set x [expr $x+1] } | |
1546 | -re "^ +\[0-9\]+ 0008 04A42200\[^\n]*\n" { set x [expr $x+1] } | |
1547 | -re "^ +\[0-9\]+ 000c 04A42220\[^\n]*\n" { set x [expr $x+1] } | |
1548 | -re "^ +\[0-9\]+ 0010 04A41240\[^\n]*\n" { set x [expr $x+1] } | |
1549 | -re "^ +\[0-9\]+ 0014 04A41260\[^\n]*\n" { set x [expr $x+1] } | |
1550 | -re "^ +\[0-9\]+ 0018 04A42240\[^\n]*\n" { set x [expr $x+1] } | |
1551 | -re "^ +\[0-9\]+ 001c 04A42260\[^\n]*\n" { set x [expr $x+1] } | |
1552 | -re "^ +\[0-9\]+ 0020 04A41380\[^\n]*\n" { set x [expr $x+1] } | |
1553 | -re "^ +\[0-9\]+ 0024 04A413A0\[^\n]*\n" { set x [expr $x+1] } | |
1554 | -re "^ +\[0-9\]+ 0028 04A41280\[^\n]*\n" { set x [expr $x+1] } | |
1555 | -re "^ +\[0-9\]+ 002c 04A412A0\[^\n]*\n" { set x [expr $x+1] } | |
1556 | -re "^ +\[0-9\]+ 0030 04A42280\[^\n]*\n" { set x [expr $x+1] } | |
1557 | -re "^ +\[0-9\]+ 0034 04A422A0\[^\n]*\n" { set x [expr $x+1] } | |
1558 | -re "^ +\[0-9\]+ 0038 04A412C0\[^\n]*\n" { set x [expr $x+1] } | |
1559 | -re "^ +\[0-9\]+ 003c 04A412E0\[^\n]*\n" { set x [expr $x+1] } | |
1560 | -re "^ +\[0-9\]+ 0040 04A422C0\[^\n]*\n" { set x [expr $x+1] } | |
1561 | -re "^ +\[0-9\]+ 0044 04A422E0\[^\n]*\n" { set x [expr $x+1] } | |
1562 | ||
1563 | -re "\[^\n\]*\n" { } | |
1564 | timeout { perror "timeout\n"; break } | |
1565 | eof { break } | |
1566 | } | |
1567 | } | |
1568 | ||
1569 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1570 | # isn't needed, but just in case, please keep it in for now. | |
1571 | gas_finish | |
1572 | ||
1573 | # Did we find what we were looking for? If not, flunk it. | |
1574 | if [expr $x==18] then { pass $testname } else { fail $testname } | |
1575 | } | |
1576 | ||
1577 | proc do_fp_misc {} { | |
1578 | set testname "fp_misc.s: fp_misc tests" | |
1579 | set x 0 | |
1580 | ||
1581 | gas_start "fp_misc.s" "-al" | |
1582 | ||
1583 | # Check the assembled instruction against a table built by the HP assembler | |
1584 | # Any differences should be checked by hand -- with the number of problems | |
1585 | # I've seen in the HP assembler I don't completely trust it. | |
1586 | # | |
1587 | # Instead of having a variable for each match string just increment the | |
1588 | # total number of matches seen. That's simpler when testing large numbers | |
1589 | # of instructions (as these tests to). | |
1590 | while 1 { | |
1591 | expect { | |
1592 | -re "^ +\[0-9\]+ 0000 30002420\[^\n\]*\n" { set x [expr $x+1] } | |
1593 | -re "\[^\n\]*\n" { } | |
1594 | timeout { perror "timeout\n"; break } | |
1595 | eof { break } | |
1596 | } | |
1597 | } | |
1598 | ||
1599 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1600 | # isn't needed, but just in case, please keep it in for now. | |
1601 | gas_finish | |
1602 | ||
1603 | # Did we find what we were looking for? If not, flunk it. | |
1604 | if [expr $x==1] then { pass $testname } else { fail $testname } | |
1605 | } | |
1606 | ||
1607 | proc do_fmem {} { | |
1608 | set testname "fmem.s: fmem tests" | |
1609 | set x 0 | |
1610 | ||
1611 | gas_start "fmem.s" "-al" | |
1612 | ||
1613 | # Check the assembled instruction against a table built by the HP assembler | |
1614 | # Any differences should be checked by hand -- with the number of problems | |
1615 | # I've seen in the HP assembler I don't completely trust it. | |
1616 | # | |
1617 | # Instead of having a variable for each match string just increment the | |
1618 | # total number of matches seen. That's simpler when testing large numbers | |
1619 | # of instructions (as these tests to). | |
1620 | while 1 { | |
1621 | expect { | |
1622 | -re "^ +\[0-9\]+ 0000 24A40006\[^\n\]*\n" { set x [expr $x+1] } | |
1623 | -re "^ +\[0-9\]+ 0004 24A42006\[^\n\]*\n" { set x [expr $x+1] } | |
1624 | -re "^ +\[0-9\]+ 0008 24A40026\[^\n\]*\n" { set x [expr $x+1] } | |
1625 | -re "^ +\[0-9\]+ 000c 24A42026\[^\n\]*\n" { set x [expr $x+1] } | |
1626 | -re "^ +\[0-9\]+ 0010 2CA40006\[^\n\]*\n" { set x [expr $x+1] } | |
1627 | -re "^ +\[0-9\]+ 0014 2CA42006\[^\n\]*\n" { set x [expr $x+1] } | |
1628 | -re "^ +\[0-9\]+ 0018 2CA40026\[^\n\]*\n" { set x [expr $x+1] } | |
1629 | -re "^ +\[0-9\]+ 001c 2CA42026\[^\n\]*\n" { set x [expr $x+1] } | |
1630 | -re "^ +\[0-9\]+ 0020 24A40206\[^\n\]*\n" { set x [expr $x+1] } | |
1631 | -re "^ +\[0-9\]+ 0024 24A42206\[^\n\]*\n" { set x [expr $x+1] } | |
1632 | -re "^ +\[0-9\]+ 0028 24A40226\[^\n\]*\n" { set x [expr $x+1] } | |
1633 | -re "^ +\[0-9\]+ 002c 24A42226\[^\n\]*\n" { set x [expr $x+1] } | |
1634 | -re "^ +\[0-9\]+ 0030 2CA40206\[^\n\]*\n" { set x [expr $x+1] } | |
1635 | -re "^ +\[0-9\]+ 0034 2CA42206\[^\n\]*\n" { set x [expr $x+1] } | |
1636 | -re "^ +\[0-9\]+ 0038 2CA40226\[^\n\]*\n" { set x [expr $x+1] } | |
1637 | -re "^ +\[0-9\]+ 003c 2CA42226\[^\n\]*\n" { set x [expr $x+1] } | |
1638 | -re "^ +\[0-9\]+ 0040 3CA40206\[^\n\]*\n" { set x [expr $x+1] } | |
1639 | -re "^ +\[0-9\]+ 0044 3CA42206\[^\n\]*\n" { set x [expr $x+1] } | |
1640 | -re "^ +\[0-9\]+ 0048 3CA40226\[^\n\]*\n" { set x [expr $x+1] } | |
1641 | -re "^ +\[0-9\]+ 004c 3CA42226\[^\n\]*\n" { set x [expr $x+1] } | |
1642 | -re "^ +\[0-9\]+ 0050 24A01006\[^\n\]*\n" { set x [expr $x+1] } | |
1643 | -re "^ +\[0-9\]+ 0054 24A03026\[^\n\]*\n" { set x [expr $x+1] } | |
1644 | -re "^ +\[0-9\]+ 0058 24A01026\[^\n\]*\n" { set x [expr $x+1] } | |
1645 | -re "^ +\[0-9\]+ 005c 2CA01006\[^\n\]*\n" { set x [expr $x+1] } | |
1646 | -re "^ +\[0-9\]+ 0060 2CA03026\[^\n\]*\n" { set x [expr $x+1] } | |
1647 | -re "^ +\[0-9\]+ 0064 2CA01026\[^\n\]*\n" { set x [expr $x+1] } | |
1648 | -re "^ +\[0-9\]+ 0068 24A01206\[^\n\]*\n" { set x [expr $x+1] } | |
1649 | -re "^ +\[0-9\]+ 006c 24A03226\[^\n\]*\n" { set x [expr $x+1] } | |
1650 | -re "^ +\[0-9\]+ 0070 24A01226\[^\n\]*\n" { set x [expr $x+1] } | |
1651 | -re "^ +\[0-9\]+ 0074 2CA01206\[^\n\]*\n" { set x [expr $x+1] } | |
1652 | -re "^ +\[0-9\]+ 0078 2CA03226\[^\n\]*\n" { set x [expr $x+1] } | |
1653 | -re "^ +\[0-9\]+ 007c 2CA01226\[^\n\]*\n" { set x [expr $x+1] } | |
1654 | -re "^ +\[0-9\]+ 0080 3CA01206\[^\n\]*\n" { set x [expr $x+1] } | |
1655 | -re "^ +\[0-9\]+ 0084 3CA03226\[^\n\]*\n" { set x [expr $x+1] } | |
1656 | -re "^ +\[0-9\]+ 0088 3CA01226\[^\n\]*\n" { set x [expr $x+1] } | |
1657 | -re "\[^\n\]*\n" { } | |
1658 | timeout { perror "timeout\n"; break } | |
1659 | eof { break } | |
1660 | } | |
1661 | } | |
1662 | ||
1663 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1664 | # isn't needed, but just in case, please keep it in for now. | |
1665 | gas_finish | |
1666 | ||
1667 | # Did we find what we were looking for? If not, flunk it. | |
1668 | if [expr $x==35] then { pass $testname } else { fail $testname } | |
1669 | } | |
1670 | ||
1671 | proc do_fp_comp {} { | |
1672 | set testname "fp_comp.s: fp_comp tests" | |
1673 | set x 0 | |
1674 | ||
1675 | gas_start "fp_comp.s" "-al" | |
1676 | ||
1677 | # Check the assembled instruction against a table built by the HP assembler | |
1678 | # Any differences should be checked by hand -- with the number of problems | |
1679 | # I've seen in the HP assembler I don't completely trust it. | |
1680 | # | |
1681 | # Instead of having a variable for each match string just increment the | |
1682 | # total number of matches seen. That's simpler when testing large numbers | |
1683 | # of instructions (as these tests to). | |
1684 | while 1 { | |
1685 | expect { | |
1686 | -re "^ +\[0-9\]+ 0000 30A0400A\[^\n\]*\n" { set x [expr $x+1] } | |
1687 | -re "^ +\[0-9\]+ 0004 30A0480A\[^\n\]*\n" { set x [expr $x+1] } | |
1688 | -re "^ +\[0-9\]+ 0008 30A0580A\[^\n\]*\n" { set x [expr $x+1] } | |
1689 | -re "^ +\[0-9\]+ 000c 32804018\[^\n\]*\n" { set x [expr $x+1] } | |
1690 | -re "^ +\[0-9\]+ 0010 32804818\[^\n\]*\n" { set x [expr $x+1] } | |
1691 | -re "^ +\[0-9\]+ 0014 30A0600A\[^\n\]*\n" { set x [expr $x+1] } | |
1692 | -re "^ +\[0-9\]+ 0018 30A0680A\[^\n\]*\n" { set x [expr $x+1] } | |
1693 | -re "^ +\[0-9\]+ 001c 30A0780A\[^\n\]*\n" { set x [expr $x+1] } | |
1694 | -re "^ +\[0-9\]+ 0020 32806018\[^\n\]*\n" { set x [expr $x+1] } | |
1695 | -re "^ +\[0-9\]+ 0024 32806818\[^\n\]*\n" { set x [expr $x+1] } | |
1696 | -re "^ +\[0-9\]+ 0028 30A0800A\[^\n\]*\n" { set x [expr $x+1] } | |
1697 | -re "^ +\[0-9\]+ 002c 30A0880A\[^\n\]*\n" { set x [expr $x+1] } | |
1698 | -re "^ +\[0-9\]+ 0030 30A0980A\[^\n\]*\n" { set x [expr $x+1] } | |
1699 | -re "^ +\[0-9\]+ 0034 32808018\[^\n\]*\n" { set x [expr $x+1] } | |
1700 | -re "^ +\[0-9\]+ 0038 32808818\[^\n\]*\n" { set x [expr $x+1] } | |
1701 | -re "^ +\[0-9\]+ 003c 30A0A00A\[^\n\]*\n" { set x [expr $x+1] } | |
1702 | -re "^ +\[0-9\]+ 0040 30A0A80A\[^\n\]*\n" { set x [expr $x+1] } | |
1703 | -re "^ +\[0-9\]+ 0044 30A0B80A\[^\n\]*\n" { set x [expr $x+1] } | |
1704 | -re "^ +\[0-9\]+ 0048 3280A018\[^\n\]*\n" { set x [expr $x+1] } | |
1705 | -re "^ +\[0-9\]+ 004c 3280A818\[^\n\]*\n" { set x [expr $x+1] } | |
1706 | -re "^ +\[0-9\]+ 0050 3088060C\[^\n\]*\n" { set x [expr $x+1] } | |
1707 | -re "^ +\[0-9\]+ 0054 30880E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1708 | -re "^ +\[0-9\]+ 0058 30881E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1709 | -re "^ +\[0-9\]+ 005c 3298061C\[^\n\]*\n" { set x [expr $x+1] } | |
1710 | -re "^ +\[0-9\]+ 0060 32980E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1711 | -re "^ +\[0-9\]+ 0064 32981E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1712 | -re "^ +\[0-9\]+ 0068 3088260C\[^\n\]*\n" { set x [expr $x+1] } | |
1713 | -re "^ +\[0-9\]+ 006c 30882E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1714 | -re "^ +\[0-9\]+ 0070 30883E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1715 | -re "^ +\[0-9\]+ 0074 3298261C\[^\n\]*\n" { set x [expr $x+1] } | |
1716 | -re "^ +\[0-9\]+ 0078 32982E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1717 | -re "^ +\[0-9\]+ 007c 32983E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1718 | -re "^ +\[0-9\]+ 0080 3088460C\[^\n\]*\n" { set x [expr $x+1] } | |
1719 | -re "^ +\[0-9\]+ 0084 30884E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1720 | -re "^ +\[0-9\]+ 0088 30885E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1721 | -re "^ +\[0-9\]+ 008c 3298461C\[^\n\]*\n" { set x [expr $x+1] } | |
1722 | -re "^ +\[0-9\]+ 0090 32984E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1723 | -re "^ +\[0-9\]+ 0094 32985E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1724 | -re "^ +\[0-9\]+ 0098 3088660C\[^\n\]*\n" { set x [expr $x+1] } | |
1725 | -re "^ +\[0-9\]+ 009c 30886E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1726 | -re "^ +\[0-9\]+ 00a0 30887E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1727 | -re "^ +\[0-9\]+ 00a4 3298661C\[^\n\]*\n" { set x [expr $x+1] } | |
1728 | -re "^ +\[0-9\]+ 00a8 32986E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1729 | -re "^ +\[0-9\]+ 00ac 32987E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1730 | -re "^ +\[0-9\]+ 00b0 3088860C\[^\n\]*\n" { set x [expr $x+1] } | |
1731 | -re "^ +\[0-9\]+ 00b4 30888E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1732 | -re "^ +\[0-9\]+ 00b8 30889E0C\[^\n\]*\n" { set x [expr $x+1] } | |
1733 | -re "^ +\[0-9\]+ 00bc 3298861C\[^\n\]*\n" { set x [expr $x+1] } | |
1734 | -re "^ +\[0-9\]+ 00c0 32988E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1735 | -re "^ +\[0-9\]+ 00c4 32989E1C\[^\n\]*\n" { set x [expr $x+1] } | |
1736 | -re "^ +\[0-9\]+ 00c8 180120E2\[^\n\]*\n" { set x [expr $x+1] } | |
1737 | -re "^ +\[0-9\]+ 00cc 1A11A4D2\[^\n\]*\n" { set x [expr $x+1] } | |
1738 | -re "^ +\[0-9\]+ 00d0 980120E2\[^\n\]*\n" { set x [expr $x+1] } | |
1739 | -re "^ +\[0-9\]+ 00d4 9A11A4D2\[^\n\]*\n" { set x [expr $x+1] } | |
1740 | -re "^ +\[0-9\]+ 00d8 38854706\[^\n\]*\n" { set x [expr $x+1] } | |
1741 | -re "\[^\n\]*\n" { } | |
1742 | timeout { perror "timeout\n"; break } | |
1743 | eof { break } | |
1744 | } | |
1745 | } | |
1746 | ||
1747 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1748 | # isn't needed, but just in case, please keep it in for now. | |
1749 | gas_finish | |
1750 | ||
1751 | # Did we find what we were looking for? If not, flunk it. | |
1752 | if [expr $x==55] then { pass $testname } else { fail $testname } | |
1753 | } | |
1754 | ||
1755 | proc do_fp_conv {} { | |
1756 | set testname "fp_conv.s: fp_conv tests" | |
1757 | set x 0 | |
1758 | ||
1759 | gas_start "fp_conv.s" "-al" | |
1760 | ||
1761 | # Check the assembled instruction against a table built by the HP assembler | |
1762 | # Any differences should be checked by hand -- with the number of problems | |
1763 | # I've seen in the HP assembler I don't completely trust it. | |
1764 | # | |
1765 | # Instead of having a variable for each match string just increment the | |
1766 | # total number of matches seen. That's simpler when testing large numbers | |
1767 | # of instructions (as these tests to). | |
1768 | while 1 { | |
1769 | expect { | |
1770 | -re "^ +\[0-9\]+ 0000 30A0020A\[^\n\]*\n" { set x [expr $x+1] } | |
1771 | -re "^ +\[0-9\]+ 0004 30A0220A\[^\n\]*\n" { set x [expr $x+1] } | |
1772 | -re "^ +\[0-9\]+ 0008 30A0620A\[^\n\]*\n" { set x [expr $x+1] } | |
1773 | -re "^ +\[0-9\]+ 000c 30A00A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1774 | -re "^ +\[0-9\]+ 0010 30A02A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1775 | -re "^ +\[0-9\]+ 0014 30A06A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1776 | -re "^ +\[0-9\]+ 0018 30A01A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1777 | -re "^ +\[0-9\]+ 001c 30A03A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1778 | -re "^ +\[0-9\]+ 0020 30A07A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1779 | -re "^ +\[0-9\]+ 0024 32800218\[^\n\]*\n" { set x [expr $x+1] } | |
1780 | -re "^ +\[0-9\]+ 0028 32802218\[^\n\]*\n" { set x [expr $x+1] } | |
1781 | -re "^ +\[0-9\]+ 002c 32806218\[^\n\]*\n" { set x [expr $x+1] } | |
1782 | -re "^ +\[0-9\]+ 0030 32800A18\[^\n\]*\n" { set x [expr $x+1] } | |
1783 | -re "^ +\[0-9\]+ 0034 32802A18\[^\n\]*\n" { set x [expr $x+1] } | |
1784 | -re "^ +\[0-9\]+ 0038 32806A18\[^\n\]*\n" { set x [expr $x+1] } | |
1785 | -re "^ +\[0-9\]+ 003c 32801A18\[^\n\]*\n" { set x [expr $x+1] } | |
1786 | -re "^ +\[0-9\]+ 0040 32803A18\[^\n\]*\n" { set x [expr $x+1] } | |
1787 | -re "^ +\[0-9\]+ 0044 32807A18\[^\n\]*\n" { set x [expr $x+1] } | |
1788 | -re "^ +\[0-9\]+ 0048 30A0820A\[^\n\]*\n" { set x [expr $x+1] } | |
1789 | -re "^ +\[0-9\]+ 004c 30A0A20A\[^\n\]*\n" { set x [expr $x+1] } | |
1790 | -re "^ +\[0-9\]+ 0050 30A0E20A\[^\n\]*\n" { set x [expr $x+1] } | |
1791 | -re "^ +\[0-9\]+ 0054 30A08A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1792 | -re "^ +\[0-9\]+ 0058 30A0AA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1793 | -re "^ +\[0-9\]+ 005c 30A0EA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1794 | -re "^ +\[0-9\]+ 0060 30A09A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1795 | -re "^ +\[0-9\]+ 0064 30A0BA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1796 | -re "^ +\[0-9\]+ 0068 30A0FA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1797 | -re "^ +\[0-9\]+ 006c 32808218\[^\n\]*\n" { set x [expr $x+1] } | |
1798 | -re "^ +\[0-9\]+ 0070 3280A218\[^\n\]*\n" { set x [expr $x+1] } | |
1799 | -re "^ +\[0-9\]+ 0074 3280E218\[^\n\]*\n" { set x [expr $x+1] } | |
1800 | -re "^ +\[0-9\]+ 0078 32808A18\[^\n\]*\n" { set x [expr $x+1] } | |
1801 | -re "^ +\[0-9\]+ 007c 3280AA18\[^\n\]*\n" { set x [expr $x+1] } | |
1802 | -re "^ +\[0-9\]+ 0080 3280EA18\[^\n\]*\n" { set x [expr $x+1] } | |
1803 | -re "^ +\[0-9\]+ 0084 32809A18\[^\n\]*\n" { set x [expr $x+1] } | |
1804 | -re "^ +\[0-9\]+ 0088 3280BA18\[^\n\]*\n" { set x [expr $x+1] } | |
1805 | -re "^ +\[0-9\]+ 008c 3280FA18\[^\n\]*\n" { set x [expr $x+1] } | |
1806 | -re "^ +\[0-9\]+ 0090 30A1020A\[^\n\]*\n" { set x [expr $x+1] } | |
1807 | -re "^ +\[0-9\]+ 0094 30A1220A\[^\n\]*\n" { set x [expr $x+1] } | |
1808 | -re "^ +\[0-9\]+ 0098 30A1620A\[^\n\]*\n" { set x [expr $x+1] } | |
1809 | -re "^ +\[0-9\]+ 009c 30A10A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1810 | -re "^ +\[0-9\]+ 00a0 30A12A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1811 | -re "^ +\[0-9\]+ 00a4 30A16A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1812 | -re "^ +\[0-9\]+ 00a8 30A11A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1813 | -re "^ +\[0-9\]+ 00ac 30A13A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1814 | -re "^ +\[0-9\]+ 00b0 30A17A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1815 | -re "^ +\[0-9\]+ 00b4 32810218\[^\n\]*\n" { set x [expr $x+1] } | |
1816 | -re "^ +\[0-9\]+ 00b8 32812218\[^\n\]*\n" { set x [expr $x+1] } | |
1817 | -re "^ +\[0-9\]+ 00bc 32816218\[^\n\]*\n" { set x [expr $x+1] } | |
1818 | -re "^ +\[0-9\]+ 00c0 32810A18\[^\n\]*\n" { set x [expr $x+1] } | |
1819 | -re "^ +\[0-9\]+ 00c4 32812A18\[^\n\]*\n" { set x [expr $x+1] } | |
1820 | -re "^ +\[0-9\]+ 00c8 32816A18\[^\n\]*\n" { set x [expr $x+1] } | |
1821 | -re "^ +\[0-9\]+ 00cc 32811A18\[^\n\]*\n" { set x [expr $x+1] } | |
1822 | -re "^ +\[0-9\]+ 00d0 32813A18\[^\n\]*\n" { set x [expr $x+1] } | |
1823 | -re "^ +\[0-9\]+ 00d4 32817A18\[^\n\]*\n" { set x [expr $x+1] } | |
1824 | -re "^ +\[0-9\]+ 00d8 30A1820A\[^\n\]*\n" { set x [expr $x+1] } | |
1825 | -re "^ +\[0-9\]+ 00dc 30A1A20A\[^\n\]*\n" { set x [expr $x+1] } | |
1826 | -re "^ +\[0-9\]+ 00e0 30A1E20A\[^\n\]*\n" { set x [expr $x+1] } | |
1827 | -re "^ +\[0-9\]+ 00e4 30A18A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1828 | -re "^ +\[0-9\]+ 00e8 30A1AA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1829 | -re "^ +\[0-9\]+ 00ec 30A1EA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1830 | -re "^ +\[0-9\]+ 00f0 30A19A0A\[^\n\]*\n" { set x [expr $x+1] } | |
1831 | -re "^ +\[0-9\]+ 00f4 30A1BA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1832 | -re "^ +\[0-9\]+ 00f8 30A1FA0A\[^\n\]*\n" { set x [expr $x+1] } | |
1833 | -re "^ +\[0-9\]+ 00fc 32818218\[^\n\]*\n" { set x [expr $x+1] } | |
1834 | -re "^ +\[0-9\]+ 0100 3281A218\[^\n\]*\n" { set x [expr $x+1] } | |
1835 | -re "^ +\[0-9\]+ 0104 3281E218\[^\n\]*\n" { set x [expr $x+1] } | |
1836 | -re "^ +\[0-9\]+ 0108 32818A18\[^\n\]*\n" { set x [expr $x+1] } | |
1837 | -re "^ +\[0-9\]+ 010c 3281AA18\[^\n\]*\n" { set x [expr $x+1] } | |
1838 | -re "^ +\[0-9\]+ 0110 3281EA18\[^\n\]*\n" { set x [expr $x+1] } | |
1839 | -re "^ +\[0-9\]+ 0114 32819A18\[^\n\]*\n" { set x [expr $x+1] } | |
1840 | -re "^ +\[0-9\]+ 0118 3281BA18\[^\n\]*\n" { set x [expr $x+1] } | |
1841 | -re "^ +\[0-9\]+ 011c 3281FA18\[^\n\]*\n" { set x [expr $x+1] } | |
1842 | -re "\[^\n\]*\n" { } | |
1843 | timeout { perror "timeout\n"; break } | |
1844 | eof { break } | |
1845 | } | |
1846 | } | |
1847 | ||
1848 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1849 | # isn't needed, but just in case, please keep it in for now. | |
1850 | gas_finish | |
1851 | ||
1852 | # Did we find what we were looking for? If not, flunk it. | |
1853 | if [expr $x==72] then { pass $testname } else { fail $testname } | |
1854 | } | |
1855 | ||
1856 | proc do_fp_fcmp {} { | |
1857 | set testname "fp_fcmp.s: fp_fcmp tests" | |
1858 | set x 0 | |
1859 | ||
1860 | gas_start "fp_fcmp.s" "-al" | |
1861 | ||
1862 | # Check the assembled instruction against a table built by the HP assembler | |
1863 | # Any differences should be checked by hand -- with the number of problems | |
1864 | # I've seen in the HP assembler I don't completely trust it. | |
1865 | # | |
1866 | # Instead of having a variable for each match string just increment the | |
1867 | # total number of matches seen. That's simpler when testing large numbers | |
1868 | # of instructions (as these tests to). | |
1869 | while 1 { | |
1870 | expect { | |
1871 | -re "^ +\[0-9\]+ 0000 30850400\[^\n\]*\n" {set x [expr $x+1] } | |
1872 | -re "^ +\[0-9\]+ 0004 30850401\[^\n\]*\n" {set x [expr $x+1] } | |
1873 | -re "^ +\[0-9\]+ 0008 30850402\[^\n\]*\n" {set x [expr $x+1] } | |
1874 | -re "^ +\[0-9\]+ 000c 30850403\[^\n\]*\n" {set x [expr $x+1] } | |
1875 | -re "^ +\[0-9\]+ 0010 30850404\[^\n\]*\n" {set x [expr $x+1] } | |
1876 | -re "^ +\[0-9\]+ 0014 30850405\[^\n\]*\n" {set x [expr $x+1] } | |
1877 | -re "^ +\[0-9\]+ 0018 30850406\[^\n\]*\n" {set x [expr $x+1] } | |
1878 | -re "^ +\[0-9\]+ 001c 30850407\[^\n\]*\n" {set x [expr $x+1] } | |
1879 | -re "^ +\[0-9\]+ 0020 30850408\[^\n\]*\n" {set x [expr $x+1] } | |
1880 | -re "^ +\[0-9\]+ 0024 30850409\[^\n\]*\n" {set x [expr $x+1] } | |
1881 | -re "^ +\[0-9\]+ 0028 3085040A\[^\n\]*\n" {set x [expr $x+1] } | |
1882 | -re "^ +\[0-9\]+ 002c 3085040B\[^\n\]*\n" {set x [expr $x+1] } | |
1883 | -re "^ +\[0-9\]+ 0030 3085040C\[^\n\]*\n" {set x [expr $x+1] } | |
1884 | -re "^ +\[0-9\]+ 0034 3085040D\[^\n\]*\n" {set x [expr $x+1] } | |
1885 | -re "^ +\[0-9\]+ 0038 3085040E\[^\n\]*\n" {set x [expr $x+1] } | |
1886 | -re "^ +\[0-9\]+ 003c 3085040F\[^\n\]*\n" {set x [expr $x+1] } | |
1887 | -re "^ +\[0-9\]+ 0040 30850410\[^\n\]*\n" {set x [expr $x+1] } | |
1888 | -re "^ +\[0-9\]+ 0044 30850411\[^\n\]*\n" {set x [expr $x+1] } | |
1889 | -re "^ +\[0-9\]+ 0048 30850412\[^\n\]*\n" {set x [expr $x+1] } | |
1890 | -re "^ +\[0-9\]+ 004c 30850413\[^\n\]*\n" {set x [expr $x+1] } | |
1891 | -re "^ +\[0-9\]+ 0050 30850414\[^\n\]*\n" {set x [expr $x+1] } | |
1892 | -re "^ +\[0-9\]+ 0054 30850415\[^\n\]*\n" {set x [expr $x+1] } | |
1893 | -re "^ +\[0-9\]+ 0058 30850416\[^\n\]*\n" {set x [expr $x+1] } | |
1894 | -re "^ +\[0-9\]+ 005c 30850417\[^\n\]*\n" {set x [expr $x+1] } | |
1895 | -re "^ +\[0-9\]+ 0060 30850418\[^\n\]*\n" {set x [expr $x+1] } | |
1896 | -re "^ +\[0-9\]+ 0064 30850419\[^\n\]*\n" {set x [expr $x+1] } | |
1897 | -re "^ +\[0-9\]+ 0068 3085041A\[^\n\]*\n" {set x [expr $x+1] } | |
1898 | -re "^ +\[0-9\]+ 006c 3085041B\[^\n\]*\n" {set x [expr $x+1] } | |
1899 | -re "^ +\[0-9\]+ 0070 3085041C\[^\n\]*\n" {set x [expr $x+1] } | |
1900 | -re "^ +\[0-9\]+ 0074 3085041D\[^\n\]*\n" {set x [expr $x+1] } | |
1901 | -re "^ +\[0-9\]+ 0078 3085041E\[^\n\]*\n" {set x [expr $x+1] } | |
1902 | -re "^ +\[0-9\]+ 007c 3085041F\[^\n\]*\n" {set x [expr $x+1] } | |
1903 | -re "^ +\[0-9\]+ 0080 30850C00\[^\n\]*\n" {set x [expr $x+1] } | |
1904 | -re "^ +\[0-9\]+ 0084 30850C01\[^\n\]*\n" {set x [expr $x+1] } | |
1905 | -re "^ +\[0-9\]+ 0088 30850C02\[^\n\]*\n" {set x [expr $x+1] } | |
1906 | -re "^ +\[0-9\]+ 008c 30850C03\[^\n\]*\n" {set x [expr $x+1] } | |
1907 | -re "^ +\[0-9\]+ 0090 30850C04\[^\n\]*\n" {set x [expr $x+1] } | |
1908 | -re "^ +\[0-9\]+ 0094 30850C05\[^\n\]*\n" {set x [expr $x+1] } | |
1909 | -re "^ +\[0-9\]+ 0098 30850C06\[^\n\]*\n" {set x [expr $x+1] } | |
1910 | -re "^ +\[0-9\]+ 009c 30850C07\[^\n\]*\n" {set x [expr $x+1] } | |
1911 | -re "^ +\[0-9\]+ 00a0 30850C08\[^\n\]*\n" {set x [expr $x+1] } | |
1912 | -re "^ +\[0-9\]+ 00a4 30850C09\[^\n\]*\n" {set x [expr $x+1] } | |
1913 | -re "^ +\[0-9\]+ 00a8 30850C0A\[^\n\]*\n" {set x [expr $x+1] } | |
1914 | -re "^ +\[0-9\]+ 00ac 30850C0B\[^\n\]*\n" {set x [expr $x+1] } | |
1915 | -re "^ +\[0-9\]+ 00b0 30850C0C\[^\n\]*\n" {set x [expr $x+1] } | |
1916 | -re "^ +\[0-9\]+ 00b4 30850C0D\[^\n\]*\n" {set x [expr $x+1] } | |
1917 | -re "^ +\[0-9\]+ 00b8 30850C0E\[^\n\]*\n" {set x [expr $x+1] } | |
1918 | -re "^ +\[0-9\]+ 00bc 30850C0F\[^\n\]*\n" {set x [expr $x+1] } | |
1919 | -re "^ +\[0-9\]+ 00c0 30850C10\[^\n\]*\n" {set x [expr $x+1] } | |
1920 | -re "^ +\[0-9\]+ 00c4 30850C11\[^\n\]*\n" {set x [expr $x+1] } | |
1921 | -re "^ +\[0-9\]+ 00c8 30850C12\[^\n\]*\n" {set x [expr $x+1] } | |
1922 | -re "^ +\[0-9\]+ 00cc 30850C13\[^\n\]*\n" {set x [expr $x+1] } | |
1923 | -re "^ +\[0-9\]+ 00d0 30850C14\[^\n\]*\n" {set x [expr $x+1] } | |
1924 | -re "^ +\[0-9\]+ 00d4 30850C15\[^\n\]*\n" {set x [expr $x+1] } | |
1925 | -re "^ +\[0-9\]+ 00d8 30850C16\[^\n\]*\n" {set x [expr $x+1] } | |
1926 | -re "^ +\[0-9\]+ 00dc 30850C17\[^\n\]*\n" {set x [expr $x+1] } | |
1927 | -re "^ +\[0-9\]+ 00e0 30850C18\[^\n\]*\n" {set x [expr $x+1] } | |
1928 | -re "^ +\[0-9\]+ 00e4 30850C19\[^\n\]*\n" {set x [expr $x+1] } | |
1929 | -re "^ +\[0-9\]+ 00e8 30850C1A\[^\n\]*\n" {set x [expr $x+1] } | |
1930 | -re "^ +\[0-9\]+ 00ec 30850C1B\[^\n\]*\n" {set x [expr $x+1] } | |
1931 | -re "^ +\[0-9\]+ 00f0 30850C1C\[^\n\]*\n" {set x [expr $x+1] } | |
1932 | -re "^ +\[0-9\]+ 00f4 30850C1D\[^\n\]*\n" {set x [expr $x+1] } | |
1933 | -re "^ +\[0-9\]+ 00f8 30850C1E\[^\n\]*\n" {set x [expr $x+1] } | |
1934 | -re "^ +\[0-9\]+ 00fc 30850C1F\[^\n\]*\n" {set x [expr $x+1] } | |
1935 | -re "^ +\[0-9\]+ 0100 30851C00\[^\n\]*\n" {set x [expr $x+1] } | |
1936 | -re "^ +\[0-9\]+ 0104 30851C01\[^\n\]*\n" {set x [expr $x+1] } | |
1937 | -re "^ +\[0-9\]+ 0108 30851C02\[^\n\]*\n" {set x [expr $x+1] } | |
1938 | -re "^ +\[0-9\]+ 010c 30851C03\[^\n\]*\n" {set x [expr $x+1] } | |
1939 | -re "^ +\[0-9\]+ 0110 30851C04\[^\n\]*\n" {set x [expr $x+1] } | |
1940 | -re "^ +\[0-9\]+ 0114 30851C05\[^\n\]*\n" {set x [expr $x+1] } | |
1941 | -re "^ +\[0-9\]+ 0118 30851C06\[^\n\]*\n" {set x [expr $x+1] } | |
1942 | -re "^ +\[0-9\]+ 011c 30851C07\[^\n\]*\n" {set x [expr $x+1] } | |
1943 | -re "^ +\[0-9\]+ 0120 30851C08\[^\n\]*\n" {set x [expr $x+1] } | |
1944 | -re "^ +\[0-9\]+ 0124 30851C09\[^\n\]*\n" {set x [expr $x+1] } | |
1945 | -re "^ +\[0-9\]+ 0128 30851C0A\[^\n\]*\n" {set x [expr $x+1] } | |
1946 | -re "^ +\[0-9\]+ 012c 30851C0B\[^\n\]*\n" {set x [expr $x+1] } | |
1947 | -re "^ +\[0-9\]+ 0130 30851C0C\[^\n\]*\n" {set x [expr $x+1] } | |
1948 | -re "^ +\[0-9\]+ 0134 30851C0D\[^\n\]*\n" {set x [expr $x+1] } | |
1949 | -re "^ +\[0-9\]+ 0138 30851C0E\[^\n\]*\n" {set x [expr $x+1] } | |
1950 | -re "^ +\[0-9\]+ 013c 30851C0F\[^\n\]*\n" {set x [expr $x+1] } | |
1951 | -re "^ +\[0-9\]+ 0140 30851C10\[^\n\]*\n" {set x [expr $x+1] } | |
1952 | -re "^ +\[0-9\]+ 0144 30851C11\[^\n\]*\n" {set x [expr $x+1] } | |
1953 | -re "^ +\[0-9\]+ 0148 30851C12\[^\n\]*\n" {set x [expr $x+1] } | |
1954 | -re "^ +\[0-9\]+ 014c 30851C13\[^\n\]*\n" {set x [expr $x+1] } | |
1955 | -re "^ +\[0-9\]+ 0150 30851C14\[^\n\]*\n" {set x [expr $x+1] } | |
1956 | -re "^ +\[0-9\]+ 0154 30851C15\[^\n\]*\n" {set x [expr $x+1] } | |
1957 | -re "^ +\[0-9\]+ 0158 30851C16\[^\n\]*\n" {set x [expr $x+1] } | |
1958 | -re "^ +\[0-9\]+ 015c 30851C17\[^\n\]*\n" {set x [expr $x+1] } | |
1959 | -re "^ +\[0-9\]+ 0160 30851C18\[^\n\]*\n" {set x [expr $x+1] } | |
1960 | -re "^ +\[0-9\]+ 0164 30851C19\[^\n\]*\n" {set x [expr $x+1] } | |
1961 | -re "^ +\[0-9\]+ 0168 30851C1A\[^\n\]*\n" {set x [expr $x+1] } | |
1962 | -re "^ +\[0-9\]+ 016c 30851C1B\[^\n\]*\n" {set x [expr $x+1] } | |
1963 | -re "^ +\[0-9\]+ 0170 30851C1C\[^\n\]*\n" {set x [expr $x+1] } | |
1964 | -re "^ +\[0-9\]+ 0174 30851C1D\[^\n\]*\n" {set x [expr $x+1] } | |
1965 | -re "^ +\[0-9\]+ 0178 30851C1E\[^\n\]*\n" {set x [expr $x+1] } | |
1966 | -re "^ +\[0-9\]+ 017c 30851C1F\[^\n\]*\n" {set x [expr $x+1] } | |
1967 | -re "\[^\n\]*\n" { } | |
1968 | timeout { perror "timeout\n"; break } | |
1969 | eof { break } | |
1970 | } | |
1971 | } | |
1972 | ||
1973 | # This was intended to do any cleanup necessary. It kinda looks like it | |
1974 | # isn't needed, but just in case, please keep it in for now. | |
1975 | gas_finish | |
1976 | ||
1977 | # Did we find what we were looking for? If not, flunk it. | |
1978 | if [expr $x==96] then { pass $testname } else { fail $testname } | |
1979 | } | |
1980 | ||
1981 | proc do_special {} { | |
1982 | set testname "special.s: special tests" | |
1983 | set x 0 | |
1984 | ||
1985 | gas_start "special.s" "-al" | |
1986 | ||
1987 | # Check the assembled instruction against a table built by the HP assembler | |
1988 | # Any differences should be checked by hand -- with the number of problems | |
1989 | # I've seen in the HP assembler I don't completely trust it. | |
1990 | # | |
1991 | # Instead of having a variable for each match string just increment the | |
1992 | # total number of matches seen. That's simpler when testing large numbers | |
1993 | # of instructions (as these tests to). | |
1994 | while 1 { | |
1995 | expect { | |
1996 | -re "^ +\[0-9\]+ 0000 04A41680\[^\n\]*\n" { set x [expr $x+1] } | |
1997 | -re "^ +\[0-9\]+ 0004 04A416A0\[^\n\]*\n" { set x [expr $x+1] } | |
1998 | -re "^ +\[0-9\]+ 0008 04A41A80\[^\n\]*\n" { set x [expr $x+1] } | |
1999 | -re "^ +\[0-9\]+ 000c 04A41AA0\[^\n\]*\n" { set x [expr $x+1] } | |
2000 | -re "\[^\n\]*\n" { } | |
2001 | timeout { perror "timeout\n"; break } | |
2002 | eof { break } | |
2003 | } | |
2004 | } | |
2005 | ||
2006 | # This was intended to do any cleanup necessary. It kinda looks like it | |
2007 | # isn't needed, but just in case, please keep it in for now. | |
2008 | gas_finish | |
2009 | ||
2010 | # Did we find what we were looking for? If not, flunk it. | |
2011 | if [expr $x==4] then { pass $testname } else { fail $testname } | |
2012 | } | |
2013 | ||
2014 | proc do_spop {} { | |
2015 | set testname "spop.s: spop tests" | |
2016 | set x 0 | |
2017 | ||
2018 | # This tickles a bug in the expression parser. | |
2019 | gas_start "spop.s" "-al" | |
2020 | ||
2021 | # Check the assembled instruction against a table built by the HP assembler | |
2022 | # Any differences should be checked by hand -- with the number of problems | |
2023 | # I've seen in the HP assembler I don't completely trust it. | |
2024 | # | |
2025 | # Instead of having a variable for each match string just increment the | |
2026 | # total number of matches seen. That's simpler when testing large numbers | |
2027 | # of instructions (as these tests to). | |
2028 | while 1 { | |
2029 | expect { | |
2030 | -re "^ +\[0-9\]+ 0000 10000105\[^\n\]*\n" { set x [expr $x+1] } | |
2031 | -re "^ +\[0-9\]+ 0004 10001913\[^\n\]*\n" { set x [expr $x+1] } | |
2032 | -re "^ +\[0-9\]+ 0008 10000125\[^\n\]*\n" { set x [expr $x+1] } | |
2033 | -re "^ +\[0-9\]+ 000c 10001933\[^\n\]*\n" { set x [expr $x+1] } | |
2034 | -re "^ +\[0-9\]+ 0010 10002B05\[^\n\]*\n" { set x [expr $x+1] } | |
2035 | -re "^ +\[0-9\]+ 0014 10039B05\[^\n\]*\n" { set x [expr $x+1] } | |
2036 | -re "^ +\[0-9\]+ 0018 10002B25\[^\n\]*\n" { set x [expr $x+1] } | |
2037 | -re "^ +\[0-9\]+ 001c 10039B25\[^\n\]*\n" { set x [expr $x+1] } | |
2038 | -re "^ +\[0-9\]+ 0020 10A00505\[^\n\]*\n" { set x [expr $x+1] } | |
2039 | -re "^ +\[0-9\]+ 0024 10A01D13\[^\n\]*\n" { set x [expr $x+1] } | |
2040 | -re "^ +\[0-9\]+ 0028 10A00525\[^\n\]*\n" { set x [expr $x+1] } | |
2041 | -re "^ +\[0-9\]+ 002c 10A01D33\[^\n\]*\n" { set x [expr $x+1] } | |
2042 | -re "^ +\[0-9\]+ 0030 10C50705\[^\n\]*\n" { set x [expr $x+1] } | |
2043 | -re "^ +\[0-9\]+ 0034 10C51F13\[^\n\]*\n" { set x [expr $x+1] } | |
2044 | -re "^ +\[0-9\]+ 0038 10C50725\[^\n\]*\n" { set x [expr $x+1] } | |
2045 | -re "^ +\[0-9\]+ 003c 10C51F33\[^\n\]*\n" { set x [expr $x+1] } | |
2046 | -re "\[^\n\]*\n" { } | |
2047 | timeout { perror "timeout\n"; break } | |
2048 | eof { break } | |
2049 | } | |
2050 | } | |
2051 | ||
2052 | # This was intended to do any cleanup necessary. It kinda looks like it | |
2053 | # isn't needed, but just in case, please keep it in for now. | |
2054 | gas_finish | |
2055 | ||
2056 | # Did we find what we were looking for? If not, flunk it. | |
2057 | if [expr $x==16] then { pass $testname } else { fail $testname } | |
2058 | } | |
2059 | ||
2060 | proc do_copr {} { | |
2061 | set testname "copr.s: copr tests" | |
2062 | set x 0 | |
2063 | ||
2064 | gas_start "copr.s" "-al" | |
2065 | ||
2066 | # Check the assembled instruction against a table built by the HP assembler | |
2067 | # Any differences should be checked by hand -- with the number of problems | |
2068 | # I've seen in the HP assembler I don't completely trust it. | |
2069 | # | |
2070 | # Instead of having a variable for each match string just increment the | |
2071 | # total number of matches seen. That's simpler when testing large numbers | |
2072 | # of instructions (as these tests to). | |
2073 | while 1 { | |
2074 | expect { | |
2075 | -re "^ +\[0-9\]+ 0000 30000105\[^\n\]*\n" { set x [expr $x+1] } | |
2076 | -re "^ +\[0-9\]+ 0004 30000713\[^\n\]*\n" { set x [expr $x+1] } | |
2077 | -re "^ +\[0-9\]+ 0008 30000125\[^\n\]*\n" { set x [expr $x+1] } | |
2078 | -re "^ +\[0-9\]+ 000c 30000733\[^\n\]*\n" { set x [expr $x+1] } | |
2079 | -re "\[^\n\]*\n" { } | |
2080 | timeout { perror "timeout\n"; break } | |
2081 | eof { break } | |
2082 | } | |
2083 | } | |
2084 | ||
2085 | # This was intended to do any cleanup necessary. It kinda looks like it | |
2086 | # isn't needed, but just in case, please keep it in for now. | |
2087 | gas_finish | |
2088 | ||
2089 | # Did we find what we were looking for? If not, flunk it. | |
2090 | if [expr $x==4] then { pass $testname } else { fail $testname } | |
2091 | } | |
2092 | ||
2093 | proc do_coprmem {} { | |
2094 | set testname "coprmem.s: copr memory tests" | |
2095 | set x 0 | |
2096 | ||
2097 | gas_start "coprmem.s" "-al" | |
2098 | ||
2099 | # Check the assembled instruction against a table built by the HP assembler | |
2100 | # Any differences should be checked by hand -- with the number of problems | |
2101 | # I've seen in the HP assembler I don't completely trust it. | |
2102 | # | |
2103 | # Instead of having a variable for each match string just increment the | |
2104 | # total number of matches seen. That's simpler when testing large numbers | |
2105 | # of instructions (as these tests to). | |
2106 | while 1 { | |
2107 | expect { | |
2108 | -re "^ +\[0-9\]+ 0000 2485011A\[^\n\]*\n" { set x [expr $x+1] } | |
2109 | -re "^ +\[0-9\]+ 0004 2485211A\[^\n\]*\n" { set x [expr $x+1] } | |
2110 | -re "^ +\[0-9\]+ 0008 2485013A\[^\n\]*\n" { set x [expr $x+1] } | |
2111 | -re "^ +\[0-9\]+ 000c 2485213A\[^\n\]*\n" { set x [expr $x+1] } | |
2112 | -re "^ +\[0-9\]+ 0010 2C85011A\[^\n\]*\n" { set x [expr $x+1] } | |
2113 | -re "^ +\[0-9\]+ 0014 2C85211A\[^\n\]*\n" { set x [expr $x+1] } | |
2114 | -re "^ +\[0-9\]+ 0018 2C85013A\[^\n\]*\n" { set x [expr $x+1] } | |
2115 | -re "^ +\[0-9\]+ 001c 2C85213A\[^\n\]*\n" { set x [expr $x+1] } | |
2116 | -re "^ +\[0-9\]+ 0020 2485031A\[^\n\]*\n" { set x [expr $x+1] } | |
2117 | -re "^ +\[0-9\]+ 0024 2485231A\[^\n\]*\n" { set x [expr $x+1] } | |
2118 | -re "^ +\[0-9\]+ 0028 2485033A\[^\n\]*\n" { set x [expr $x+1] } | |
2119 | -re "^ +\[0-9\]+ 002c 2485233A\[^\n\]*\n" { set x [expr $x+1] } | |
2120 | -re "^ +\[0-9\]+ 0030 2C85031A\[^\n\]*\n" { set x [expr $x+1] } | |
2121 | -re "^ +\[0-9\]+ 0034 2C85231A\[^\n\]*\n" { set x [expr $x+1] } | |
2122 | -re "^ +\[0-9\]+ 0038 2C85033A\[^\n\]*\n" { set x [expr $x+1] } | |
2123 | -re "^ +\[0-9\]+ 003c 2C85233A\[^\n\]*\n" { set x [expr $x+1] } | |
2124 | -re "^ +\[0-9\]+ 0040 2480111A\[^\n\]*\n" { set x [expr $x+1] } | |
2125 | -re "^ +\[0-9\]+ 0044 2480313A\[^\n\]*\n" { set x [expr $x+1] } | |
2126 | -re "^ +\[0-9\]+ 0048 2480113A\[^\n\]*\n" { set x [expr $x+1] } | |
2127 | -re "^ +\[0-9\]+ 004c 2C80111A\[^\n\]*\n" { set x [expr $x+1] } | |
2128 | -re "^ +\[0-9\]+ 0050 2C80313A\[^\n\]*\n" { set x [expr $x+1] } | |
2129 | -re "^ +\[0-9\]+ 0054 2C80113A\[^\n\]*\n" { set x [expr $x+1] } | |
2130 | -re "^ +\[0-9\]+ 0058 2480131A\[^\n\]*\n" { set x [expr $x+1] } | |
2131 | -re "^ +\[0-9\]+ 005c 2480333A\[^\n\]*\n" { set x [expr $x+1] } | |
2132 | -re "^ +\[0-9\]+ 0060 2480133A\[^\n\]*\n" { set x [expr $x+1] } | |
2133 | -re "^ +\[0-9\]+ 0064 2C80131A\[^\n\]*\n" { set x [expr $x+1] } | |
2134 | -re "^ +\[0-9\]+ 0068 2C80333A\[^\n\]*\n" { set x [expr $x+1] } | |
2135 | -re "^ +\[0-9\]+ 006c 2C80133A\[^\n\]*\n" { set x [expr $x+1] } | |
2136 | -re "\[^\n\]*\n" { } | |
2137 | timeout { perror "timeout\n"; break } | |
2138 | eof { break } | |
2139 | } | |
2140 | } | |
2141 | ||
2142 | # This was intended to do any cleanup necessary. It kinda looks like it | |
2143 | # isn't needed, but just in case, please keep it in for now. | |
2144 | gas_finish | |
2145 | ||
2146 | # Did we find what we were looking for? If not, flunk it. | |
2147 | if [expr $x==28] then { pass $testname } else { fail $testname } | |
2148 | } | |
2149 | ||
2150 | proc do_fmem_LR_tests {} { | |
2151 | set testname "fmemLRbug.s: LR register selection on fp mem instructions" | |
2152 | set x 0 | |
2153 | ||
2154 | gas_start "fmemLRbug.s" "-al" | |
2155 | ||
2156 | # Make sure we correctly handle field selectors. | |
2157 | while 1 { | |
2158 | expect { | |
2159 | -re "^ +\[0-9\]+ 0000 27401246\[^\n\]*\n" { set x [expr $x+1] } | |
2160 | -re "^ +\[0-9\]+ 0004 27481206\[^\n\]*\n" { set x [expr $x+1] } | |
2161 | -re "^ +\[0-9\]+ 0008 27501206\[^\n\]*\n" { set x [expr $x+1] } | |
2162 | -re "^ +\[0-9\]+ 000c 2F401206\[^\n\]*\n" { set x [expr $x+1] } | |
2163 | -re "^ +\[0-9\]+ 0010 2F481206\[^\n\]*\n" { set x [expr $x+1] } | |
2164 | -re "^ +\[0-9\]+ 0014 2F501206\[^\n\]*\n" { set x [expr $x+1] } | |
2165 | -re "^ +\[0-9\]+ 0018 27401046\[^\n\]*\n" { set x [expr $x+1] } | |
2166 | -re "^ +\[0-9\]+ 001c 27481006\[^\n\]*\n" { set x [expr $x+1] } | |
2167 | -re "^ +\[0-9\]+ 0020 27501006\[^\n\]*\n" { set x [expr $x+1] } | |
2168 | -re "^ +\[0-9\]+ 0024 2F401006\[^\n\]*\n" { set x [expr $x+1] } | |
2169 | -re "^ +\[0-9\]+ 0028 2F481006\[^\n\]*\n" { set x [expr $x+1] } | |
2170 | -re "^ +\[0-9\]+ 002c 2F501006\[^\n\]*\n" { set x [expr $x+1] } | |
2171 | -re "^ +\[0-9\]+ 0030 27401246\[^\n\]*\n" { set x [expr $x+1] } | |
2172 | -re "^ +\[0-9\]+ 0034 27481206\[^\n\]*\n" { set x [expr $x+1] } | |
2173 | -re "^ +\[0-9\]+ 0038 27501206\[^\n\]*\n" { set x [expr $x+1] } | |
2174 | -re "^ +\[0-9\]+ 003c 2F401206\[^\n\]*\n" { set x [expr $x+1] } | |
2175 | -re "^ +\[0-9\]+ 0040 2F481206\[^\n\]*\n" { set x [expr $x+1] } | |
2176 | -re "^ +\[0-9\]+ 0044 2F501206\[^\n\]*\n" { set x [expr $x+1] } | |
2177 | -re "^ +\[0-9\]+ 0048 27401046\[^\n\]*\n" { set x [expr $x+1] } | |
2178 | -re "^ +\[0-9\]+ 004c 27481006\[^\n\]*\n" { set x [expr $x+1] } | |
2179 | -re "^ +\[0-9\]+ 0050 27501006\[^\n\]*\n" { set x [expr $x+1] } | |
2180 | -re "^ +\[0-9\]+ 0054 2F401006\[^\n\]*\n" { set x [expr $x+1] } | |
2181 | -re "^ +\[0-9\]+ 0058 2F481006\[^\n\]*\n" { set x [expr $x+1] } | |
2182 | -re "^ +\[0-9\]+ 005c 2F501006\[^\n\]*\n" { set x [expr $x+1] } | |
2183 | -re "^ +\[0-9\]+ 0060 27590246\[^\n\]*\n" { set x [expr $x+1] } | |
2184 | -re "^ +\[0-9\]+ 0064 27590206\[^\n\]*\n" { set x [expr $x+1] } | |
2185 | -re "^ +\[0-9\]+ 0068 27590206\[^\n\]*\n" { set x [expr $x+1] } | |
2186 | -re "^ +\[0-9\]+ 006c 2F590206\[^\n\]*\n" { set x [expr $x+1] } | |
2187 | -re "^ +\[0-9\]+ 0070 2F590206\[^\n\]*\n" { set x [expr $x+1] } | |
2188 | -re "^ +\[0-9\]+ 0074 2F590206\[^\n\]*\n" { set x [expr $x+1] } | |
2189 | -re "^ +\[0-9\]+ 0078 27590046\[^\n\]*\n" { set x [expr $x+1] } | |
2190 | -re "^ +\[0-9\]+ 007c 27590006\[^\n\]*\n" { set x [expr $x+1] } | |
2191 | -re "^ +\[0-9\]+ 0080 27590006\[^\n\]*\n" { set x [expr $x+1] } | |
2192 | -re "^ +\[0-9\]+ 0084 2F590006\[^\n\]*\n" { set x [expr $x+1] } | |
2193 | -re "^ +\[0-9\]+ 0088 2F590006\[^\n\]*\n" { set x [expr $x+1] } | |
2194 | -re "^ +\[0-9\]+ 008c 2F590006\[^\n\]*\n" { set x [expr $x+1] } | |
2195 | -re "^ +\[0-9\]+ 0090 27590246\[^\n\]*\n" { set x [expr $x+1] } | |
2196 | -re "^ +\[0-9\]+ 0094 27590206\[^\n\]*\n" { set x [expr $x+1] } | |
2197 | -re "^ +\[0-9\]+ 0098 27590206\[^\n\]*\n" { set x [expr $x+1] } | |
2198 | -re "^ +\[0-9\]+ 009c 2F590206\[^\n\]*\n" { set x [expr $x+1] } | |
2199 | -re "^ +\[0-9\]+ 00a0 2F590206\[^\n\]*\n" { set x [expr $x+1] } | |
2200 | -re "^ +\[0-9\]+ 00a4 2F590206\[^\n\]*\n" { set x [expr $x+1] } | |
2201 | -re "^ +\[0-9\]+ 00a8 27590046\[^\n\]*\n" { set x [expr $x+1] } | |
2202 | -re "^ +\[0-9\]+ 00ac 27590006\[^\n\]*\n" { set x [expr $x+1] } | |
2203 | -re "^ +\[0-9\]+ 00b0 27590006\[^\n\]*\n" { set x [expr $x+1] } | |
2204 | -re "^ +\[0-9\]+ 00b4 2F590006\[^\n\]*\n" { set x [expr $x+1] } | |
2205 | -re "^ +\[0-9\]+ 00b8 2F590006\[^\n\]*\n" { set x [expr $x+1] } | |
2206 | -re "^ +\[0-9\]+ 00bc 2F590006\[^\n\]*\n" { set x [expr $x+1] } | |
2207 | -re "^ +\[0-9\]+ 00c0 E840C000\[^\n\]*\n" { set x [expr $x+1] } | |
2208 | -re "^ +\[0-9\]+ 00c4 08000240\[^\n\]*\n" { set x [expr $x+1] } | |
2209 | -re "\[^\n\]*\n" { } | |
2210 | timeout { perror "timeout\n"; break } | |
2211 | eof { break } | |
2212 | } | |
2213 | } | |
2214 | ||
2215 | # This was intended to do any cleanup necessary. It kinda looks like it | |
2216 | # isn't needed, but just in case, please keep it in for now. | |
2217 | gas_finish | |
2218 | ||
2219 | # Did we find what we were looking for? If not, flunk it. | |
2220 | if [expr $x==50] then { pass $testname } else { fail $testname } | |
2221 | } | |
2222 | ||
2223 | if [istarget hppa*-*-*] then { | |
2224 | # Test the basic instruction parser. | |
2225 | do_imem | |
2226 | do_immed | |
2227 | do_branch | |
2228 | do_add | |
2229 | do_sh1add | |
2230 | do_sh2add | |
2231 | do_sh3add | |
2232 | do_sub | |
2233 | do_ds | |
2234 | do_comclr | |
2235 | do_logical | |
2236 | do_unit | |
2237 | do_dcor | |
2238 | do_addi | |
2239 | do_subi | |
2240 | do_shift | |
2241 | do_extract | |
2242 | do_deposit | |
2243 | do_system | |
2244 | do_purge | |
2245 | do_fp_misc | |
2246 | do_fmem | |
2247 | do_fp_comp | |
2248 | do_fp_conv | |
2249 | do_fp_fcmp | |
2250 | do_special | |
2251 | do_spop | |
2252 | do_copr | |
2253 | do_coprmem | |
2254 | ||
2255 | # The "weird.s" file from the gdb testsuite. Simply verify it | |
2256 | # assembles. | |
2257 | gas_test "weird.s" "" "" "stabs parsing" | |
2258 | ||
2259 | # Test that we correctly assemble some FP memory tests which | |
2260 | # L/R register selects. (Regression test for a bug Tege found). | |
2261 | do_fmem_LR_tests | |
2262 | } |