1# Copyright (C) 1996, 2002 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., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 16 17# Please email any bugs, comments, and/or additions to this file to: 18# dejagnu@gnu.org 19 20# Written by Cygnus Support. 21 22proc do_add {} { 23 set testname "add.s: Add operations" 24 set x 0 25 26 gas_start "add.s" "-al" 27 28 # Instead of having a variable for each match string just increment the 29 # total number of matches seen. That's simpler when testing large numbers 30 # of instructions (as these tests to). 31 while 1 { 32 expect { 33 -re "^ +\[0-9\]+ 0000 96\[^\n\]*\n" { set x [expr $x+1] } 34 -re "^ +\[0-9\]+ 0001 F20B\[^\n\]*\n" { set x [expr $x+1] } 35 -re "^ +\[0-9\]+ 0003 F2C9\[^\n\]*\n" { set x [expr $x+1] } 36 -re "^ +\[0-9\]+ 0005 F24E\[^\n\]*\n" { set x [expr $x+1] } 37 -re "^ +\[0-9\]+ 0007 D510\[^\n\]*\n" { set x [expr $x+1] } 38 -re "^ +\[0-9\]+ 0009 F71A0001\[^\n\]*\n" { set x [expr $x+1] } 39 -re "^ +\[0-9\]+ 000d F463FFFF\[^\n\]*\n" { set x [expr $x+1] } 40 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] } 41 -re "^ +\[0-9\]+ 0012 D110\[^\n\]*\n" { set x [expr $x+1] } 42 -re "^ +\[0-9\]+ 0014 F70A0001\[^\n\]*\n" { set x [expr $x+1] } 43 -re "^ +\[0-9\]+ 0018 F467FFFF\[^\n\]*\n" { set x [expr $x+1] } 44 -re "^ +11 +01\[^\n\]*\n" { set x [expr $x+1] } 45 -re "^ +\[0-9\]+ 001d F286\[^\n\]*\n" { set x [expr $x+1] } 46 -re "^ +\[0-9\]+ 001f F50E10\[^\n\]*\n" { set x [expr $x+1] } 47 -re "\[^\n\]*\n" { } 48 timeout { perror "timeout\n"; break } 49 eof { break } 50 } 51 } 52 53 # This was intended to do any cleanup necessary. It kinda looks like it 54 # isn't needed, but just in case, please keep it in for now. 55 gas_finish 56 57 # Did we find what we were looking for? If not, flunk it. 58 if [expr $x==14] then { pass $testname } else { fail $testname } 59} 60 61proc do_bcc {} { 62 set testname "bcc.s: Bcc tests" 63 set x 0 64 65 gas_start "bcc.s" "-al" 66 67 # Instead of having a variable for each match string just increment the 68 # total number of matches seen. That's simpler when testing large numbers 69 # of instructions (as these tests to). 70 while 1 { 71 expect { 72 -re "^ +\[0-9\]+ 0000 E800\[^\n\]*\n" { set x [expr $x+1] } 73 -re "^ +\[0-9\]+ 0002 E900\[^\n\]*\n" { set x [expr $x+1] } 74 -re "^ +\[0-9\]+ 0004 E100\[^\n\]*\n" { set x [expr $x+1] } 75 -re "^ +\[0-9\]+ 0006 E200\[^\n\]*\n" { set x [expr $x+1] } 76 -re "^ +\[0-9\]+ 0008 E300\[^\n\]*\n" { set x [expr $x+1] } 77 -re "^ +\[0-9\]+ 000a E000\[^\n\]*\n" { set x [expr $x+1] } 78 -re "^ +\[0-9\]+ 000c E500\[^\n\]*\n" { set x [expr $x+1] } 79 -re "^ +\[0-9\]+ 000e E600\[^\n\]*\n" { set x [expr $x+1] } 80 -re "^ +\[0-9\]+ 0010 E700\[^\n\]*\n" { set x [expr $x+1] } 81 -re "^ +\[0-9\]+ 0012 E400\[^\n\]*\n" { set x [expr $x+1] } 82 -re "^ +\[0-9\]+ 0014 F5FC00\[^\n\]*\n" { set x [expr $x+1] } 83 -re "^ +\[0-9\]+ 0017 F5FD00\[^\n\]*\n" { set x [expr $x+1] } 84 -re "^ +\[0-9\]+ 001a F5FE00\[^\n\]*\n" { set x [expr $x+1] } 85 -re "^ +\[0-9\]+ 001d F5FF00\[^\n\]*\n" { set x [expr $x+1] } 86 -re "^ +\[0-9\]+ 0020 EA00\[^\n\]*\n" { set x [expr $x+1] } 87 -re "\[^\n\]*\n" { } 88 timeout { perror "timeout\n"; break } 89 eof { break } 90 } 91 } 92 93 # This was intended to do any cleanup necessary. It kinda looks like it 94 # isn't needed, but just in case, please keep it in for now. 95 gas_finish 96 97 # Did we find what we were looking for? If not, flunk it. 98 if [expr $x==15] then { pass $testname } else { fail $testname } 99} 100 101proc do_bccx {} { 102 set testname "bccx.s: Bccx tests" 103 set x 0 104 105 gas_start "bccx.s" "-al" 106 107 # Instead of having a variable for each match string just increment the 108 # total number of matches seen. That's simpler when testing large numbers 109 # of instructions (as these tests to). 110 while 1 { 111 expect { 112 -re "^ +\[0-9\]+ 0000 F5E800\[^\n\]*\n" { set x [expr $x+1] } 113 -re "^ +\[0-9\]+ 0003 F5E900\[^\n\]*\n" { set x [expr $x+1] } 114 -re "^ +\[0-9\]+ 0006 F5E100\[^\n\]*\n" { set x [expr $x+1] } 115 -re "^ +\[0-9\]+ 0009 F5E200\[^\n\]*\n" { set x [expr $x+1] } 116 -re "^ +\[0-9\]+ 000c F5E300\[^\n\]*\n" { set x [expr $x+1] } 117 -re "^ +\[0-9\]+ 000f F5E000\[^\n\]*\n" { set x [expr $x+1] } 118 -re "^ +\[0-9\]+ 0012 F5E500\[^\n\]*\n" { set x [expr $x+1] } 119 -re "^ +\[0-9\]+ 0015 F5E600\[^\n\]*\n" { set x [expr $x+1] } 120 -re "^ +\[0-9\]+ 0018 F5E700\[^\n\]*\n" { set x [expr $x+1] } 121 -re "^ +\[0-9\]+ 001b F5E400\[^\n\]*\n" { set x [expr $x+1] } 122 -re "^ +\[0-9\]+ 001e F5EC00\[^\n\]*\n" { set x [expr $x+1] } 123 -re "^ +\[0-9\]+ 0021 F5ED00\[^\n\]*\n" { set x [expr $x+1] } 124 -re "^ +\[0-9\]+ 0024 F5EE00\[^\n\]*\n" { set x [expr $x+1] } 125 -re "^ +\[0-9\]+ 0027 F5EF00\[^\n\]*\n" { set x [expr $x+1] } 126 -re "\[^\n\]*\n" { } 127 timeout { perror "timeout\n"; break } 128 eof { break } 129 } 130 } 131 132 # This was intended to do any cleanup necessary. It kinda looks like it 133 # isn't needed, but just in case, please keep it in for now. 134 gas_finish 135 136 # Did we find what we were looking for? If not, flunk it. 137 if [expr $x==14] then { pass $testname } else { fail $testname } 138} 139 140proc do_bit {} { 141 set testname "bit.s: bit tests" 142 set x 0 143 144 gas_start "bit.s" "-al" 145 146 # Instead of having a variable for each match string just increment the 147 # total number of matches seen. That's simpler when testing large numbers 148 # of instructions (as these tests to). 149 while 1 { 150 expect { 151 -re "^ +\[0-9\]+ 0000 F50540\[^\n\]*\n" { set x [expr $x+1] } 152 -re "^ +\[0-9\]+ 0003 F7060020\[^\n\]*\n" { set x [expr $x+1] } 153 -re "^ +\[0-9\]+ 0007 F029\[^\n\]*\n" { set x [expr $x+1] } 154 -re "^ +\[0-9\]+ 0009 F039\[^\n\]*\n" { set x [expr $x+1] } 155 -re "^ +12 +FFFF40\[^\n\]*\n" { set x [expr $x+1] } 156 -re "\[^\n\]*\n" { } 157 timeout { perror "timeout\n"; break } 158 eof { break } 159 } 160 } 161 162 # This was intended to do any cleanup necessary. It kinda looks like it 163 # isn't needed, but just in case, please keep it in for now. 164 gas_finish 165 166 # Did we find what we were looking for? If not, flunk it. 167 if [expr $x==4] then { pass $testname } else { fail $testname } 168} 169 170 171proc do_cmp {} { 172 set testname "cmp.s: cmp tests" 173 set x 0 174 175 gas_start "cmp.s" "-al" 176 177 # Instead of having a variable for each match string just increment the 178 # total number of matches seen. That's simpler when testing large numbers 179 # of instructions (as these tests to). 180 while 1 { 181 expect { 182 -re "^ +\[0-9\]+ 0000 F396\[^\n\]*\n" { set x [expr $x+1] } 183 -re "^ +\[0-9\]+ 0002 F22B\[^\n\]*\n" { set x [expr $x+1] } 184 -re "^ +\[0-9\]+ 0004 F2EF\[^\n\]*\n" { set x [expr $x+1] } 185 -re "^ +\[0-9\]+ 0006 F26E\[^\n\]*\n" { set x [expr $x+1] } 186 -re "^ +\[0-9\]+ 0008 DB10\[^\n\]*\n" { set x [expr $x+1] } 187 -re "^ +\[0-9\]+ 000a F74A0001\[^\n\]*\n" { set x [expr $x+1] } 188 -re "^ +\[0-9\]+ 000e F479FFFF\[^\n\]*\n" { set x [expr $x+1] } 189 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] } 190 -re "^ +\[0-9\]+ 0013 EE0001\[^\n\]*\n" { set x [expr $x+1] } 191 -re "^ +\[0-9\]+ 0016 F47DFFFF\[^\n\]*\n" { set x [expr $x+1] } 192 -re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] } 193 -re "\[^\n\]*\n" { } 194 timeout { perror "timeout\n"; break } 195 eof { break } 196 } 197 } 198 199 # This was intended to do any cleanup necessary. It kinda looks like it 200 # isn't needed, but just in case, please keep it in for now. 201 gas_finish 202 203 # Did we find what we were looking for? If not, flunk it. 204 if [expr $x==11] then { pass $testname } else { fail $testname } 205} 206 207proc do_ext {} { 208 set testname "ext.s: ext tests" 209 set x 0 210 211 gas_start "ext.s" "-al" 212 213 # Instead of having a variable for each match string just increment the 214 # total number of matches seen. That's simpler when testing large numbers 215 # of instructions (as these tests to). 216 while 1 { 217 expect { 218 -re "^ +\[0-9\]+ 0000 F3C5\[^\n\]*\n" { set x [expr $x+1] } 219 -re "^ +\[0-9\]+ 0002 B2\[^\n\]*\n" { set x [expr $x+1] } 220 -re "^ +\[0-9\]+ 0003 B7\[^\n\]*\n" { set x [expr $x+1] } 221 -re "^ +\[0-9\]+ 0004 BA\[^\n\]*\n" { set x [expr $x+1] } 222 -re "^ +\[0-9\]+ 0005 BD\[^\n\]*\n" { set x [expr $x+1] } 223 -re "\[^\n\]*\n" { } 224 timeout { perror "timeout\n"; break } 225 eof { break } 226 } 227 } 228 229 # This was intended to do any cleanup necessary. It kinda looks like it 230 # isn't needed, but just in case, please keep it in for now. 231 gas_finish 232 233 # Did we find what we were looking for? If not, flunk it. 234 if [expr $x==5] then { pass $testname } else { fail $testname } 235} 236 237proc do_extend {} { 238 set testname "extend.s: extended instruction tests" 239 set x 0 240 241 gas_start "extend.s" "-al" 242 243 # Instead of having a variable for each match string just increment the 244 # total number of matches seen. That's simpler when testing large numbers 245 # of instructions (as these tests to). 246 while 1 { 247 expect { 248 -re "^ +\[0-9\]+ 0000 F505\[^\n\]*\n" { set x [expr $x+1] } 249 -re "^ +\[0-9\]+ 0002 F6FA\[^\n\]*\n" { set x [expr $x+1] } 250 -re "^ +\[0-9\]+ 0004 F606\[^\n\]*\n" { set x [expr $x+1] } 251 -re "^ +\[0-9\]+ 0006 F90210\[^\n\]*\n" { set x [expr $x+1] } 252 -re "^ +\[0-9\]+ 0009 FB030100\[^\n\]*\n" { set x [expr $x+1] } 253 -re "^ +\[0-9\]+ 000d FD030001\[^\n\]*\n" { set x [expr $x+1] } 254 -re "^ +7 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 255 -re "^ +\[0-9\]+ 0013 F616\[^\n\]*\n" { set x [expr $x+1] } 256 -re "^ +\[0-9\]+ 0015 F91610\[^\n\]*\n" { set x [expr $x+1] } 257 -re "^ +\[0-9\]+ 0018 FB170100\[^\n\]*\n" { set x [expr $x+1] } 258 -re "^ +\[0-9\]+ 001c FD170001\[^\n\]*\n" { set x [expr $x+1] } 259 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 260 -re "^ +\[0-9\]+ 0022 F64B\[^\n\]*\n" { set x [expr $x+1] } 261 -re "^ +\[0-9\]+ 0024 F65E\[^\n\]*\n" { set x [expr $x+1] } 262 -re "^ +\[0-9\]+ 0026 F676\[^\n\]*\n" { set x [expr $x+1] } 263 -re "\[^\n\]*\n" { } 264 timeout { perror "timeout\n"; break } 265 eof { break } 266 } 267 } 268 269 # This was intended to do any cleanup necessary. It kinda looks like it 270 # isn't needed, but just in case, please keep it in for now. 271 gas_finish 272 273 # Did we find what we were looking for? If not, flunk it. 274 if [expr $x==15] then { pass $testname } else { fail $testname } 275} 276 277proc do_logical {} { 278 set testname "logical.s: logical tests" 279 set x 0 280 281 gas_start "logical.s" "-al" 282 283 # Instead of having a variable for each match string just increment the 284 # total number of matches seen. That's simpler when testing large numbers 285 # of instructions (as these tests to). 286 while 1 { 287 expect { 288 -re "^ +\[0-9\]+ 0000 F306\[^\n\]*\n" { set x [expr $x+1] } 289 -re "^ +\[0-9\]+ 0002 F5027F\[^\n\]*\n" { set x [expr $x+1] } 290 -re "^ +\[0-9\]+ 0005 F703FF7F\[^\n\]*\n" { set x [expr $x+1] } 291 -re "^ +\[0-9\]+ 0009 F710FF7F\[^\n\]*\n" { set x [expr $x+1] } 292 -re "^ +\[0-9\]+ 000d F316\[^\n\]*\n" { set x [expr $x+1] } 293 -re "^ +\[0-9\]+ 000f F50A7F\[^\n\]*\n" { set x [expr $x+1] } 294 -re "^ +\[0-9\]+ 0012 F743FF7F\[^\n\]*\n" { set x [expr $x+1] } 295 -re "^ +\[0-9\]+ 0016 F714FF7F\[^\n\]*\n" { set x [expr $x+1] } 296 -re "^ +\[0-9\]+ 001a F326\[^\n\]*\n" { set x [expr $x+1] } 297 -re "^ +\[0-9\]+ 001c F74FFF7F\[^\n\]*\n" { set x [expr $x+1] } 298 -re "^ +\[0-9\]+ 0020 F3E7\[^\n\]*\n" { set x [expr $x+1] } 299 -re "^\[^\n\]*\n" { } 300 timeout { perror "timeout\n"; break } 301 eof { break } 302 } 303 } 304 305 # This was intended to do any cleanup necessary. It kinda looks like it 306 # isn't needed, but just in case, please keep it in for now. 307 gas_finish 308 309 # Did we find what we were looking for? If not, flunk it. 310 if [expr $x==11] then { pass $testname } else { fail $testname } 311} 312 313proc do_loop {} { 314 set testname "loop.s: loop tests" 315 set x 0 316 317 gas_start "loop.s" "-al" 318 319 # Instead of having a variable for each match string just increment the 320 # total number of matches seen. That's simpler when testing large numbers 321 # of instructions (as these tests to). 322 while 1 { 323 expect { 324 -re "^ +\[0-9\]+ 0000 D8\[^\n\]*\n" { set x [expr $x+1] } 325 -re "^ +\[0-9\]+ 0001 D9\[^\n\]*\n" { set x [expr $x+1] } 326 -re "^ +\[0-9\]+ 0002 D1\[^\n\]*\n" { set x [expr $x+1] } 327 -re "^ +\[0-9\]+ 0003 D2\[^\n\]*\n" { set x [expr $x+1] } 328 -re "^ +\[0-9\]+ 0004 D3\[^\n\]*\n" { set x [expr $x+1] } 329 -re "^ +\[0-9\]+ 0005 D0\[^\n\]*\n" { set x [expr $x+1] } 330 -re "^ +\[0-9\]+ 0006 D5\[^\n\]*\n" { set x [expr $x+1] } 331 -re "^ +\[0-9\]+ 0007 D6\[^\n\]*\n" { set x [expr $x+1] } 332 -re "^ +\[0-9\]+ 0008 D7\[^\n\]*\n" { set x [expr $x+1] } 333 -re "^ +\[0-9\]+ 0009 D4\[^\n\]*\n" { set x [expr $x+1] } 334 -re "^ +\[0-9\]+ 000a DA\[^\n\]*\n" { set x [expr $x+1] } 335 -re "^ +\[0-9\]+ 000b DB\[^\n\]*\n" { set x [expr $x+1] } 336 -re "\[^\n\]*\n" { } 337 timeout { perror "timeout\n"; break } 338 eof { break } 339 } 340 } 341 342 # This was intended to do any cleanup necessary. It kinda looks like it 343 # isn't needed, but just in case, please keep it in for now. 344 gas_finish 345 346 # Did we find what we were looking for? If not, flunk it. 347 if [expr $x==12] then { pass $testname } else { fail $testname } 348} 349 350proc do_mov1 {} { 351 set testname "mov1.s: mov1 tests" 352 set x 0 353 354 gas_start "mov1.s" "-al" 355 356 # Instead of having a variable for each match string just increment the 357 # total number of matches seen. That's simpler when testing large numbers 358 # of instructions (as these tests to). 359 while 1 { 360 expect { 361 -re "^ +\[0-9\]+ 0000 F236\[^\n\]*\n" { set x [expr $x+1] } 362 -re "^ +\[0-9\]+ 0002 F2F9\[^\n\]*\n" { set x [expr $x+1] } 363 -re "^ +\[0-9\]+ 0004 86\[^\n\]*\n" { set x [expr $x+1] } 364 -re "^ +\[0-9\]+ 0005 F279\[^\n\]*\n" { set x [expr $x+1] } 365 -re "^ +\[0-9\]+ 0007 F3F3\[^\n\]*\n" { set x [expr $x+1] } 366 -re "^ +\[0-9\]+ 0009 F3D8\[^\n\]*\n" { set x [expr $x+1] } 367 -re "^ +\[0-9\]+ 000b F3E1\[^\n\]*\n" { set x [expr $x+1] } 368 -re "^ +\[0-9\]+ 000d F3C8\[^\n\]*\n" { set x [expr $x+1] } 369 -re "^ +\[0-9\]+ 000f 29\[^\n\]*\n" { set x [expr $x+1] } 370 -re "^ +\[0-9\]+ 0010 6908\[^\n\]*\n" { set x [expr $x+1] } 371 -re "^ +\[0-9\]+ 0012 F7C90001\[^\n\]*\n" { set x [expr $x+1] } 372 -re "^ +\[0-9\]+ 0016 F489FFFF\[^\n\]*\n" { set x [expr $x+1] } 373 -re "^ +13 +01\[^\n\]*\n" { set x [expr $x+1] } 374 -re "\[^\n\]*\n" { } 375 timeout { perror "timeout\n"; break } 376 eof { break } 377 } 378 } 379 380 # This was intended to do any cleanup necessary. It kinda looks like it 381 # isn't needed, but just in case, please keep it in for now. 382 gas_finish 383 384 # Did we find what we were looking for? If not, flunk it. 385 if [expr $x==13] then { pass $testname } else { fail $testname } 386} 387 388proc do_mov2 {} { 389 set testname "mov2.s: mov2 tests" 390 set x 0 391 392 gas_start "mov2.s" "-al" 393 394 # Instead of having a variable for each match string just increment the 395 # total number of matches seen. That's simpler when testing large numbers 396 # of instructions (as these tests to). 397 while 1 { 398 expect { 399 -re "^ +\[0-9\]+ 0000 F156\[^\n\]*\n" { set x [expr $x+1] } 400 -re "^ +\[0-9\]+ 0002 C90080\[^\n\]*\n" { set x [expr $x+1] } 401 -re "^ +\[0-9\]+ 0005 F4C1FFFF\[^\n\]*\n" { set x [expr $x+1] } 402 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] } 403 -re "^ +\[0-9\]+ 000a 7908\[^\n\]*\n" { set x [expr $x+1] } 404 -re "^ +\[0-9\]+ 000c F7B90001\[^\n\]*\n" { set x [expr $x+1] } 405 -re "^ +\[0-9\]+ 0010 F4F9FFFF \[^\n\]*\n" { set x [expr $x+1] } 406 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] } 407 -re "^ +\[0-9\]+ 0015 F116\[^\n\]*\n" { set x [expr $x+1] } 408 -re "^ +\[0-9\]+ 0017 F7310080\[^\n\]*\n" { set x [expr $x+1] } 409 -re "^ +\[0-9\]+ 001b F4D1FFFF\[^\n\]*\n" { set x [expr $x+1] } 410 -re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] } 411 -re "\[^\n\]*\n" { } 412 timeout { perror "timeout\n"; break } 413 eof { break } 414 } 415 } 416 417 # This was intended to do any cleanup necessary. It kinda looks like it 418 # isn't needed, but just in case, please keep it in for now. 419 gas_finish 420 421 # Did we find what we were looking for? If not, flunk it. 422 if [expr $x==12] then { pass $testname } else { fail $testname } 423} 424 425proc do_mov3 {} { 426 set testname "mov3.s: mov3 tests" 427 set x 0 428 429 gas_start "mov3.s" "-al" 430 431 # Instead of having a variable for each match string just increment the 432 # total number of matches seen. That's simpler when testing large numbers 433 # of instructions (as these tests to). 434 while 1 { 435 expect { 436 -re "^ +\[0-9\]+ 0000 09\[^\n\]*\n" { set x [expr $x+1] } 437 -re "^ +\[0-9\]+ 0001 4920\[^\n\]*\n" { set x [expr $x+1] } 438 -re "^ +\[0-9\]+ 0003 F7890001\[^\n\]*\n" { set x [expr $x+1] } 439 -re "^ +\[0-9\]+ 0007 F409FFFF\[^\n\]*\n" { set x [expr $x+1] } 440 -re "^ +5 +01\[^\n\]*\n" { set x [expr $x+1] } 441 -re "^ +\[0-9\]+ 000c F1E9\[^\n\]*\n" { set x [expr $x+1] } 442 -re "^ +\[0-9\]+ 000e C18000\[^\n\]*\n" { set x [expr $x+1] } 443 -re "^ +\[0-9\]+ 0011 F441FFFF\[^\n\]*\n" { set x [expr $x+1] } 444 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] } 445 -re "^ +\[0-9\]+ 0016 5920\[^\n\]*\n" { set x [expr $x+1] } 446 -re "^ +\[0-9\]+ 0018 F7A90001\[^\n\]*\n" { set x [expr $x+1] } 447 -re "^ +\[0-9\]+ 001c F419FFFF\[^\n\]*\n" { set x [expr $x+1] } 448 -re "^ +11 +01\[^\n\]*\n" { set x [expr $x+1] } 449 -re "\[^\n\]*\n" { } 450 timeout { perror "timeout\n"; break } 451 eof { break } 452 } 453 } 454 455 # This was intended to do any cleanup necessary. It kinda looks like it 456 # isn't needed, but just in case, please keep it in for now. 457 gas_finish 458 459 # Did we find what we were looking for? If not, flunk it. 460 if [expr $x==13] then { pass $testname } else { fail $testname } 461} 462 463proc do_mov4 {} { 464 set testname "mov4.s: mov4 tests" 465 set x 0 466 467 gas_start "mov4.s" "-al" 468 469 # Instead of having a variable for each match string just increment the 470 # total number of matches seen. That's simpler when testing large numbers 471 # of instructions (as these tests to). 472 while 1 { 473 expect { 474 -re "^ +\[0-9\]+ 0000 F1A9\[^\n\]*\n" { set x [expr $x+1] } 475 -re "^ +\[0-9\]+ 0002 F7218000\[^\n\]*\n" { set x [expr $x+1] } 476 -re "^ +\[0-9\]+ 0006 F451FFFF\[^\n\]*\n" { set x [expr $x+1] } 477 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] } 478 -re "^ +\[0-9\]+ 000b 8508\[^\n\]*\n" { set x [expr $x+1] } 479 -re "^ +\[0-9\]+ 000d F90001\[^\n\]*\n" { set x [expr $x+1] } 480 -re "^ +\[0-9\]+ 0010 F471FFFF\[^\n\]*\n" { set x [expr $x+1] } 481 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] } 482 -re "^ +\[0-9\]+ 0015 DD0001\[^\n\]*\n" { set x [expr $x+1] } 483 -re "^ +\[0-9\]+ 0018 F475FFFF\[^\n\]*\n" { set x [expr $x+1] } 484 -re "^ +9 +01\[^\n\]*\n" { set x [expr $x+1] } 485 -re "\[^\n\]*\n" { } 486 timeout { perror "timeout\n"; break } 487 eof { break } 488 } 489 } 490 491 # This was intended to do any cleanup necessary. It kinda looks like it 492 # isn't needed, but just in case, please keep it in for now. 493 gas_finish 494 495 # Did we find what we were looking for? If not, flunk it. 496 if [expr $x==11] then { pass $testname } else { fail $testname } 497} 498 499proc do_movx {} { 500 set testname "movx.s: movx tests" 501 set x 0 502 503 gas_start "movx.s" "-al" 504 505 # Instead of having a variable for each match string just increment the 506 # total number of matches seen. That's simpler when testing large numbers 507 # of instructions (as these tests to). 508 while 1 { 509 expect { 510 -re "^ +\[0-9\]+ 0000 F57908\[^\n\]*\n" { set x [expr $x+1] } 511 -re "^ +\[0-9\]+ 0003 F7790001\[^\n\]*\n" { set x [expr $x+1] } 512 -re "^ +\[0-9\]+ 0007 F4B9FFFF\[^\n\]*\n" { set x [expr $x+1] } 513 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] } 514 -re "^ +\[0-9\]+ 000c F55908\[^\n\]*\n" { set x [expr $x+1] } 515 -re "^ +\[0-9\]+ 000f F7690001\[^\n\]*\n" { set x [expr $x+1] } 516 -re "^ +\[0-9\]+ 0013 F439FFFF\[^\n\]*\n" { set x [expr $x+1] } 517 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] } 518 -re "\[^\n\]*\n" { } 519 timeout { perror "timeout\n"; break } 520 eof { break } 521 } 522 } 523 524 # This was intended to do any cleanup necessary. It kinda looks like it 525 # isn't needed, but just in case, please keep it in for now. 526 gas_finish 527 528 # Did we find what we were looking for? If not, flunk it. 529 if [expr $x==8] then { pass $testname } else { fail $testname } 530} 531 532proc do_movb {} { 533 set testname "movb.s: movb tests" 534 set x 0 535 536 gas_start "movb.s" "-al" 537 538 # Instead of having a variable for each match string just increment the 539 # total number of matches seen. That's simpler when testing large numbers 540 # of instructions (as these tests to). 541 while 1 { 542 expect { 543 -re "^ +\[0-9\]+ 0000 F52908\[^\n\]*\n" { set x [expr $x+1] } 544 -re "^ +\[0-9\]+ 0003 F7D90001\[^\n\]*\n" { set x [expr $x+1] } 545 -re "^ +\[0-9\]+ 0007 F4A9FFFF\[^\n\]*\n" { set x [expr $x+1] } 546 -re "^ +4 +01\[^\n\]*\n" { set x [expr $x+1] } 547 -re "^ +\[0-9\]+ 000c F06B\[^\n\]*\n" { set x [expr $x+1] } 548 -re "^ +\[0-9\]+ 000e F4C6FFFF\[^\n\]*\n" { set x [expr $x+1] } 549 -re "^ +6 +01\[^\n\]*\n" { set x [expr $x+1] } 550 -re "^ +\[0-9\]+ 0013 19\[^\n\]*\n" { set x [expr $x+1] } 551 -re "^ +\[0-9\]+ 0014 F51908\[^\n\]*\n" { set x [expr $x+1] } 552 -re "^ +\[0-9\]+ 0017 F7990001\[^\n\]*\n" { set x [expr $x+1] } 553 -re "^ +\[0-9\]+ 001b F429FFFF\[^\n\]*\n" { set x [expr $x+1] } 554 -re "^ +10 +01\[^\n\]*\n" { set x [expr $x+1] } 555 -re "^ +\[0-9\]+ 0020 F0E9\[^\n\]*\n" { set x [expr $x+1] } 556 -re "^ +\[0-9\]+ 0022 C50001\[^\n\]*\n" { set x [expr $x+1] } 557 -re "^ +\[0-9\]+ 0025 F445FFFF\[^\n\]*\n" { set x [expr $x+1] } 558 -re "^ +13 +01\[^\n\]*\n" { set x [expr $x+1] } 559 -re "\[^\n\]*\n" { } 560 timeout { perror "timeout\n"; break } 561 eof { break } 562 } 563 } 564 565 # This was intended to do any cleanup necessary. It kinda looks like it 566 # isn't needed, but just in case, please keep it in for now. 567 gas_finish 568 569 # Did we find what we were looking for? If not, flunk it. 570 if [expr $x==16] then { pass $testname } else { fail $testname } 571} 572 573proc do_movbu {} { 574 set testname "movbu.s: movbu tests" 575 set x 0 576 577 gas_start "movbu.s" "-al" 578 579 # Instead of having a variable for each match string just increment the 580 # total number of matches seen. That's simpler when testing large numbers 581 # of instructions (as these tests to). 582 while 1 { 583 expect { 584 -re "^ +\[0-9\]+ 0000 39\[^\n\]*\n" { set x [expr $x+1] } 585 -re "^ +\[0-9\]+ 0001 F53908\[^\n\]*\n" { set x [expr $x+1] } 586 -re "^ +\[0-9\]+ 0004 F7590001\[^\n\]*\n" { set x [expr $x+1] } 587 -re "^ +\[0-9\]+ 0008 F499FFFF\[^\n\]*\n" { set x [expr $x+1] } 588 -re "^ +5 +01\[^\n\]*\n" { set x [expr $x+1] } 589 -re "^ +\[0-9\]+ 000d F096\[^\n\]*\n" { set x [expr $x+1] } 590 -re "^ +\[0-9\]+ 000f CD0080\[^\n\]*\n" { set x [expr $x+1] } 591 -re "^ +\[0-9\]+ 0012 F4C9FFFF\[^\n\]*\n" { set x [expr $x+1] } 592 -re "^ +8 +01\[^\n\]*\n" { set x [expr $x+1] } 593 -re "\[^\n\]*\n" { } 594 timeout { perror "timeout\n"; break } 595 eof { break } 596 } 597 } 598 599 # This was intended to do any cleanup necessary. It kinda looks like it 600 # isn't needed, but just in case, please keep it in for now. 601 gas_finish 602 603 # Did we find what we were looking for? If not, flunk it. 604 if [expr $x==9] then { pass $testname } else { fail $testname } 605} 606 607proc do_movhu {} { 608 set testname "movhu.s: movhu tests" 609 set x 0 610 611 gas_start "movhu.s" "-al" 612 613 # Instead of having a variable for each match string just increment the 614 # total number of matches seen. That's simpler when testing large numbers 615 # of instructions (as these tests to). 616 while 1 { 617 expect { 618 -re "^ +\[0-9\]+ 0000 F066\[^\n\]*\n" { set x [expr $x+1] } 619 -re "^ +\[0-9\]+ 0002 F86608\[^\n\]*\n" { set x [expr $x+1] } 620 -re "^ +\[0-9\]+ 0005 FA660100\[^\n\]*\n" { set x [expr $x+1] } 621 -re "^ +\[0-9\]+ 0009 FC660001\[^\n\]*\n" { set x [expr $x+1] } 622 -re "^ +5 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 623 -re "^ +\[0-9\]+ 000f F8BD08\[^\n\]*\n" { set x [expr $x+1] } 624 -re "^ +\[0-9\]+ 0012 FABD0100\[^\n\]*\n" { set x [expr $x+1] } 625 -re "^ +\[0-9\]+ 0016 FCBD0001\[^\n\]*\n" { set x [expr $x+1] } 626 -re "^ +8 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 627 -re "^ +\[0-9\]+ 001c F4A5\[^\n\]*\n" { set x [expr $x+1] } 628 -re "^ +\[0-9\]+ 001e 398000\[^\n\]*\n" { set x [expr $x+1] } 629 -re "^ +\[0-9\]+ 0021 FCAD0001\[^\n\]*\n" { set x [expr $x+1] } 630 -re "^ +11 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 631 -re "^ +\[0-9\]+ 0027 F076\[^\n\]*\n" { set x [expr $x+1] } 632 -re "^ +\[0-9\]+ 0029 F87620\[^\n\]*\n" { set x [expr $x+1] } 633 -re "^ +\[0-9\]+ 002c FA760100\[^\n\]*\n" { set x [expr $x+1] } 634 -re "^ +\[0-9\]+ 0030 FC760001\[^\n\]*\n" { set x [expr $x+1] } 635 -re "^ +15 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 636 -re "^ +\[0-9\]+ 0036 F89720\[^\n\]*\n" { set x [expr $x+1] } 637 -re "^ +\[0-9\]+ 0039 FA978000\[^\n\]*\n" { set x [expr $x+1] } 638 -re "^ +\[0-9\]+ 003d FC970001\[^\n\]*\n" { set x [expr $x+1] } 639 -re "^ +18 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 640 -re "^ +\[0-9\]+ 0043 F4DA\[^\n\]*\n" { set x [expr $x+1] } 641 -re "^ +\[0-9\]+ 0045 070080\[^\n\]*\n" { set x [expr $x+1] } 642 -re "^ +\[0-9\]+ 0048 FC870001\[^\n\]*\n" { set x [expr $x+1] } 643 -re "^ +21 +FFFF\[^\n\]*\n" { set x [expr $x+1] } 644 -re "\[^\n\]*\n" { } 645 timeout { perror "timeout\n"; break } 646 eof { break } 647 } 648 } 649 650 # This was intended to do any cleanup necessary. It kinda looks like it 651 # isn't needed, but just in case, please keep it in for now. 652 gas_finish 653 654 # Did we find what we were looking for? If not, flunk it. 655 if [expr $x==26] then { pass $testname } else { fail $testname } 656} 657 658proc do_movm {} { 659 set testname "movm.s: movm tests" 660 set x 0 661 662 gas_start "movm.s" "-al" 663 664 # Instead of having a variable for each match string just increment the 665 # total number of matches seen. That's simpler when testing large numbers 666 # of instructions (as these tests to). 667 while 1 { 668 expect { 669 -re "^ +\[0-9\]+ 0000 CE30\[^\n\]*\n" { set x [expr $x+1] } 670 -re "^ +\[0-9\]+ 0002 CEF8\[^\n\]*\n" { set x [expr $x+1] } 671 -re "^ +\[0-9\]+ 0004 CF30\[^\n\]*\n" { set x [expr $x+1] } 672 -re "^ +\[0-9\]+ 0006 CFF8\[^\n\]*\n" { set x [expr $x+1] } 673 -re "\[^\n\]*\n" { } 674 timeout { perror "timeout\n"; break } 675 eof { break } 676 } 677 } 678 679 # This was intended to do any cleanup necessary. It kinda looks like it 680 # isn't needed, but just in case, please keep it in for now. 681 gas_finish 682 683 # Did we find what we were looking for? If not, flunk it. 684 if [expr $x==4] then { pass $testname } else { fail $testname } 685} 686 687proc do_muldiv {} { 688 set testname "muldiv.s: muldiv tests" 689 set x 0 690 691 gas_start "muldiv.s" "-al" 692 693 # Instead of having a variable for each match string just increment the 694 # total number of matches seen. That's simpler when testing large numbers 695 # of instructions (as these tests to). 696 while 1 { 697 expect { 698 -re "^ +\[0-9\]+ 0000 F346\[^\n\]*\n" { set x [expr $x+1] } 699 -re "^ +\[0-9\]+ 0002 F35B\[^\n\]*\n" { set x [expr $x+1] } 700 -re "^ +\[0-9\]+ 0004 F36E\[^\n\]*\n" { set x [expr $x+1] } 701 -re "\[^\n\]*\n" { } 702 timeout { perror "timeout\n"; break } 703 eof { break } 704 } 705 } 706 707 # This was intended to do any cleanup necessary. It kinda looks like it 708 # isn't needed, but just in case, please keep it in for now. 709 gas_finish 710 711 # Did we find what we were looking for? If not, flunk it. 712 if [expr $x==3] then { pass $testname } else { fail $testname } 713} 714 715proc do_other {} { 716 set testname "other.s: other tests" 717 set x 0 718 719 gas_start "other.s" "-al" 720 721 # Instead of having a variable for each match string just increment the 722 # total number of matches seen. That's simpler when testing large numbers 723 # of instructions (as these tests to). 724 while 1 { 725 expect { 726 -re "^ +\[0-9\]+ 0000 FC0001\[^\n\]*\n" { set x [expr $x+1] } 727 -re "^ +\[0-9\]+ 0003 F4E0FFFF\[^\n\]*\n" { set x [expr $x+1] } 728 -re "^ +3 +01\[^\n\]*\n" { set x [expr $x+1] } 729 -re "^ +\[0-9\]+ 0008 F008\[^\n\]*\n" { set x [expr $x+1] } 730 -re "^ +\[0-9\]+ 000a FD0001\[^\n\]*\n" { set x [expr $x+1] } 731 -re "^ +\[0-9\]+ 000d F4E1FFFF\[^\n\]*\n" { set x [expr $x+1] } 732 -re "^ +6 +01\[^\n\]*\n" { set x [expr $x+1] } 733 -re "^ +\[0-9\]+ 0012 F009\[^\n\]*\n" { set x [expr $x+1] } 734 -re "^ +\[0-9\]+ 0014 FE\[^\n\]*\n" { set x [expr $x+1] } 735 -re "^ +\[0-9\]+ 0015 EB\[^\n\]*\n" { set x [expr $x+1] } 736 -re "^ +\[0-9\]+ 0016 F6\[^\n\]*\n" { set x [expr $x+1] } 737 -re "\[^\n\]*\n" { } 738 timeout { perror "timeout\n"; break } 739 eof { break } 740 } 741 } 742 743 # This was intended to do any cleanup necessary. It kinda looks like it 744 # isn't needed, but just in case, please keep it in for now. 745 gas_finish 746 747 # Did we find what we were looking for? If not, flunk it. 748 if [expr $x==11] then { pass $testname } else { fail $testname } 749} 750 751proc do_shift {} { 752 set testname "shift.s: shift tests" 753 set x 0 754 755 gas_start "shift.s" "-al" 756 757 # Instead of having a variable for each match string just increment the 758 # total number of matches seen. That's simpler when testing large numbers 759 # of instructions (as these tests to). 760 while 1 { 761 expect { 762 -re "^ +\[0-9\]+ 0000 F33A\[^\n\]*\n" { set x [expr $x+1] } 763 -re "^ +\[0-9\]+ 0002 F33F\[^\n\]*\n" { set x [expr $x+1] } 764 -re "^ +\[0-9\]+ 0004 F335\[^\n\]*\n" { set x [expr $x+1] } 765 -re "^ +\[0-9\]+ 0006 F332\[^\n\]*\n" { set x [expr $x+1] } 766 -re "\[^\n\]*\n" { } 767 timeout { perror "timeout\n"; break } 768 eof { break } 769 } 770 } 771 772 # This was intended to do any cleanup necessary. It kinda looks like it 773 # isn't needed, but just in case, please keep it in for now. 774 gas_finish 775 776 # Did we find what we were looking for? If not, flunk it. 777 if [expr $x==4] then { pass $testname } else { fail $testname } 778} 779 780proc do_sub {} { 781 set testname "sub.s: sub tests" 782 set x 0 783 784 gas_start "sub.s" "-al" 785 786 # Instead of having a variable for each match string just increment the 787 # total number of matches seen. That's simpler when testing large numbers 788 # of instructions (as these tests to). 789 while 1 { 790 expect { 791 -re "^ +\[0-9\]+ 0000 A6\[^\n\]*\n" { set x [expr $x+1] } 792 -re "^ +\[0-9\]+ 0001 F21B\[^\n\]*\n" { set x [expr $x+1] } 793 -re "^ +\[0-9\]+ 0003 F2DF\[^\n\]*\n" { set x [expr $x+1] } 794 -re "^ +\[0-9\]+ 0005 F25E\[^\n\]*\n" { set x [expr $x+1] } 795 -re "^ +\[0-9\]+ 0007 F71EFF7F \[^\n\]*\n" { set x [expr $x+1] } 796 -re "^ +\[0-9\]+ 000b F46AFFFF\[^\n\]*\n" { set x [expr $x+1] } 797 -re "^ +7 +01\[^\n\]*\n" { set x [expr $x+1] } 798 -re "^ +\[0-9\]+ 0010 F70EFF7F \[^\n\]*\n" { set x [expr $x+1] } 799 -re "^ +\[0-9\]+ 0014 F46EFFFF\[^\n\]*\n" { set x [expr $x+1] } 800 -re "^ +9 +01\[^\n\]*\n" { set x [expr $x+1] } 801 -re "^ +\[0-9\]+ 0019 F296 \[^\n\]*\n" { set x [expr $x+1] } 802 -re "\[^\n\]*\n" { } 803 timeout { perror "timeout\n"; break } 804 eof { break } 805 } 806 } 807 808 # This was intended to do any cleanup necessary. It kinda looks like it 809 # isn't needed, but just in case, please keep it in for now. 810 gas_finish 811 812 # Did we find what we were looking for? If not, flunk it. 813 if [expr $x==11] then { pass $testname } else { fail $testname } 814} 815 816if [istarget mn10200*-*-*] then { 817 # Test the basic instruction parser. 818 do_add 819 do_bcc 820 do_bccx 821 do_bit 822 do_cmp 823 do_ext 824 do_logical 825 do_mov1 826 do_mov2 827 do_mov3 828 do_mov4 829 do_movb 830 do_movx 831 do_movbu 832 do_muldiv 833 do_other 834 do_shift 835 do_sub 836} 837