gas/testsuite/gas/h8300/t06_ari2.exp

   1 # Copyright (C) 2012-2021 Free Software Foundation, Inc.
   2
   3 # This program is free software; you can redistribute it and/or modify
   4 # it under the terms of the GNU General Public License as published by
   5 # the Free Software Foundation; either version 3 of the License, or
   6 # (at your option) any later version.
   7 #
   8 # This program is distributed in the hope that it will be useful,
   9 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 # GNU General Public License for more details.
  12 #
  13 # You should have received a copy of the GNU General Public License
  14 # along with this program; if not, write to the Free Software
  15 # Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.
  16
  17 #
  18 # Some h8300sx tests -- t06_ari2
  19 #
  20
  21 proc do_t06_ari2_test {} {
  22     set testname "t06_ari2.s -- h8sx arithmetic tests"
  23
  24     gas_start "t06_ari2.s" "-al"
  25
  26     # Check each instruction bit pattern to verify it got assembled correctly.
  27
  28     set x 0
  29     expect {
  30         -re ".*   7 0000 9112" { set x [expr $x+1]; exp_continue; }
  31         -re ".*   8 0002 7D109012" { set x [expr $x+1]; exp_continue; }
  32         -re ".*   9 0006 01766C18" { set x [expr $x+1]; exp_continue; }
  33         -re ".*   9      9012" { set x [expr $x+1]; exp_continue; }
  34         -re ".*  10              " {
  35             if [expr $x == 4] then {
  36                 pass "$testname: addx.b #0x12:8, ..."
  37             } else {
  38                 fail "$testname: addx.b #0x12:8, ... ($x)"
  39             }
  40         }
  41         default { fail "$testname: addx.b #0x12:8, ... ($x)" }
  42     }
  43
  44     set x 0
  45     expect {
  46         -re ".*  11 000c 0E31" { set x [expr $x+1]; exp_continue; }
  47         -re ".*  12 000e 7D100E30" { set x [expr $x+1]; exp_continue; }
  48         -re ".*  13 0012 01766C18" { set x [expr $x+1]; exp_continue; }
  49         -re ".*  13      0E30" { set x [expr $x+1]; exp_continue; }
  50         -re ".*  14              " {
  51             if [expr $x == 4] then {
  52                 pass "$testname: addx.b r3h, ..."
  53             } else {
  54                 fail "$testname: addx.b r3h, ... ($x)"
  55             }
  56         }
  57         default { fail "$testname: addx.b r3h, ... ($x)" }
  58     }
  59
  60     set x 0
  61     expect {
  62         -re ".*  15 0018 7C300E01" { set x [expr $x+1]; exp_continue; }
  63         -re ".*  16 001c 0174683D" { set x [expr $x+1]; exp_continue; }
  64         -re ".*  16      0110" { set x [expr $x+1]; exp_continue; }
  65         -re ".*  17              " {
  66             if [expr $x == 3] then {
  67                 pass "$testname: addx.b @er3, ..."
  68             } else {
  69                 fail "$testname: addx.b @er3, ... ($x)"
  70             }
  71         }
  72         default { fail "$testname: addx.b @er3, ... ($x)" }
  73     }
  74
  75     set x 0
  76     expect {
  77         -re ".*  18 0022 01766C30" { set x [expr $x+1]; exp_continue; }
  78         -re ".*  18      0E01" { set x [expr $x+1]; exp_continue; }
  79         -re ".*  19 0028 01766C3D" { set x [expr $x+1]; exp_continue; }
  80         -re ".*  19      A110" { set x [expr $x+1]; exp_continue; }
  81         -re ".*  20              " {
  82             if [expr $x == 4] then {
  83                 pass "$testname: addx.b @er3-, ..."
  84             } else {
  85                 fail "$testname: addx.b @er3-, ... ($x)"
  86             }
  87         }
  88         default { fail "$testname: addx.b @er3-, ... ($x)" }
  89     }
  90
  91     set x 0
  92     expect {
  93         -re ".*  21 002e 01517911" { set x [expr $x+1]; exp_continue; }
  94         -re ".*  21      1234" { set x [expr $x+1]; exp_continue; }
  95         -re ".*  22 0034 7D917910" { set x [expr $x+1]; exp_continue; }
  96         -re ".*  22      1234" { set x [expr $x+1]; exp_continue; }
  97         -re ".*  23 003a 01566D19" { set x [expr $x+1]; exp_continue; }
  98         -re ".*  23      79101234" { set x [expr $x+1]; exp_continue; }
  99         -re ".*  24              " {
 100             if [expr $x == 6] then {
 101                 pass "$testname: addx.w #0x1234:16, ..."
 102             } else {
 103                 fail "$testname: addx.w #0x1234:16, ... ($x)"
 104             }
 105         }
 106         default { fail "$testname: addx.w #0x1234:16, ... ($x)" }
 107     }
 108
 109     set x 0
 110     expect {
 111         -re ".*  25 0042 01510931" { set x [expr $x+1]; exp_continue; }
 112         -re ".*  26 0046 7D910930" { set x [expr $x+1]; exp_continue; }
 113         -re ".*  27 004a 01566D19" { set x [expr $x+1]; exp_continue; }
 114         -re ".*  27      0930" { set x [expr $x+1]; exp_continue; }
 115         -re ".*  28              " {
 116             if [expr $x == 4] then {
 117                 pass "$testname: addx.w r3, ..."
 118             } else {
 119                 fail "$testname: addx.w r3, ... ($x)"
 120             }
 121         }
 122         default { fail "$testname: addx.w r3, ... ($x)" }
 123     }
 124
 125     set x 0
 126     expect {
 127         -re ".*  29 0050 7CB10901" { set x [expr $x+1]; exp_continue; }
 128         -re ".*  30 0054 0154693D" { set x [expr $x+1]; exp_continue; }
 129         -re ".*  30      0110" { set x [expr $x+1]; exp_continue; }
 130         -re ".*  31              " {
 131             if [expr $x == 3] then {
 132                 pass "$testname: addx.w @er3, ..."
 133             } else {
 134                 fail "$testname: addx.w @er3, ... ($x)"
 135             }
 136         }
 137         default { fail "$testname: addx.w @er3, ... ($x)" }
 138     }
 139
 140     set x 0
 141     expect {
 142         -re ".*  32 005a 01566D31" { set x [expr $x+1]; exp_continue; }
 143         -re ".*  32      0901" { set x [expr $x+1]; exp_continue; }
 144         -re ".*  33 0060 01566D3D" { set x [expr $x+1]; exp_continue; }
 145         -re ".*  33      A110" { set x [expr $x+1]; exp_continue; }
 146         -re ".*  34              " {
 147             if [expr $x == 4] then {
 148                 pass "$testname: addx.w @er3-, ..."
 149             } else {
 150                 fail "$testname: addx.w @er3-, ... ($x)"
 151             }
 152         }
 153         default { fail "$testname: addx.w @er3-, ... ($x)" }
 154     }
 155
 156     set x 0
 157     expect {
 158         -re ".*  35 0066 01017A11" { set x [expr $x+1]; exp_continue; }
 159         -re ".*  35      12345678" { set x [expr $x+1]; exp_continue; }
 160         -re ".*  36 006e 01046919" { set x [expr $x+1]; exp_continue; }
 161         -re ".*  36      7A101234" { set x [expr $x+1]; exp_continue; }
 162         -re ".*  36      5678" { set x [expr $x+1]; exp_continue; }
 163         -re ".*  37 0078 01066D19" { set x [expr $x+1]; exp_continue; }
 164         -re ".*  37      7A101234" { set x [expr $x+1]; exp_continue; }
 165         -re ".*  37      5678" { set x [expr $x+1]; exp_continue; }
 166         -re ".*  38              " {
 167             if [expr $x == 8] then {
 168                 pass "$testname: addx.l #0x12345678:32, ..."
 169             } else {
 170                 fail "$testname: addx.l #0x12345678:32, ... ($x)"
 171             }
 172         }
 173         default { fail "$testname: addx.l #0x12345678:32, ... ($x)" }
 174     }
 175
 176     set x 0
 177     expect {
 178         -re ".*  39 0082 01010AB1" { set x [expr $x+1]; exp_continue; }
 179         -re ".*  40 0086 01046919" { set x [expr $x+1]; exp_continue; }
 180         -re ".*  40      0AB0" { set x [expr $x+1]; exp_continue; }
 181         -re ".*  41 008c 01066D19" { set x [expr $x+1]; exp_continue; }
 182         -re ".*  41      0AB0" { set x [expr $x+1]; exp_continue; }
 183         -re ".*  42              " {
 184             if [expr $x == 5] then {
 185                 pass "$testname: addx.l er3, ..."
 186             } else {
 187                 fail "$testname: addx.l er3, ... ($x)"
 188             }
 189         }
 190         default { fail "$testname: addx.l er3, ... ($x)" }
 191     }
 192
 193     set x 0
 194     expect {
 195         -re ".*  43 0092 01046931" { set x [expr $x+1]; exp_continue; }
 196         -re ".*  43      0A81" { set x [expr $x+1]; exp_continue; }
 197         -re ".*  44 0098 0104693D" { set x [expr $x+1]; exp_continue; }
 198         -re ".*  44      0110" { set x [expr $x+1]; exp_continue; }
 199         -re ".*  45              " {
 200             if [expr $x == 4] then {
 201                 pass "$testname: addx.l @er3, ..."
 202             } else {
 203                 fail "$testname: addx.l @er3, ... ($x)"
 204             }
 205         }
 206         default { fail "$testname: addx.l @er3, ... ($x)" }
 207     }
 208
 209     set x 0
 210     expect {
 211         -re ".*  46 009e 01066D31" { set x [expr $x+1]; exp_continue; }
 212         -re ".*  46      0A81" { set x [expr $x+1]; exp_continue; }
 213         -re ".*  47 00a4 01066D3D" { set x [expr $x+1]; exp_continue; }
 214         -re ".*  47      A110" { set x [expr $x+1]; exp_continue; }
 215         -re ".*  48              " {
 216             if [expr $x == 4] then {
 217                 pass "$testname: addx.l @er3-, ..."
 218             } else {
 219                 fail "$testname: addx.l @er3-, ... ($x)"
 220             }
 221         }
 222         default { fail "$testname: addx.l @er3-, ... ($x)" }
 223     }
 224
 225     set x 0
 226     expect {
 227         -re ".*  49 00aa B112" { set x [expr $x+1]; exp_continue; }
 228         -re ".*  50 00ac 7D10B012" { set x [expr $x+1]; exp_continue; }
 229         -re ".*  51 00b0 01766C18" { set x [expr $x+1]; exp_continue; }
 230         -re ".*  51      B012" { set x [expr $x+1]; exp_continue; }
 231         -re ".*  52              " {
 232             if [expr $x == 4] then {
 233                 pass "$testname: subx.b #0x12:8, ..."
 234             } else {
 235                 fail "$testname: subx.b #0x12:8, ... ($x)"
 236             }
 237         }
 238         default { fail "$testname: subx.b #0x12:8, ... ($x)" }
 239     }
 240
 241     set x 0
 242     expect {
 243         -re ".*  53 00b6 1E31" { set x [expr $x+1]; exp_continue; }
 244         -re ".*  54 00b8 7D101E30" { set x [expr $x+1]; exp_continue; }
 245         -re ".*  55 00bc 01766C18" { set x [expr $x+1]; exp_continue; }
 246         -re ".*  55      1E30" { set x [expr $x+1]; exp_continue; }
 247         -re ".*  56              " {
 248             if [expr $x == 4] then {
 249                 pass "$testname: subx.b r3h, ..."
 250             } else {
 251                 fail "$testname: subx.b r3h, ... ($x)"
 252             }
 253         }
 254         default { fail "$testname: subx.b r3h, ... ($x)" }
 255     }
 256
 257     set x 0
 258     expect {
 259         -re ".*  57 00c2 7C301E01" { set x [expr $x+1]; exp_continue; }
 260         -re ".*  58 00c6 0174683D" { set x [expr $x+1]; exp_continue; }
 261         -re ".*  58      0130" { set x [expr $x+1]; exp_continue; }
 262         -re ".*  59              " {
 263             if [expr $x == 3] then {
 264                 pass "$testname: subx.b @er3, ..."
 265             } else {
 266                 fail "$testname: subx.b @er3, ... ($x)"
 267             }
 268         }
 269         default { fail "$testname: subx.b @er3, ... ($x)" }
 270     }
 271
 272     set x 0
 273     expect {
 274         -re ".*  60 00cc 01766C30" { set x [expr $x+1]; exp_continue; }
 275         -re ".*  60      1E01" { set x [expr $x+1]; exp_continue; }
 276         -re ".*  61 00d2 01766C3D" { set x [expr $x+1]; exp_continue; }
 277         -re ".*  61      A130" { set x [expr $x+1]; exp_continue; }
 278         -re ".*  62              " {
 279             if [expr $x == 4] then {
 280                 pass "$testname: subx.b @er3-, ..."
 281             } else {
 282                 fail "$testname: subx.b @er3-, ... ($x)"
 283             }
 284         }
 285         default { fail "$testname: subx.b @er3-, ... ($x)" }
 286     }
 287
 288     set x 0
 289     expect {
 290         -re ".*  63 00d8 01517931" { set x [expr $x+1]; exp_continue; }
 291         -re ".*  63      1234" { set x [expr $x+1]; exp_continue; }
 292         -re ".*  64 00de 7D917930" { set x [expr $x+1]; exp_continue; }
 293         -re ".*  64      1234" { set x [expr $x+1]; exp_continue; }
 294         -re ".*  65 00e4 01566D19" { set x [expr $x+1]; exp_continue; }
 295         -re ".*  65      79301234" { set x [expr $x+1]; exp_continue; }
 296         -re ".*  66              " {
 297             if [expr $x == 6] then {
 298                 pass "$testname: subx.w #0x1234:16, ..."
 299             } else {
 300                 fail "$testname: subx.w #0x1234:16, ... ($x)"
 301             }
 302         }
 303         default { fail "$testname: subx.w #0x1234:16, ... ($x)" }
 304     }
 305
 306     set x 0
 307     expect {
 308         -re ".*  67 00ec 01511931" { set x [expr $x+1]; exp_continue; }
 309         -re ".*  68 00f0 7D911930" { set x [expr $x+1]; exp_continue; }
 310         -re ".*  69 00f4 01566D19" { set x [expr $x+1]; exp_continue; }
 311         -re ".*  69      1930" { set x [expr $x+1]; exp_continue; }
 312         -re ".*  70              " {
 313             if [expr $x == 4] then {
 314                 pass "$testname: subx.w r3, ..."
 315             } else {
 316                 fail "$testname: subx.w r3, ... ($x)"
 317             }
 318         }
 319         default { fail "$testname: subx.w r3, ... ($x)" }
 320     }
 321
 322     set x 0
 323     expect {
 324         -re ".*  71 00fa 7CB11901" { set x [expr $x+1]; exp_continue; }
 325         -re ".*  72 00fe 0154693D" { set x [expr $x+1]; exp_continue; }
 326         -re ".*  72      0130" { set x [expr $x+1]; exp_continue; }
 327         -re ".*  73              " {
 328             if [expr $x == 3] then {
 329                 pass "$testname: subx.w @er3, ..."
 330             } else {
 331                 fail "$testname: subx.w @er3, ... ($x)"
 332             }
 333         }
 334         default { fail "$testname: subx.w @er3, ... ($x)" }
 335     }
 336
 337     set x 0
 338     expect {
 339         -re ".*  74 0104 01566D31" { set x [expr $x+1]; exp_continue; }
 340         -re ".*  74      1901" { set x [expr $x+1]; exp_continue; }
 341         -re ".*  75 010a 01566D3D" { set x [expr $x+1]; exp_continue; }
 342         -re ".*  75      A130" { set x [expr $x+1]; exp_continue; }
 343         -re ".*  76              " {
 344             if [expr $x == 4] then {
 345                 pass "$testname: subx.w @er3-, ..."
 346             } else {
 347                 fail "$testname: subx.w @er3-, ... ($x)"
 348             }
 349         }
 350         default { fail "$testname: subx.w @er3-, ... ($x)" }
 351     }
 352
 353     set x 0
 354     expect {
 355         -re ".*  77 0110 01017A31" { set x [expr $x+1]; exp_continue; }
 356         -re ".*  77      12345678" { set x [expr $x+1]; exp_continue; }
 357         -re ".*  78 0118 01046919" { set x [expr $x+1]; exp_continue; }
 358         -re ".*  78      7A301234" { set x [expr $x+1]; exp_continue; }
 359         -re ".*  78      5678" { set x [expr $x+1]; exp_continue; }
 360         -re ".*  79 0122 01066D19" { set x [expr $x+1]; exp_continue; }
 361         -re ".*  79      7A301234" { set x [expr $x+1]; exp_continue; }
 362         -re ".*  79      5678" { set x [expr $x+1]; exp_continue; }
 363         -re ".*  80              " {
 364             if [expr $x == 8] then {
 365                 pass "$testname: subx.l #0x12345678:32, ..."
 366             } else {
 367                 fail "$testname: subx.l #0x12345678:32, ... ($x)"
 368             }
 369         }
 370         default { fail "$testname: subx.l #0x12345678:32, ... ($x)" }
 371     }
 372
 373     set x 0
 374     expect {
 375         -re ".*  81 012c 01011AB1" { set x [expr $x+1]; exp_continue; }
 376         -re ".*  82 0130 01046919" { set x [expr $x+1]; exp_continue; }
 377         -re ".*  82      1AB0" { set x [expr $x+1]; exp_continue; }
 378         -re ".*  83 0136 01066D19" { set x [expr $x+1]; exp_continue; }
 379         -re ".*  83      1AB0" { set x [expr $x+1]; exp_continue; }
 380         -re ".*  84              " {
 381             if [expr $x == 5] then {
 382                 pass "$testname: subx.l er3, ..."
 383             } else {
 384                 fail "$testname: subx.l er3, ... ($x)"
 385             }
 386         }
 387         default { fail "$testname: subx.l er3, ... ($x)" }
 388     }
 389
 390     set x 0
 391     expect {
 392         -re ".*  85 013c 01046931" { set x [expr $x+1]; exp_continue; }
 393         -re ".*  85      1A81" { set x [expr $x+1]; exp_continue; }
 394         -re ".*  86 0142 0104693D" { set x [expr $x+1]; exp_continue; }
 395         -re ".*  86      0130" { set x [expr $x+1]; exp_continue; }
 396         -re ".*  87              " {
 397             if [expr $x == 4] then {
 398                 pass "$testname: subx.l @er3, ..."
 399             } else {
 400                 fail "$testname: subx.l @er3, ... ($x)"
 401             }
 402         }
 403         default { fail "$testname: subx.l @er3, ... ($x)" }
 404     }
 405
 406     set x 0
 407     expect {
 408         -re ".*  88 0148 01066D31" { set x [expr $x+1]; exp_continue; }
 409         -re ".*  88      1A81" { set x [expr $x+1]; exp_continue; }
 410         -re ".*  89 014e 01066D3D" { set x [expr $x+1]; exp_continue; }
 411         -re ".*  89      A130" { set x [expr $x+1]; exp_continue; }
 412         -re ".*  90              " {
 413             if [expr $x == 4] then {
 414                 pass "$testname: subx.l @er3-, ..."
 415             } else {
 416                 fail "$testname: subx.l @er3-, ... ($x)"
 417             }
 418         }
 419         default { fail "$testname: subx.l @er3-, ... ($x)" }
 420     }
 421
 422     set x 0
 423     expect {
 424         -re ".*  91 0154 0A01" { set x [expr $x+1]; exp_continue; }
 425         -re ".*  92 0156 0B51" { set x [expr $x+1]; exp_continue; }
 426         -re ".*  93 0158 0BD1" { set x [expr $x+1]; exp_continue; }
 427         -re ".*  94 015a 0B71" { set x [expr $x+1]; exp_continue; }
 428         -re ".*  95 015c 0BF1" { set x [expr $x+1]; exp_continue; }
 429         -re ".*  96              " {
 430             if [expr $x == 5] then {
 431                 pass "$testname: inc"
 432             } else {
 433                 fail "$testname: inc ($x)"
 434             }
 435         }
 436         default { fail "$testname: inc ($x)" }
 437     }
 438
 439     set x 0
 440     expect {
 441         -re ".*  97 015e 1A01" { set x [expr $x+1]; exp_continue; }
 442         -re ".*  98 0160 1B51" { set x [expr $x+1]; exp_continue; }
 443         -re ".*  99 0162 1BD1" { set x [expr $x+1]; exp_continue; }
 444         -re ".* 100 0164 1B71" { set x [expr $x+1]; exp_continue; }
 445         -re ".* 101 0166 1BF1" { set x [expr $x+1]; exp_continue; }
 446         -re ".* 102              " {
 447             if [expr $x == 5] then {
 448                 pass "$testname: dec"
 449             } else {
 450                 fail "$testname: dec ($x)"
 451             }
 452         }
 453         default { fail "$testname: dec ($x)" }
 454     }
 455
 456     set x 0
 457     expect {
 458         -re ".* 103 0168 0B01" { set x [expr $x+1]; exp_continue; }
 459         -re ".* 104 016a 0B81" { set x [expr $x+1]; exp_continue; }
 460         -re ".* 105 016c 0B91" { set x [expr $x+1]; exp_continue; }
 461         -re ".* 106              " {
 462             if [expr $x == 3] then {
 463                 pass "$testname: adds.l ..., er1"
 464             } else {
 465                 fail "$testname: adds.l ..., er1 ($x)"
 466             }
 467         }
 468         default { fail "$testname: adds.l ..., er1 ($x)" }
 469     }
 470
 471     set x 0
 472     expect {
 473         -re ".* 107 016e 1B01" { set x [expr $x+1]; exp_continue; }
 474         -re ".* 108 0170 1B81" { set x [expr $x+1]; exp_continue; }
 475         -re ".* 109 0172 1B91" { set x [expr $x+1]; exp_continue; }
 476         -re ".* 110              " {
 477             if [expr $x == 3] then {
 478                 pass "$testname: subs.l #4,er1"
 479             } else {
 480                 fail "$testname: subs.l #4,er1 ($x)"
 481             }
 482         }
 483         default { fail "$testname: subs.l #4,er1 ($x)" }
 484     }
 485
 486     set x 0
 487     expect {
 488         -re ".* 111 0174 0F01" { set x [expr $x+1]; exp_continue; }
 489         -re ".* 112              " {
 490             if [expr $x == 1] then {
 491                 pass "$testname: daa.b r1h"
 492             } else {
 493                 fail "$testname: daa.b r1h ($x)"
 494             }
 495         }
 496         default { fail "$testname: daa.b r1h ($x)" }
 497     }
 498
 499     set x 0
 500     expect {
 501         -re ".* 113 0176 1F01" { set x [expr $x+1]; exp_continue; }
 502         -re ".* 114              " {
 503             if [expr $x == 1] then {
 504                 pass "$testname: das.b r1h"
 505             } else {
 506                 fail "$testname: das.b r1h ($x)"
 507             }
 508         }
 509         default { fail "$testname: das.b r1h ($x)" }
 510     }
 511
 512     set x 0
 513     expect {
 514         -re ".* 115 0178 01CC50F1" { set x [expr $x+1]; exp_continue; }
 515         -re ".* 116              " {
 516             if [expr $x == 1] then {
 517                 pass "$testname: mulxu.b #0xf:4,r1"
 518             } else {
 519                 fail "$testname: mulxu.b #0xf:4,r1 ($x)"
 520             }
 521         }
 522         default { fail "$testname: mulxu.b #0xf:4,r1 ($x)" }
 523     }
 524
 525     set x 0
 526     expect {
 527         -re ".* 117 017c 5031" { set x [expr $x+1]; exp_continue; }
 528         -re ".* 118              " {
 529             if [expr $x == 1] then {
 530                 pass "$testname: mulxu.b r3h,r1"
 531             } else {
 532                 fail "$testname: mulxu.b r3h,r1 ($x)"
 533             }
 534         }
 535         default { fail "$testname: mulxu.b r3h,r1 ($x)" }
 536     }
 537
 538     set x 0
 539     expect {
 540         -re ".* 119 017e 01CC52F1" { set x [expr $x+1]; exp_continue; }
 541         -re ".* 120              " {
 542             if [expr $x == 1] then {
 543                 pass "$testname: mulxu.w #0xf:4,er1"
 544             } else {
 545                 fail "$testname: mulxu.w #0xf:4,er1 ($x)"
 546             }
 547         }
 548         default { fail "$testname: mulxu.w #0xf:4,er1 ($x)" }
 549     }
 550
 551     set x 0
 552     expect {
 553         -re ".* 121 0182 5231" { set x [expr $x+1]; exp_continue; }
 554         -re ".* 122              " {
 555             if [expr $x == 1] then {
 556                 pass "$testname: mulxu.w r3,er1"
 557             } else {
 558                 fail "$testname: mulxu.w r3,er1 ($x)"
 559             }
 560         }
 561         default { fail "$testname: mulxu.w r3,er1 ($x)" }
 562     }
 563
 564     set x 0
 565     expect {
 566         -re ".* 123 0184 01DC51F1" { set x [expr $x+1]; exp_continue; }
 567         -re ".* 124              " {
 568             if [expr $x == 1] then {
 569                 pass "$testname: divxu.b #0xf:4,r1"
 570             } else {
 571                 fail "$testname: divxu.b #0xf:4,r1 ($x)"
 572             }
 573         }
 574         default { fail "$testname: divxu.b #0xf:4,r1 ($x)" }
 575     }
 576
 577     set x 0
 578     expect {
 579         -re ".* 125 0188 5131" { set x [expr $x+1]; exp_continue; }
 580         -re ".* 126              " {
 581             if [expr $x == 1] then {
 582                 pass "$testname: divxu.b r3h,r1"
 583             } else {
 584                 fail "$testname: divxu.b r3h,r1 ($x)"
 585             }
 586         }
 587         default { fail "$testname: divxu.b r3h,r1 ($x)" }
 588     }
 589
 590     set x 0
 591     expect {
 592         -re ".* 127 018a 01DC53F1" { set x [expr $x+1]; exp_continue; }
 593         -re ".* 128              " {
 594             if [expr $x == 1] then {
 595                 pass "$testname: divxu.w #0xf:4,er1"
 596             } else {
 597                 fail "$testname: divxu.w #0xf:4,er1 ($x)"
 598             }
 599         }
 600         default { fail "$testname: divxu.w #0xf:4,er1 ($x)" }
 601     }
 602
 603     set x 0
 604     expect {
 605         -re ".* 129 018e 5331" { set x [expr $x+1]; exp_continue; }
 606         -re ".* 130              " {
 607             if [expr $x == 1] then {
 608                 pass "$testname: divxu.w r3,er1"
 609             } else {
 610                 fail "$testname: divxu.w r3,er1 ($x)"
 611             }
 612         }
 613         default { fail "$testname: divxu.w r3,er1 ($x)" }
 614     }
 615
 616     set x 0
 617     expect {
 618         -re ".* 131 0190 01C450F1" { set x [expr $x+1]; exp_continue; }
 619         -re ".* 132              " {
 620             if [expr $x == 1] then {
 621                 pass "$testname: mulxs.b #0xf:4,r1"
 622             } else {
 623                 fail "$testname: mulxs.b #0xf:4,r1 ($x)"
 624             }
 625         }
 626         default { fail "$testname: mulxs.b #0xf:4,r1 ($x)" }
 627     }
 628
 629     set x 0
 630     expect {
 631         -re ".* 133 0194 01C05031" { set x [expr $x+1]; exp_continue; }
 632         -re ".* 134              " {
 633             if [expr $x == 1] then {
 634                 pass "$testname: mulxs.b r3h,r1"
 635             } else {
 636                 fail "$testname: mulxs.b r3h,r1 ($x)"
 637             }
 638         }
 639         default { fail "$testname: mulxs.b r3h,r1 ($x)" }
 640     }
 641
 642     set x 0
 643     expect {
 644         -re ".* 135 0198 01C452F1" { set x [expr $x+1]; exp_continue; }
 645         -re ".* 136              " {
 646             if [expr $x == 1] then {
 647                 pass "$testname: mulxs.w #0xf:4,er1"
 648             } else {
 649                 fail "$testname: mulxs.w #0xf:4,er1 ($x)"
 650             }
 651         }
 652         default { fail "$testname: mulxs.w #0xf:4,er1 ($x)" }
 653     }
 654
 655     set x 0
 656     expect {
 657         -re ".* 137 019c 01C05231" { set x [expr $x+1]; exp_continue; }
 658         -re ".* 138              " {
 659             if [expr $x == 1] then {
 660                 pass "$testname: mulxs.w r3,er1"
 661             } else {
 662                 fail "$testname: mulxs.w r3,er1 ($x)"
 663             }
 664         }
 665         default { fail "$testname: mulxs.w r3,er1 ($x)" }
 666     }
 667
 668     set x 0
 669     expect {
 670         -re ".* 139 01a0 01D451F1" { set x [expr $x+1]; exp_continue; }
 671         -re ".* 140              " {
 672             if [expr $x == 1] then {
 673                 pass "$testname: divxs.b #0xf:4,r1"
 674             } else {
 675                 fail "$testname: divxs.b #0xf:4,r1 ($x)"
 676             }
 677         }
 678         default { fail "$testname: divxs.b #0xf:4,r1 ($x)" }
 679     }
 680
 681     set x 0
 682     expect {
 683         -re ".* 141 01a4 01D05131" { set x [expr $x+1]; exp_continue; }
 684         -re ".* 142              " {
 685             if [expr $x == 1] then {
 686                 pass "$testname: divxs.b r3h,r1"
 687             } else {
 688                 fail "$testname: divxs.b r3h,r1 ($x)"
 689             }
 690         }
 691         default { fail "$testname: divxs.b r3h,r1 ($x)" }
 692     }
 693
 694     set x 0
 695     expect {
 696         -re ".* 143 01a8 01D453F1" { set x [expr $x+1]; exp_continue; }
 697         -re ".* 144              " {
 698             if [expr $x == 1] then {
 699                 pass "$testname: divxs.w #0xf:4,er1"
 700             } else {
 701                 fail "$testname: divxs.w #0xf:4,er1 ($x)"
 702             }
 703         }
 704         default { fail "$testname: divxs.w #0xf:4,er1 ($x)" }
 705     }
 706
 707     set x 0
 708     expect {
 709         -re ".* 145 01ac 01D05331" { set x [expr $x+1]; exp_continue; }
 710         -re ".* 146              " {
 711             if [expr $x == 1] then {
 712                 pass "$testname: divxs.w r3,er1"
 713             } else {
 714                 fail "$testname: divxs.w r3,er1 ($x)"
 715             }
 716         }
 717         default { fail "$testname: divxs.w r3,er1 ($x)" }
 718     }
 719
 720     set x 0
 721     expect {
 722         -re ".* 147 01b0 01CE50F1" { set x [expr $x+1]; exp_continue; }
 723         -re ".* 148              " {
 724             if [expr $x == 1] then {
 725                 pass "$testname: mulu.w #0xf:4,r1"
 726             } else {
 727                 fail "$testname: mulu.w #0xf:4,r1 ($x)"
 728             }
 729         }
 730         default { fail "$testname: mulu.w #0xf:4,r1 ($x)" }
 731     }
 732
 733     set x 0
 734     expect {
 735         -re ".* 149 01b4 01CA5031" { set x [expr $x+1]; exp_continue; }
 736         -re ".* 150              " {
 737             if [expr $x == 1] then {
 738                 pass "$testname: mulu.w r3,r1"
 739             } else {
 740                 fail "$testname: mulu.w r3,r1 ($x)"
 741             }
 742         }
 743         default { fail "$testname: mulu.w r3,r1 ($x)" }
 744     }
 745
 746     set x 0
 747     expect {
 748         -re ".* 151 01b8 01CE52F1" { set x [expr $x+1]; exp_continue; }
 749         -re ".* 152              " {
 750             if [expr $x == 1] then {
 751                 pass "$testname: mulu.l #0xf:4,er1"
 752             } else {
 753                 fail "$testname: mulu.l #0xf:4,er1 ($x)"
 754             }
 755         }
 756         default { fail "$testname: mulu.l #0xf:4,er1 ($x)" }
 757     }
 758
 759     set x 0
 760     expect {
 761         -re ".* 153 01bc 01CA5231" { set x [expr $x+1]; exp_continue; }
 762         -re ".* 154              " {
 763             if [expr $x == 1] then {
 764                 pass "$testname: mulu.l er3,er1"
 765             } else {
 766                 fail "$testname: mulu.l er3,er1 ($x)"
 767             }
 768         }
 769         default { fail "$testname: mulu.l er3,er1 ($x)" }
 770     }
 771
 772     set x 0
 773     expect {
 774         -re ".* 155 01c0 01CF52F1" { set x [expr $x+1]; exp_continue; }
 775         -re ".* 156              " {
 776             if [expr $x == 1] then {
 777                 pass "$testname: mulu/u.l #0xf:4,er1"
 778             } else {
 779                 fail "$testname: mulu/u.l #0xf:4,er1 ($x)"
 780             }
 781         }
 782         default { fail "$testname: mulu/u.l #0xf:4,er1 ($x)" }
 783     }
 784
 785     set x 0
 786     expect {
 787         -re ".* 157 01c4 01CB5231" { set x [expr $x+1]; exp_continue; }
 788         -re ".* 158              " {
 789             if [expr $x == 1] then {
 790                 pass "$testname: mulu/u.l er3,er1"
 791             } else {
 792                 fail "$testname: mulu/u.l er3,er1 ($x)"
 793             }
 794         }
 795         default { fail "$testname: mulu/u.l er3,er1 ($x)" }
 796     }
 797
 798     set x 0
 799     expect {
 800         -re ".* 159 01c8 01C650F1" { set x [expr $x+1]; exp_continue; }
 801         -re ".* 160              " {
 802             if [expr $x == 1] then {
 803                 pass "$testname: muls.w #0xf:4,r1"
 804             } else {
 805                 fail "$testname: muls.w #0xf:4,r1 ($x)"
 806             }
 807         }
 808         default { fail "$testname: muls.w #0xf:4,r1 ($x)" }
 809     }
 810
 811     set x 0
 812     expect {
 813         -re ".* 161 01cc 01C25031" { set x [expr $x+1]; exp_continue; }
 814         -re ".* 162              " {
 815             if [expr $x == 1] then {
 816                 pass "$testname: muls.w r3,r1"
 817             } else {
 818                 fail "$testname: muls.w r3,r1 ($x)"
 819             }
 820         }
 821         default { fail "$testname: muls.w r3,r1 ($x)" }
 822     }
 823
 824     set x 0
 825     expect {
 826         -re ".* 163 01d0 01C652F1" { set x [expr $x+1]; exp_continue; }
 827         -re ".* 164              " {
 828             if [expr $x == 1] then {
 829                 pass "$testname: muls.l #0xf:4,er1"
 830             } else {
 831                 fail "$testname: muls.l #0xf:4,er1 ($x)"
 832             }
 833         }
 834         default { fail "$testname: muls.l #0xf:4,er1 ($x)" }
 835     }
 836
 837     set x 0
 838     expect {
 839         -re ".* 165 01d4 01C25231" { set x [expr $x+1]; exp_continue; }
 840         -re ".* 166              " {
 841             if [expr $x == 1] then {
 842                 pass "$testname: muls.l er3,er1"
 843             } else {
 844                 fail "$testname: muls.l er3,er1 ($x)"
 845             }
 846         }
 847         default { fail "$testname: muls.l er3,er1 ($x)" }
 848     }
 849
 850     set x 0
 851     expect {
 852         -re ".* 167 01d8 01C752F1" { set x [expr $x+1]; exp_continue; }
 853         -re ".* 168              " {
 854             if [expr $x == 1] then {
 855                 pass "$testname: muls/u.l #0xf:4,er1"
 856             } else {
 857                 fail "$testname: muls/u.l #0xf:4,er1 ($x)"
 858             }
 859         }
 860         default { fail "$testname: muls/u.l #0xf:4,er1 ($x)" }
 861     }
 862
 863     set x 0
 864     expect {
 865         -re ".* 169 01dc 01C35231" { set x [expr $x+1]; exp_continue; }
 866         -re ".* 170              " {
 867             if [expr $x == 1] then {
 868                 pass "$testname: muls/u.l er3,er1"
 869             } else {
 870                 fail "$testname: muls/u.l er3,er1 ($x)"
 871             }
 872         }
 873         default { fail "$testname: muls/u.l er3,er1 ($x)" }
 874     }
 875
 876     set x 0
 877     expect {
 878         -re ".* 171 01e0 01DE51F1" { set x [expr $x+1]; exp_continue; }
 879         -re ".* 172              " {
 880             if [expr $x == 1] then {
 881                 pass "$testname: divu.w #0xf:4,r1"
 882             } else {
 883                 fail "$testname: divu.w #0xf:4,r1 ($x)"
 884             }
 885         }
 886         default { fail "$testname: divu.w #0xf:4,r1 ($x)" }
 887     }
 888
 889     set x 0
 890     expect {
 891         -re ".* 173 01e4 01DA5131" { set x [expr $x+1]; exp_continue; }
 892         -re ".* 174              " {
 893             if [expr $x == 1] then {
 894                 pass "$testname: divu.w r3,r1"
 895             } else {
 896                 fail "$testname: divu.w r3,r1 ($x)"
 897             }
 898         }
 899         default { fail "$testname: divu.w r3,r1 ($x)" }
 900     }
 901
 902     set x 0
 903     expect {
 904         -re ".* 175 01e8 01DE53F1" { set x [expr $x+1]; exp_continue; }
 905         -re ".* 176              " {
 906             if [expr $x == 1] then {
 907                 pass "$testname: divu.l #0xf:4,er1"
 908             } else {
 909                 fail "$testname: divu.l #0xf:4,er1 ($x)"
 910             }
 911         }
 912         default { fail "$testname: divu.l #0xf:4,er1 ($x)" }
 913     }
 914
 915     set x 0
 916     expect {
 917         -re ".* 177 01ec 01DA5331" { set x [expr $x+1]; exp_continue; }
 918         -re ".* 178              " {
 919             if [expr $x == 1] then {
 920                 pass "$testname: divu.l er3,er1"
 921             } else {
 922                 fail "$testname: divu.l er3,er1 ($x)"
 923             }
 924         }
 925         default { fail "$testname: divu.l er3,er1 ($x)" }
 926     }
 927
 928     set x 0
 929     expect {
 930         -re ".* 179 01f0 01D651F1" { set x [expr $x+1]; exp_continue; }
 931         -re ".* 180              " {
 932             if [expr $x == 1] then {
 933                 pass "$testname: divs.w #0xf:4,r1"
 934             } else {
 935                 fail "$testname: divs.w #0xf:4,r1 ($x)"
 936             }
 937         }
 938         default { fail "$testname: divs.w #0xf:4,r1 ($x)" }
 939     }
 940
 941     set x 0
 942     expect {
 943         -re ".* 181 01f4 01D25131" { set x [expr $x+1]; exp_continue; }
 944         -re ".* 182              " {
 945             if [expr $x == 1] then {
 946                 pass "$testname: divs.w r3,r1"
 947             } else {
 948                 fail "$testname: divs.w r3,r1 ($x)"
 949             }
 950         }
 951         default { fail "$testname: divs.w r3,r1 ($x)" }
 952     }
 953
 954     set x 0
 955     expect {
 956         -re ".* 183 01f8 01D653F1" { set x [expr $x+1]; exp_continue; }
 957         -re ".* 184              " {
 958             if [expr $x == 1] then {
 959                 pass "$testname: divs.l #0xf:4,er1"
 960             } else {
 961                 fail "$testname: divs.l #0xf:4,er1 ($x)"
 962             }
 963         }
 964         default { fail "$testname: divs.l #0xf:4,er1 ($x)" }
 965     }
 966
 967     set x 0
 968     expect {
 969         -re ".* 185 01fc 01D25331" { set x [expr $x+1]; exp_continue; }
 970         -re ".* 186              " {
 971             if [expr $x == 1] then {
 972                 pass "$testname: divs.l er3,er1"
 973             } else {
 974                 fail "$testname: divs.l er3,er1 ($x)"
 975             }
 976         }
 977         default { fail "$testname: divs.l er3,er1 ($x)" }
 978     }
 979
 980     # This was intended to do any cleanup necessary.
 981     # It kinda looks like it isn't needed, but just
 982     # in case, please keep it in for now.
 983
 984     gas_finish
 985
 986 }
 987
 988 if [istarget h8300*-*-elf] then {
 989     # Test advanced h8300sx instructions.
 990     do_t06_ari2_test
 991 }
 992