mach/vax4/cg/table

   1 "$Id: table,v 1.33 1994/06/24 13:41:51 ceriel Exp $"
   2 #define LOCLABS         /* define if target assembler recognizes local labels */
   3 #define REGVARS         /* define for register variables */
   4 #define DORCK           /* define if you want RCK */
   5 #define FLOAT4          /* define if you want better 4-byte FP arithmetic */
   6 #define FLOAT8          /* define if you want better 8-byte FP arithmetic */
   7 /* #define ASBUG_AVOID  /* define if you want to avoid a bug in the BSD 4.1 VAX
   8                            assembler, that sometimes generates "*1" for
   9                            (r1). This is avoided by generating 0(r1), which is
  10                            optimized by the assembler to (r1).
  11                         */
  12 #ifdef ASBUG_AVOID
  13 #define REGDEFFORMAT "0(%[reg])"
  14 #else
  15 #define REGDEFFORMAT "(%[reg])"
  16 #endif
  17
  18 #define NC nocoercions :
  19 #define BSIZE 4
  20
  21 EM_PSIZE = 4
  22 EM_WSIZE = 4
  23 EM_BSIZE = BSIZE
  24
  25 /****************************************************************
  26  * VAX 11 Back end table.                                       *
  27  * Author : Ceriel J.H. Jacobs, Duk Bekema                      *
  28  *                                                              *
  29  * Wordsize = 4 bytes                                           *
  30  * Pointersize = 4 bytes                                        *
  31  *                                                              *
  32  * There is hardly any instruction timing information available *
  33  * for the DEC-VAX machines. Timing of addressing modes was done*
  34  * by counting the memory references and multiplying them by    *
  35  * 3.   300 nanosec seems to be a typical memory reference time.*
  36  * However, the VAX can be much faster, if the "cache hit rate" *
  37  * is high.                                                     *
  38  * Assumed hardware : VAX-11/7?0 with Floating Point Acc.       *
  39  ****************************************************************/
  40
  41 REGISTERS:
  42 AP      = ("ap",4),ArgumentPointer.
  43 LB      = ("fp",4),LocaLBase.
  44 R0      = ("r0",4),REG.
  45 R1      = ("r1",4),REG.
  46 R2      = ("r2",4),REG.
  47 R3      = ("r3",4),REG.
  48 #ifdef REGVARS
  49 R4      = ("r4",4) regvar,RREG.
  50 R5      = ("r5",4) regvar,RREG.
  51 R6      = ("r6",4) regvar,RREG.
  52 R7      = ("r7",4) regvar,RREG.
  53 R8      = ("r8",4) regvar,RREG.
  54 R9      = ("r9",4) regvar,RREG.
  55 RA      = ("r10",4) regvar,RREG.
  56 RB      = ("r11",4) regvar,RREG.
  57 #else /* REGVARS */
  58 R4      = ("r4",4),REG.
  59 R5      = ("r5",4),REG.
  60 R6      = ("r6",4),REG.
  61 R7      = ("r7",4),REG.
  62 R8      = ("r8",4),REG.
  63 R9      = ("r9",4),REG.
  64 RA      = ("r10",4),REG.
  65 RB      = ("r11",4),REG.
  66 #endif /* REGVARS */
  67 QR0     = ("r0",8,R0,R1),QREG.
  68 QR2     = ("r2",8,R2,R3),QREG.
  69 #ifndef REGVARS
  70 QR4     = ("r4",8,R4,R5),QREG.
  71 QR6     = ("r6",8,R6,R7),QREG.
  72 QR8     = ("r8",8,R8,R9),QREG.
  73 QRA     = ("r10",8,RA,RB),QREG.
  74 #endif /* REGVARS */
  75 QR1     = ("r1",8,R1,R2),QREG.
  76 #ifndef REGVARS
  77 QR3     = ("r3",8,R3,R4),QREG.
  78 QR5     = ("r5",8,R5,R6),QREG.
  79 QR7     = ("r7",8,R7,R8),QREG.
  80 QR9     = ("r9",8,R9,RA),QREG.
  81 #endif /* REGVARS */
  82
  83 TOKENS:
  84
  85 /* First some EM machine tokens */
  86 CONST1 =        {INT num;}              4 cost=(4,3)  "$%[num]"
  87 CONST2 =        {INT num;}              4 cost=(4,3)  "$%[num]"
  88 CONST4 =        {INT num;}              4 cost=(4,3)  "$%[num]"
  89 CONST8 =        {STRING ind;}           8 cost=(8,6)  "$%[ind]"
  90 LOCAL1 =        {REGISTER reg; INT num,size;}   4 cost=(2,6)  "%[num](%[reg])"
  91 LOCAL2 =        {REGISTER reg; INT num,size;}   4 cost=(2,6)  "%[num](%[reg])"
  92 LOCAL4 =        {REGISTER reg; INT num,size;}   4 cost=(2,6)  "%[num](%[reg])"
  93 LOCAL8 =        {REGISTER reg; INT num,size;}   8 cost=(2,9)  "%[num](%[reg])"
  94 ADDR_LOCAL =    {REGISTER reg; INT num;}        4 cost=(2,6)  "%[num](%[reg])"
  95 ADDR_EXTERNAL = {STRING ind;}           4 cost=(4,6)  "%[ind]"
  96 EXTERNAL1 =     {STRING ind;}           4 cost=(4,6)  "%[ind]"
  97 EXTERNAL2 =     {STRING ind;}           4 cost=(4,6)  "%[ind]"
  98 EXTERNAL4 =     {STRING ind;}           4 cost=(4,6)  "%[ind]"
  99 EXTERNAL8 =     {STRING ind;}           8 cost=(4,9)  "%[ind]"
 100 DOUBLE =        {STRING ind;}           4 cost=(4,6)  "$%[ind]"
 101 /* Now tokens for the target machine */
 102 regdef1 =       {REGISTER reg;}         4 cost=(0,3)  REGDEFFORMAT
 103 regdef2 =       {REGISTER reg;}         4 cost=(0,3)  REGDEFFORMAT
 104 regdef4 =       {REGISTER reg;}         4 cost=(0,3)  REGDEFFORMAT
 105 regdef8 =       {REGISTER reg;}         8 cost=(0,6)  REGDEFFORMAT
 106 #ifdef REGVARS
 107 reginc1 =       {REGISTER reg;}         4 cost=(0,3)  "(%[reg])+"
 108 reginc2 =       {REGISTER reg;}         4 cost=(0,3)  "(%[reg])+"
 109 reginc4 =       {REGISTER reg;}         4 cost=(0,3)  "(%[reg])+"
 110 reginc8 =       {REGISTER reg;}         8 cost=(0,6)  "(%[reg])+"
 111 regdec1 =       {REGISTER reg;}         4 cost=(0,3)  "-(%[reg])"
 112 regdec2 =       {REGISTER reg;}         4 cost=(0,3)  "-(%[reg])"
 113 regdec4 =       {REGISTER reg;}         4 cost=(0,3)  "-(%[reg])"
 114 regdec8 =       {REGISTER reg;}         8 cost=(0,6)  "-(%[reg])"
 115 #endif /* REGVARS */
 116 displ1 =        {REGISTER reg; STRING ind;} 4 cost=(2,6)  "%[ind](%[reg])"
 117 displ2 =        {REGISTER reg; STRING ind;} 4 cost=(2,6)  "%[ind](%[reg])"
 118 displ4 =        {REGISTER reg; STRING ind;} 4 cost=(2,6)  "%[ind](%[reg])"
 119 displ8 =        {REGISTER reg; STRING ind;} 8 cost=(2,9)  "%[ind](%[reg])"
 120 displdef1 =     {REGISTER reg; STRING ind;} 4 cost=(2,9)  "*%[ind](%[reg])"
 121 displdef2 =     {REGISTER reg; STRING ind;} 4 cost=(2,9)  "*%[ind](%[reg])"
 122 displdef4 =     {REGISTER reg; STRING ind;} 4 cost=(2,9)  "*%[ind](%[reg])"
 123 displdef8 =     {REGISTER reg; STRING ind;} 8 cost=(2,12) "*%[ind](%[reg])"
 124 reldef1 =       {STRING ind;}           4 cost=(4,9)    "*%[ind]"
 125 reldef2 =       {STRING ind;}           4 cost=(4,9)    "*%[ind]"
 126 reldef4 =       {STRING ind;}           4 cost=(4,9)    "*%[ind]"
 127 reldef8 =       {STRING ind;}           8 cost=(4,12)   "*%[ind]"
 128 extind2 =       {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
 129 extind4 =       {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
 130 extind8 =       {REGISTER ireg; STRING ind; } 8 cost=(5,13) "%[ind] [%[ireg]]"
 131 displind1 =     {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 132                                                 "%[ind](%[reg]) [%[ireg]]"
 133 displind2 =     {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 134                                                 "%[ind](%[reg]) [%[ireg]]"
 135 displind4 =     {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 136                                                 "%[ind](%[reg]) [%[ireg]]"
 137 displind8 =     {REGISTER ireg,reg; STRING ind;} 8 cost=(3,13)
 138                                                 "%[ind](%[reg]) [%[ireg]]"
 139 extdefind1 =    {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 140 extdefind2 =    {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 141 extdefind4 =    {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 142 extdefind8 =    {REGISTER ireg; STRING ind; } 8 cost=(5,16) "*%[ind] [%[ireg]]"
 143 displdefind1 =  {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 144                                                 "*%[ind](%[reg]) [%[ireg]]"
 145 displdefind2 =  {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 146                                                 "*%[ind](%[reg]) [%[ireg]]"
 147 displdefind4 =  {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 148                                                 "*%[ind](%[reg]) [%[ireg]]"
 149 displdefind8 =  {REGISTER ireg,reg; STRING ind;} 8 cost=(3,16)
 150                                                 "*%[ind](%[reg]) [%[ireg]]"
 151
 152 /* Not really addressable modes */
 153 adispl =        {REGISTER reg; STRING ind; } 4 cost=(4,6)  "%[ind](%[reg])"
 154 aextind2 =      {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
 155 aextind4 =      {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
 156 aextind8 =      {REGISTER ireg; STRING ind; } 4 cost=(5,10) "%[ind] [%[ireg]]"
 157 adisplind1 =    {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 158                                                 "%[ind](%[reg]) [%[ireg]]"
 159 adisplind2 =    {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 160                                                 "%[ind](%[reg]) [%[ireg]]"
 161 adisplind4 =    {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 162                                                 "%[ind](%[reg]) [%[ireg]]"
 163 adisplind8 =    {REGISTER ireg,reg; STRING ind;} 4 cost=(3,10)
 164                                                 "%[ind](%[reg]) [%[ireg]]"
 165 aextdefind1 =   {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 166 aextdefind2 =   {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 167 aextdefind4 =   {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 168 aextdefind8 =   {REGISTER ireg; STRING ind; } 4 cost=(5,13) "*%[ind] [%[ireg]]"
 169 adispldefind1 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 170                                                 "*%[ind](%[reg]) [%[ireg]]"
 171 adispldefind2 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 172                                                 "*%[ind](%[reg]) [%[ireg]]"
 173 adispldefind4 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 174                                                 "*%[ind](%[reg]) [%[ireg]]"
 175 adispldefind8 = {REGISTER ireg,reg; STRING ind;} 4 cost=(3,13)
 176                                                 "*%[ind](%[reg]) [%[ireg]]"
 177
 178
 179 TOKENEXPRESSIONS:
 180 CONST =         CONST1 + CONST2 + CONST4
 181 ind2 =          extind2 + displind2 + extdefind2 + displdefind2
 182 ind4 =          extind4 + displind4 + extdefind4 + displdefind4
 183 Xsource1 =      regdef1 + displ1 + displdef1 +
 184                 EXTERNAL1 + reldef1 + CONST1 + LOCAL1
 185                 + displind1 + extdefind1 + displdefind1
 186 source1 =       Xsource1
 187 #ifdef REGVARS
 188                 + reginc1 + regdec1
 189 #endif /* REGVARS */
 190 Xsource2 =      regdef2 + displ2 + displdef2 +
 191                 EXTERNAL2 + reldef2 + CONST2 + LOCAL2 + ind2
 192 source2 =       Xsource2
 193 #ifdef REGVARS
 194                 + reginc2 + regdec2
 195 #endif /* REGVARS */
 196 Xsource4 =      REG + regdef4 + displ4 + displdef4 + LocaLBase +
 197                 EXTERNAL4 + reldef4 + CONST + DOUBLE + LOCAL4 + ind4
 198 source4 =       Xsource4
 199 #ifdef REGVARS
 200                 + RREG + reginc4 + regdec4
 201 #endif /* REGVARS */
 202 dups4 =         CONST + regdef1 + displ1 + LOCAL1 +
 203                 REG +   regdef2 + displ2 + LOCAL2 +
 204                 RREG +  regdef4 + displ4 + LOCAL4 + DOUBLE
 205 Xsource8 =      QREG + regdef8 + displ8 + displdef8 +
 206                 EXTERNAL8 + reldef8 + CONST8 + LOCAL8
 207                 + extind8 + displind8 + extdefind8 + displdefind8
 208 source8 =       Xsource8
 209 #ifdef REGVARS
 210                 + reginc8 + regdec8
 211 #endif /* REGVARS */
 212 source1or2 =    source1 + source2 - ind2
 213 source1or2or4 = source1or2 + source4 - (ind2 + ind4)
 214 source2or4 =    source2 + source4 - ind4
 215 nonexist1 =     adispl + ADDR_EXTERNAL + ADDR_LOCAL
 216 aextind =       aextind2 + aextind4 + aextind8
 217 adisplind =     adisplind1 + adisplind2 + adisplind4 + adisplind8
 218 aextdefind =    aextdefind1 + aextdefind2 + aextdefind4 + aextdefind8
 219 adispldefind =  adispldefind1 + adispldefind2 + adispldefind4 + adispldefind8
 220 aind1 =         adisplind1 + aextdefind1 + adispldefind1
 221 aind2 =         aextind2 + adisplind2 + aextdefind2 + adispldefind2
 222 aind4 =         aextind4 + adisplind4 + aextdefind4 + adispldefind4
 223 aind8 =         aextind8 + adisplind8 + aextdefind8 + adispldefind8
 224 aind =          aind1 + aind2 + aind4 + aind8
 225 nonexist =      nonexist1 + aind
 226 #ifdef REGVARS
 227 regch4 =        reginc1 + regdec1 + reginc2 + regdec2 + reginc4 + regdec4
 228 regch8 =        reginc8 + regdec8
 229 regch =         regch4 + regch8
 230 #endif /* REGVARS */
 231 displs =        displ1 + displ2 + displ4 + displ8 +
 232                 regdef1 + regdef2 + regdef4 + regdef8
 233 #ifdef REGVARS
 234                 + regch
 235 #endif /* REGVARS */
 236 displdefs =     displdef1 + displdef2 + displdef4 + displdef8
 237 EXTERNALS =     EXTERNAL1 + EXTERNAL2 + EXTERNAL4 + EXTERNAL8
 238 LOCALS =        LOCAL1 + LOCAL2 + LOCAL4 + LOCAL8
 239 reldefs =       reldef1 + reldef2 + reldef4 + reldef8
 240 displinds =     displind1 + displind2 + displind4 + displind8
 241 extinds =       extind2 + extind4 + extind8
 242 displdefinds =  displdefind1 + displdefind2 + displdefind4 + displdefind8
 243 extdefinds =    extdefind1 + extdefind2 + extdefind4 + extdefind8
 244 displaced =     displs + displdefs + reldefs
 245                 + displinds + displdefinds + extdefinds
 246 externals =     EXTERNALS + displaced + extinds
 247 extandloc =     externals + LOCALS
 248 #ifdef REGVARS
 249 reg4 =          REG + RREG + LocaLBase
 250 reg8 =          QREG
 251 #else /* REGVARS */
 252 reg4 =          REG
 253 reg8 =          QREG
 254 #endif /* REGVARS */
 255 sreg4 =         REG * SCRATCH
 256 sreg8 =         QREG * SCRATCH
 257 bigsource4 =    source1or2or4 + nonexist + ind2 + ind4
 258 bigsource8 =    source8
 259 all =           bigsource4 + bigsource8
 260 scr =           ALL - (EXTERNALS + LOCALS + ADDR_LOCAL + ADDR_EXTERNAL + CONST
 261                         + DOUBLE)
 262 #ifdef REGVARS
 263 #define REMEXTANDLOC remove(externals) remove(LOCALS,inreg(%[num])==0)
 264 #define REMREG(x) remove(regch,%[reg]==regvar(x))
 265 #else /* REGVARS */
 266 #define REMEXTANDLOC remove(extandloc)
 267 #endif /* REGVARS */
 268
 269 CODE:
 270
 271 /********************************
 272  * Group 1 : Load instructions  *
 273  ********************************/
 274
 275 loc $1>=0 && $1<256     | |     | {CONST1,$1}                           | |
 276 loc $1>=256 && $1<65536 | |     | {CONST2,$1}                           | |
 277 loc             | |             | {CONST4,$1}                           | |
 278 ldc             | |             | {CONST8,$1}                           | |
 279 #ifdef REGVARS
 280 lol inreg($1)==2 | | REMREG($1) | regvar($1)                            | |
 281 #endif /* REGVARS */
 282 lol $1 < 0      | |             | {LOCAL4,LB,$1,4}                      | |
 283 lol $1 >= 0     | |             | {LOCAL4,AP,$1,4}                      | |
 284 loe             | |             | {EXTERNAL4,$1}                        | |
 285 #ifdef REGVARS
 286 lil inreg($1)==2 | |    REMREG($1)      | {regdef4,regvar($1)}          | |
 287 #endif /* REGVARS */
 288 lil $1 < 0      | |             | {displdef4,LB,tostring($1)}           | |
 289 lil $1 >= 0     | |             | {displdef4,AP,tostring($1)}           | |
 290 lof             | |             |                       | adp $1 loi 4  |
 291 lal $1 < 0      | |             | {ADDR_LOCAL,LB,$1}                    | |
 292 lal $1 >= 0     | |             | {ADDR_LOCAL,AP,$1}                    | |
 293 lae             | |             | {ADDR_EXTERNAL,$1}                    | |
 294 lxl $1==0       | |             | LB                                    | |
 295 lxl $1==1       | |             | {LOCAL4,AP,BSIZE,4}                   | |
 296 lxl $1 > 1      | |     remove(scr)
 297                         move({CONST4,$1},R0)
 298                         "jsb\t.lxl"
 299                         erase(R0)                               | R0    | |
 300 lxa $1==0       | |             | {ADDR_LOCAL,AP,BSIZE}                 | |
 301 lxa $1==1       | |             | {LOCAL4,AP,BSIZE,4}                   | lpb |
 302 lxa $1 > 1      | |     remove(scr)
 303                         move({CONST4,$1},R0)
 304                         "jsb\t.lxa"
 305                         erase(R0)                               | R0    | |
 306 loi $1==1       | NC adispl |   | {displ1,%[1.reg],%[1.ind]}            | |
 307 ...             | NC ADDR_LOCAL | | {LOCAL1,%[1.reg],%[1.num],1}        | |
 308 ...             | NC LOCAL4 |   | {displdef1,%[1.reg],tostring(%[1.num])} | |
 309 ...             | NC regdef4 |  | {displdef1,%[1.reg],"0"}              | |
 310 ...             | NC displ4 |   | {displdef1,%[1.reg],%[1.ind]}         | |
 311 ...             | NC ADDR_EXTERNAL | | {EXTERNAL1,%[1.ind]}             | |
 312 ...             | NC EXTERNAL4 | | {reldef1,%[1.ind]}                   | |
 313 ...             | NC adisplind1 |
 314                         | {displind1,%[1.ireg],%[1.reg],%[1.ind]}       | |
 315 ...             | NC aextdefind1 |
 316                                 | {extdefind1,%[1.ireg],%[1.ind]}       | |
 317 ...             | NC adispldefind1 |
 318                         | {displdefind1,%[1.ireg],%[1.reg],%[1.ind]}    | |
 319 ...             | reg4 |        | {regdef1,%[1]}                        | |
 320 loi $1==2       | NC adispl |   | {displ2,%[1.reg],%[1.ind]}            | |
 321 ...             | NC ADDR_LOCAL | | {LOCAL2,%[1.reg],%[1.num],2}        | |
 322 ...             | NC LOCAL4 |   | {displdef2,%[1.reg],tostring(%[1.num])} | |
 323 ...             | NC regdef4 |  | {displdef2,%[1.reg],"0"}              | |
 324 ...             | NC displ4 |   | {displdef2,%[1.reg],%[1.ind]}         | |
 325 ...             | NC ADDR_EXTERNAL | | {EXTERNAL2,%[1.ind]}             | |
 326 ...             | NC EXTERNAL4 | | {reldef2,%[1.ind]}                   | |
 327 ...             | NC aextind2 | | {extind2,%[1.ireg],%[1.ind]}  | |
 328 ...             | NC adisplind2 |
 329                         | {displind2,%[1.ireg],%[1.reg],%[1.ind]}       | |
 330 ...             | NC aextdefind2 |
 331                                 | {extdefind2,%[1.ireg],%[1.ind]}       | |
 332 ...             | NC adispldefind2 |
 333                         | {displdefind2,%[1.ireg],%[1.reg],%[1.ind]}    | |
 334 ...             | reg4 |        | {regdef2,%[1]}                        | |
 335 loi $1==4       | NC adispl |   | {displ4,%[1.reg],%[1.ind]}            | |
 336 ...             | NC ADDR_LOCAL | | {LOCAL4,%[1.reg],%[1.num],4}        | |
 337 ...             | NC LOCAL4 |   | {displdef4,%[1.reg],tostring(%[1.num])} | |
 338 ...             | NC regdef4 |  | {displdef4,%[1.reg],"0"}              | |
 339 ...             | NC displ4 |   | {displdef4,%[1.reg],%[1.ind]}         | |
 340 ...             | NC ADDR_EXTERNAL | | {EXTERNAL4,%[1.ind]}             | |
 341 ...             | NC EXTERNAL4 | | {reldef4,%[1.ind]}                   | |
 342 ...             | NC aextind4 | | {extind4,%[1.ireg],%[1.ind]}          | |
 343 ...             | NC adisplind4 |
 344                         | {displind4,%[1.ireg],%[1.reg],%[1.ind]}       | |
 345 ...             | NC aextdefind4 |
 346                                 | {extdefind4,%[1.ireg],%[1.ind]}       | |
 347 ...             | NC adispldefind4 |
 348                         | {displdefind4,%[1.ireg],%[1.reg],%[1.ind]}    | |
 349 ...             | reg4 |        | {regdef4,%[1]}                        | |
 350 loi $1==8       | NC adispl |   | {displ8,%[1.reg],%[1.ind]}            | |
 351 ...             | NC ADDR_LOCAL | | {LOCAL8,%[1.reg],%[1.num],8}        | |
 352 ...             | NC LOCAL4 |   | {displdef8,%[1.reg],tostring(%[1.num])} | |
 353 ...             | NC regdef4 |  | {displdef8,%[1.reg],"0"}              | |
 354 ...             | NC displ4 |   | {displdef8,%[1.reg],%[1.ind]} | |
 355 ...             | NC ADDR_EXTERNAL | | {EXTERNAL8,%[1.ind]}             | |
 356 ...             | NC EXTERNAL4 | | {reldef8,%[1.ind]}                   | |
 357 ...             | NC aextind8 | | {extind8,%[1.ireg],%[1.ind]}          | |
 358 ...             | NC adisplind8 |
 359                         | {displind8,%[1.ireg],%[1.reg],%[1.ind]}       | |
 360 ...             | NC aextdefind8 |
 361                                 | {extdefind8,%[1.ireg],%[1.ind]}       | |
 362 ...             | NC adispldefind8 |
 363                         | {displdefind8,%[1.ireg],%[1.reg],%[1.ind]}    | |
 364 ...             | reg4 |        | {regdef8,%[1]}                        | |
 365 loi $1>8 && $1<=16
 366                 | NC ADDR_EXTERNAL |
 367                                 | {EXTERNAL8,%[1.ind]+"+"+tostring($1-8)}
 368                                 %[1]                            | loi $1-8 |
 369 ...             | NC ADDR_LOCAL |
 370                                 | {LOCAL8,%[1.reg],%[1.num]+$1-8,8} %[1]
 371                                                                 | loi $1-8 |
 372 ...             | reg4 | | {displ8,%[1],tostring($1-8)} %[1]    | loi $1-8 |
 373 loi             | sreg4 |
 374                         remove(ALL)
 375                         allocate(REG={CONST4,$1/4})
 376                         "addl2\t$$$1,%[1]"
 377 #ifdef LOCLABS
 378                         "1:\nmovl\t-(%[1]),-(sp)"
 379                         "sobgtr\t%[a],1b"
 380 #else
 381                         "movl\t-(%[1]),-(sp)"
 382                         "sobgtr\t%[a],.-3"
 383 #endif
 384                         erase(%[a])                             |       | |
 385 los $1==4       | STACK |
 386                         move({CONST1,4},R0)
 387                         "jsb\t.los"
 388                         erase(R0)                               |       | |
 389 los !defined($1) | source1or2or4 |
 390                         remove(ALL)
 391                         move(%[1],R0)
 392                         "jsb\t.los"
 393                         erase(R0)                               |       | |
 394 ldl $1<0        | |             | {LOCAL8,LB,$1,8}                      | |
 395 ldl $1>=0       | |             | {LOCAL8,AP,$1,8}                      | |
 396 lde             | |             | {EXTERNAL8,$1}                        | |
 397 ldf             | |             |               | adp $1 loi 8  |
 398 lpi             | |             | {ADDR_EXTERNAL,$1}                    | |
 399
 400 /********************************
 401  * Group 2 : Store instructions *
 402  ********************************/
 403
 404 #ifdef REGVARS
 405 stl inreg($1)==2 | NC bigsource4 |
 406                         remove(regvar($1))
 407                         move(%[1],regvar($1))           |       | |
 408 ...             | STACK |
 409                         "movl\t(sp)+,%(regvar($1)%)"    |       | | (3,7)
 410 #endif /* REGVARS */
 411 stl $1 < 0      | NC bigsource4 |
 412                         remove(displaced)
 413                         remove(LOCALS,%[num] <= $1+3 && %[num]+%[size] > $1)
 414                         move(%[1],{LOCAL4,LB,$1,4})             |       | |
 415 ...             | STACK |
 416                         "movl\t(sp)+,$1(fp)"            |       | | (5,14)
 417 stl $1 >= 0     | NC bigsource4 |
 418                         remove(displaced)
 419                         remove(LOCALS,%[num] <= $1+3 && %[num]+%[size] > $1)
 420                         move(%[1],{LOCAL4,AP,$1,4})             |       | |
 421 ...             | STACK |
 422                         "movl\t(sp)+,$1(ap)"            |       | | (5,14)
 423 ste             | NC bigsource4 |
 424                         remove(externals)
 425                         move(%[1],{EXTERNAL4,$1})               |       | |
 426 ...             | STACK |
 427                         "movl\t(sp)+,$1"                |       | | (7,14)
 428 #ifdef REGVARS
 429 sil inreg($1)==2 | NC bigsource4 |
 430                         REMEXTANDLOC
 431                         move(%[1],{regdef4,regvar($1)}) |       | |
 432 ...             | STACK |
 433                         "movl\t(sp)+,(%(regvar($1)%))"  |       | | (3,10)
 434 #endif /* REGVARS */
 435 sil $1 < 0      | NC bigsource4 |
 436                         REMEXTANDLOC
 437                         move(%[1],{displdef4,LB,tostring($1)})  |       | |
 438 ...             | STACK |
 439                         "movl\t(sp)+,*$1(fp)"           |       | | (5,17)
 440 sil $1 >= 0     | NC bigsource4 |
 441                         REMEXTANDLOC
 442                         move(%[1],{displdef4,AP,tostring($1)})  |       | |
 443 ...             | STACK |
 444                         "movl\t(sp)+,*$1(ap)"           |       | | (5,17)
 445 stf             | |                             | | adp $1 sti 4 |
 446 /*** C-problem: f(c) char c; {
 447                         write(1,&c,1);
 448                 }
 449                 You don't know where the character is put in the word,
 450                 so the CEM-compiler generates: (shorts analogously)
 451 ***/
 452 lol lal sti $1==$2 && $3<4      | | | | |
 453 /************************************************/
 454 sti $1==1       | NC adispl source1or2or4 |
 455                         REMEXTANDLOC
 456                         move(%[2],{displ1,%[1.reg],%[1.ind]})   |       | |
 457 ...             | NC ADDR_LOCAL source1or2or4 |
 458                         remove(displaced)
 459                         remove(LOCALS,
 460                                 %[num]<=%[1.num] && %[num]+%[size]>%[1.num])
 461                         move(%[2],{LOCAL1,%[1.reg],%[1.num],1}) |       | |
 462 ...             | NC displ4 source1or2or4 |
 463                         REMEXTANDLOC
 464                         move(%[2],{displdef1,%[1.reg],%[1.ind]}) |      | |
 465 ...             | NC ADDR_EXTERNAL source1or2or4 |
 466                         remove(externals)
 467                         move(%[2],{EXTERNAL1,%[1.ind]})         |       | |
 468 ...             | NC EXTERNAL4 source1or2or4 |
 469                         REMEXTANDLOC
 470                         move(%[2],{reldef1,%[1.ind]})           |       | |
 471 ...             | NC adisplind1 source1or2or4 |
 472                         REMEXTANDLOC
 473                         move(%[2],{displind1,%[1.ireg],%[1.reg],%[1.ind]})
 474                                                                 |       | |
 475 ...             | NC aextdefind1 source1or2or4 |
 476                         REMEXTANDLOC
 477                         move(%[2],{extdefind1,%[1.ireg],%[1.ind]}) |    | |
 478 ...             | NC adispldefind1 source1or2or4 |
 479                         REMEXTANDLOC
 480                         move(%[2],{displdefind1,%[1.ireg],%[1.reg],%[1.ind]})
 481                                                                 |       | |
 482 ...             | reg4 source1or2or4 |
 483                         REMEXTANDLOC
 484                         move(%[2],{regdef1,%[1]})               |       | |
 485 ...             | NC nonexist1+aind1 STACK |
 486                         "cvtlb\t(sp)+,%[1]"             |       | | (3,7)+%[1]
 487 sti $1==2       | NC adispl source1or2or4 |
 488                         REMEXTANDLOC
 489                         move(%[2],{displ2,%[1.reg],%[1.ind]}) | | |
 490 ...             | NC ADDR_LOCAL source1or2or4 |
 491                         remove(displaced)
 492                         remove(LOCALS,
 493                                 %[num]<=%[1.num] && %[num]+%[size]>%[1.num])
 494                         move(%[2],{LOCAL2,%[1.reg],%[1.num],2}) |       | |
 495 ...             | NC displ4 source1or2or4 |
 496                         REMEXTANDLOC
 497                         move(%[2],{displdef2,%[1.reg],%[1.ind]}) |      | |
 498 ...             | NC ADDR_EXTERNAL source1or2or4 |
 499                         remove(externals)
 500                         move(%[2],{EXTERNAL2,%[1.ind]})         |       | |
 501 ...             | NC EXTERNAL4 source1or2or4 |
 502                         REMEXTANDLOC
 503                         move(%[2],{reldef2,%[1.ind]})           |       | |
 504 ...             | NC aextind2 source1or2or4 |
 505                         remove(externals)
 506                         move(%[2],{extind2,%[1.ireg],%[1.ind]}) |       | |
 507 ...             | NC adisplind2 source1or2or4 |
 508                         REMEXTANDLOC
 509                         move(%[2],{displind2,%[1.ireg],%[1.reg],%[1.ind]}) | | |
 510 ...             | NC aextdefind2 source1or2or4 |
 511                         REMEXTANDLOC
 512                         move(%[2],{extdefind2,%[1.ireg],%[1.ind]}) |    | |
 513 ...             | NC adispldefind2 source1or2or4 |
 514                         REMEXTANDLOC
 515                         move(%[2],{displdefind2,%[1.ireg],%[1.reg],%[1.ind]})
 516                                                                 |       | |
 517 ...             | reg4 source1or2or4 |
 518                         REMEXTANDLOC
 519                         move(%[2],{regdef2,%[1]})               |       | |
 520 sti $1==4       | NC adispl bigsource4 |
 521                         REMEXTANDLOC
 522                         move(%[2],{displ4,%[1.reg],%[1.ind]}) | | |
 523 ...             | NC ADDR_LOCAL |               | | stl %[1.num] |
 524 ...             | NC ADDR_EXTERNAL |            | | ste %[1.ind] |
 525 ...             | NC LOCAL4 bigsource4 |
 526                         REMEXTANDLOC
 527                         move(%[2],{displdef4,%[1.reg],tostring(%[1.num])}) | | |
 528 ...             | NC regdef4 bigsource4 |
 529                         REMEXTANDLOC
 530                         move(%[2],{displdef4,%[1.reg],"0"})     |       | |
 531 ...             | NC displ4 bigsource4 |
 532                         REMEXTANDLOC
 533                         move(%[2],{displdef4,%[1.reg],%[1.ind]}) |      | |
 534 ...             | NC EXTERNAL4 bigsource4 |
 535                         REMEXTANDLOC
 536                         move(%[2],{reldef4,%[1.ind]})           |       | |
 537 ...             | NC aextind4 bigsource4 |
 538                         remove(externals)
 539                         move(%[2],{extind4,%[1.ireg],%[1.ind]}) |       | |
 540 ...             | NC adisplind4 bigsource4 |
 541                         REMEXTANDLOC
 542                         move(%[2],{displind4,%[1.ireg],%[1.reg],%[1.ind]}) | | |
 543 ...             | NC aextdefind4 bigsource4 |
 544                         REMEXTANDLOC
 545                         move(%[2],{extdefind4,%[1.ireg],%[1.ind]}) |    | |
 546 ...             | NC adispldefind4 bigsource4 |
 547                         REMEXTANDLOC
 548                         move(%[2],{displdefind4,%[1.ireg],%[1.reg],%[1.ind]})
 549                                                                 |       | |
 550 ...             | NC nonexist1+aind4 STACK |
 551                         "movl\t(sp)+,%[1]"              |       | | (3,7)+%[1]
 552 ...             | reg4 bigsource4 |
 553                         REMEXTANDLOC
 554                         move(%[2],{regdef4,%[1]})               |       | |
 555 ...             | reg4 STACK |
 556                         "movl\t(sp)+,(%[1])"            |       | | (3,10)
 557 sti $1==8       | NC adispl bigsource8 |
 558                         REMEXTANDLOC
 559                         move(%[2],{displ8,%[1.reg],%[1.ind]}) | | |
 560 ...             | NC ADDR_LOCAL |               | | sdl %[1.num] |
 561 ...             | NC ADDR_EXTERNAL |            | | sde %[1.ind] |
 562 ...             | NC displ4 bigsource8 |
 563                         REMEXTANDLOC
 564                         move(%[2],{displdef8,%[1.reg],%[1.ind]}) |      | |
 565 ...             | NC LOCAL4 bigsource8 |
 566                         REMEXTANDLOC
 567                         move(%[2],{displdef8,%[1.reg],tostring(%[1.num])}) | | |
 568 ...             | NC regdef4 bigsource8 |
 569                         REMEXTANDLOC
 570                         move(%[2],{displdef8,%[1.reg],"0"})     |       | |
 571 ...             | NC EXTERNAL4 bigsource8 |
 572                         REMEXTANDLOC
 573                         move(%[2],{reldef8,%[1.ind]})           |       | |
 574 ...             | NC aextind8 bigsource8 |
 575                         remove(externals)
 576                         move(%[2],{extind8,%[1.ireg],%[1.ind]}) |       | |
 577 ...             | NC adisplind8 bigsource8 |
 578                         REMEXTANDLOC
 579                         move(%[2],{displind8,%[1.ireg],%[1.reg],%[1.ind]}) | | |
 580 ...             | NC aextdefind8 bigsource8 |
 581                         REMEXTANDLOC
 582                         move(%[2],{extdefind8,%[1.ireg],%[1.ind]}) |    | |
 583 ...             | NC adispldefind8 bigsource8 |
 584                         REMEXTANDLOC
 585                         move(%[2],{displdefind8,%[1.ireg],%[1.reg],%[1.ind]})
 586                                                                 |       | |
 587 ...             | reg4 bigsource8 |
 588                         REMEXTANDLOC
 589                         move(%[2],{regdef8,%[1]})               |       | |
 590 sti             | sreg4 |
 591                         remove(ALL)
 592                         allocate(REG={CONST4,$1/4})
 593 #ifdef LOCLABS
 594                         "1:\nmovl\t(sp)+,(%[1])+"
 595                         "sobgtr\t%[a],1b"
 596 #else
 597                         "movl\t(sp)+,(%[1])+"
 598                         "sobgtr\t%[a],.-3"
 599 #endif
 600                         erase(%[a])                             |       | |
 601 sts $1==4       | STACK |
 602                         move({CONST1,4},R0)
 603                         "jsb\t.sts"
 604                         erase(R0)                               |       | |
 605 sts !defined($1) | source4 |
 606                         remove(ALL)
 607                         move(%[1],R0)
 608                         "jsb\t.sts"
 609                         erase(R0)                               |       | |
 610 sdl $1 < 0      | NC bigsource8 |
 611                         remove(displaced)
 612                         remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
 613                         move(%[1],{LOCAL8,LB,$1,8})             |       | |
 614 ...             | NC bigsource4 bigsource4 |
 615                         remove(displaced)
 616                         remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
 617                         move(%[1],{LOCAL4,LB,$1,4})
 618                         move(%[2],{LOCAL4,LB,$1+4,4})           |       | |
 619 ...             | STACK |
 620                         "movq\t(sp)+,$1(fp)"            |       | | (5,14)
 621 sdl $1 >= 0     | NC bigsource8 |
 622                         remove(displaced)
 623                         remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
 624                         move(%[1],{LOCAL8,AP,$1,8})             |       | |
 625 ...             | NC bigsource4 bigsource4 |
 626                         remove(displaced)
 627                         remove(LOCALS,%[num]<=$1+7 && %[num]+%[size]>$1)
 628                         move(%[1],{LOCAL4,AP,$1,4})
 629                         move(%[2],{LOCAL4,AP,$1+4,4})           |       | |
 630 ...             | STACK |
 631                         "movq\t(sp)+,$1(ap)"            |       | | (5,14)
 632 sde             | NC bigsource8 |
 633                         remove(externals)
 634                         move(%[1],{EXTERNAL8,$1})               |       | |
 635 ...             | bigsource4 bigsource4 |
 636                         remove(externals)
 637                         move(%[1],{EXTERNAL4,$1})
 638                         move(%[2],{EXTERNAL4,$1+"+4"})  |       | |
 639 ...             | STACK |
 640                         "movq\t(sp)+,$1"                |       | | (7,14)
 641 sdf             | |                                     | | adp $1 sti 8 |
 642
 643 /********************************
 644  * Group 3 : Integer Arithmetic *
 645  ********************************/
 646
 647 adi $1==4       | source4 sreg4 |
 648                         "addl2\t%[1],%[2]"
 649                         erase(%[2])
 650                         setcc(%[2])             | %[2]  | | (3,4) + %[1]
 651 ...             | sreg4 source4 |
 652                         "addl2\t%[2],%[1]"
 653                         erase(%[1])
 654                         setcc(%[1])             | %[1]  | | (3,4) + %[2]
 655 ...             | source4 source4 |
 656                         allocate(%[1],%[2],REG)
 657                         "addl3\t%[1],%[2],%[a]"
 658                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
 659 #ifdef REGVARS
 660 adi stl $1==4 && inreg($2)==2
 661                 | source4 source4 |
 662                         remove(regvar($2))
 663                         "addl3\t%[1],%[2],%(regvar($2)%)"
 664                         erase(regvar($2))
 665                         setcc(regvar($2))       |       | |
 666 #endif /* REGVARS */
 667 adi stl $1==4 && $2<0
 668                 | source4 source4 |
 669                         remove(displaced)
 670                         remove(LOCALS,%[num]<=$2+3 && %[num]+%[size]>$2)
 671                         "addl3\t%[1],%[2],$2(fp)"
 672                         setcc({LOCAL4,LB,$2,4})         |       | |
 673 adi stl $1==4 && $2>=0
 674                 | source4 source4 |
 675                         remove(displaced)
 676                         remove(LOCALS,%[num]<=$2+3 && %[num]+%[size]>$2)
 677                         "addl3\t%[1],%[2],$2(ap)"
 678                         setcc({LOCAL4,AP,$2,4})         |       | |
 679 #ifdef REGVARS
 680 adi sil $1==4 && inreg($2)==2
 681                 | source4 source4 |
 682                         REMEXTANDLOC
 683                         "addl3\t%[1],%[2],(%(regvar($2)%))"
 684                         setcc({regdef4,regvar($2)})     |       | |
 685 adi lol stf $1==4 && inreg($2)==2
 686                 | source4 source4 |
 687                         REMEXTANDLOC
 688                         "addl3\t%[1],%[2],$3(%(regvar($2)%))"
 689                         setcc({displ4,regvar($2),tostring($3)}) |       | |
 690 #endif /* REGVARS */
 691 adi sil $1==4 && $2<0
 692                 | source4 source4 |
 693                         REMEXTANDLOC
 694                         "addl3\t%[1],%[2],*$2(fp)"
 695                         setcc({displdef4,LB,tostring($2)})      |       | |
 696 adi sil $1==4 && $2>=0
 697                 | source4 source4 |
 698                         REMEXTANDLOC
 699                         "addl3\t%[1],%[2],*$2(ap)"
 700                         setcc({displdef4,AP,tostring($2)})      |       | |
 701 adi ste $1==4   | source4 source4 |
 702                         remove(externals)
 703                         "addl3\t%[1],%[2],$2"
 704                         setcc({EXTERNAL4,$2})                   |       | |
 705 adi !defined($1) | source4 |
 706                         remove(ALL)
 707                         move(%[1],R0)
 708                         "jsb\t.adi"                          |       | |
 709 sbi $1==4       | source4 sreg4 |
 710                         "subl2\t%[1],%[2]"
 711                         erase(%[2])
 712                         setcc(%[2])             | %[2]  | | (3,4) + %[1]
 713 ...             | source4 source4 |
 714                         allocate(%[1],%[2],REG)
 715                         "subl3\t%[1],%[2],%[a]"
 716                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
 717 #ifdef REGVARS
 718 sbi stl $1==4 && inreg($2)==2
 719                 | source4 source4 |
 720                         remove(regvar($2))
 721                         "subl3\t%[1],%[2],%(regvar($2)%)"
 722                         erase(regvar($2))
 723                         setcc(regvar($2))       |       | |
 724 #endif /* REGVARS */
 725 sbi stl $1==4 && $2<0
 726                 | source4 source4 |
 727                         remove(displaced)
 728                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 729                         "subl3\t%[1],%[2],$2(fp)"
 730                         setcc({LOCAL4,LB,$2,4})         |       | |
 731 sbi stl $1==4 && $2>=0
 732                 | source4 source4 |
 733                         remove(displaced)
 734                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 735                         "subl3\t%[1],%[2],$2(ap)"
 736                         setcc({LOCAL4,AP,$2,4})         |       | |
 737 #ifdef REGVARS
 738 sbi sil $1==4 && inreg($2)==2
 739                 | source4 source4 |
 740                         REMEXTANDLOC
 741                         "subl3\t%[1],%[2],(%(regvar($2)%))"
 742                         setcc({regdef4,regvar($2)})     |       | |
 743 sbi lol stf $1==4 && inreg($2)==2
 744                 | source4 source4 |
 745                         REMEXTANDLOC
 746                         "subl3\t%[1],%[2],$3(%(regvar($2)%))"
 747                         setcc({displ4,regvar($2),tostring($3)}) |       | |
 748 #endif /* REGVARS */
 749 sbi sil $1==4 && $2<0
 750                 | source4 source4 |
 751                         REMEXTANDLOC
 752                         "subl3\t%[1],%[2],*$2(fp)"
 753                         setcc({displdef4,LB,tostring($2)})      |       | |
 754 sbi sil $1==4 && $2>=0
 755                 | source4 source4 |
 756                         REMEXTANDLOC
 757                         "subl3\t%[1],%[2],*$2(ap)"
 758                         setcc({displdef4,AP,tostring($2)})      |       | |
 759 sbi ste $1==4   | source4 source4 |
 760                         remove(externals)
 761                         "subl3\t%[1],%[2],$2"
 762                         setcc({EXTERNAL4,$2})                   |       | |
 763 sbi !defined($1) | source4 |
 764                         remove(ALL)
 765                         move(%[1],R0)
 766                         "jsb\t.sbi"                          |       | |
 767 mli $1==4       | source4 sreg4 |
 768                         "mull2\t%[1],%[2]"
 769                         erase(%[2])
 770                         setcc(%[2])             | %[2]  | | (3,16) + %[1]
 771 ...             | sreg4 source4 |
 772                         "mull2\t%[2],%[1]"
 773                         erase(%[1])
 774                         setcc(%[1])             | %[1]  | | (3,16) + %[2]
 775 ...             | source4 source4 |
 776                         allocate(%[1],%[2],REG)
 777                         "mull3\t%[1],%[2],%[a]"
 778                         setcc(%[a])             | %[a]  | | (4,16)+%[1]+%[2]
 779 #ifdef REGVARS
 780 mli stl $1==4 && inreg($2)==2
 781                 | source4 source4 |
 782                         remove(regvar($2))
 783                         "mull3\t%[1],%[2],%(regvar($2)%)"
 784                         erase(regvar($2))
 785                         setcc(regvar($2))       |       | |
 786 #endif /* REGVARS */
 787 mli stl $1==4 && $2<0
 788                 | source4 source4 |
 789                         remove(displaced)
 790                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 791                         "mull3\t%[1],%[2],$2(fp)"
 792                         setcc({LOCAL4,LB,$2,4})         |       | |
 793 mli stl $1==4 && $2>=0
 794                 | source4 source4 |
 795                         remove(displaced)
 796                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 797                         "mull3\t%[1],%[2],$2(ap)"
 798                         setcc({LOCAL4,AP,$2,4})         |       | |
 799 #ifdef REGVARS
 800 mli sil $1==4 && inreg($2)==2
 801                 | source4 source4 |
 802                         REMEXTANDLOC
 803                         "mull3\t%[1],%[2],(%(regvar($2)%))"
 804                         setcc({regdef4,regvar($2)})     |       | |
 805 mli lol stf $1==4 && inreg($2)==2
 806                 | source4 source4 |
 807                         REMEXTANDLOC
 808                         "mull3\t%[1],%[2],$3(%(regvar($2)%))"
 809                         setcc({displ4,regvar($2),tostring($3)}) |       | |
 810 #endif /* REGVARS */
 811 mli sil $1==4 && $2<0
 812                 | source4 source4 |
 813                         REMEXTANDLOC
 814                         "mull3\t%[1],%[2],*$2(fp)"
 815                         setcc({displdef4,LB,tostring($2)})      |       | |
 816 mli sil $1==4 && $2>=0
 817                 | source4 source4 |
 818                         REMEXTANDLOC
 819                         "mull3\t%[1],%[2],*$2(ap)"
 820                         setcc({displdef4,AP,tostring($2)})      |       | |
 821 mli ste $1==4   | source4 source4 |
 822                         remove(externals)
 823                         "mull3\t%[1],%[2],$2"
 824                         setcc({EXTERNAL4,$2})                   |       | |
 825 mli !defined($1) | source4 |
 826                         remove(ALL)
 827                         move(%[1],R0)
 828                         "jsb\t.mli"                          |       | |
 829 dvi $1==4       | source4 sreg4 |
 830                         "divl2\t%[1],%[2]"
 831                         erase(%[2])
 832                         setcc(%[2])                 | %[2]  | | (3,98) + %[1]
 833 ...             | source4 source4 |
 834                         allocate(%[1],%[2],REG)
 835                         "divl3\t%[1],%[2],%[a]"
 836                         setcc(%[a])             | %[a]  | | (4,98)+%[1]+%[2]
 837 #ifdef REGVARS
 838 dvi stl $1==4 && inreg($2)==2
 839                 | source4 source4 |
 840                         remove(regvar($2))
 841                         "divl3\t%[1],%[2],%(regvar($2)%)"
 842                         erase(regvar($2))
 843                         setcc(regvar($2))       |       | |
 844 #endif /* REGVARS */
 845 dvi stl $1==4 && $2<0
 846                 | source4 source4 |
 847                         remove(displaced)
 848                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 849                         "divl3\t%[1],%[2],$2(fp)"
 850                         setcc({LOCAL4,LB,$2,4})         |       | |
 851 dvi stl $1==4 && $2>=0
 852                 | source4 source4 |
 853                         remove(displaced)
 854                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 855                         "divl3\t%[1],%[2],$2(ap)"
 856                         setcc({LOCAL4,AP,$2,4})         |       | |
 857 #ifdef REGVARS
 858 dvi sil $1==4 && inreg($2)==2
 859                 | source4 source4 |
 860                         REMEXTANDLOC
 861                         "divl3\t%[1],%[2],(%(regvar($2)%))"
 862                         setcc({regdef4,regvar($2)})     |       | |
 863 dvi lol stf $1==4 && inreg($2)==2
 864                 | source4 source4 |
 865                         REMEXTANDLOC
 866                         "divl3\t%[1],%[2],$3(%(regvar($2)%))"
 867                         setcc({displ4,regvar($2),tostring($3)}) |       | |
 868 #endif /* REGVARS */
 869 dvi sil $1==4 && $2<0
 870                 | source4 source4 |
 871                         REMEXTANDLOC
 872                         "divl3\t%[1],%[2],*$2(fp)"
 873                         setcc({displdef4,LB,tostring($2)})      |       | |
 874 dvi sil $1==4 && $2>=0
 875                 | source4 source4 |
 876                         REMEXTANDLOC
 877                         "divl3\t%[1],%[2],*$2(ap)"
 878                         setcc({displdef4,AP,tostring($2)})      |       | |
 879 dvi ste $1==4   | source4 source4 |
 880                         remove(externals)
 881                         "divl3\t%[1],%[2],$2"
 882                         setcc({EXTERNAL4,$2})                   |       | |
 883 dvi !defined($1) | source4 |
 884                         remove(ALL)
 885                         move(%[1],R0)
 886                         "jsb\t.dvi"                          |       | |
 887 rmi $1==4       | Xsource4 Xsource4 |
 888                         allocate(REG)
 889                         "divl3\t%[1],%[2],%[a]"
 890                         "mull2\t%[1],%[a]"
 891                         "subl3\t%[a],%[2],%[a]"
 892                         setcc(%[a])                             | %[a]   | |
 893 #ifdef REGVARS
 894 rmi stl $1==4 && inreg($2)==2
 895                 | Xsource4 Xsource4 |
 896                         remove(regvar($2))
 897                         allocate(REG)
 898                         "divl3\t%[1],%[2],%[a]"
 899                         "mull2\t%[1],%[a]"
 900                         "subl3\t%[a],%[2],%(regvar($2)%)"
 901                         erase(regvar($2))
 902                         setcc(regvar($2))               |       | |
 903 #endif /* REGVARS */
 904 rmi stl $1==4 && $2<0
 905                 | Xsource4 Xsource4 |
 906                         remove(displaced)
 907                         remove(LOCALS,(%[num]<=$2+3 && %[num]+%[size]>$2))
 908                         allocate(REG)
 909                         "divl3\t%[1],%[2],%[a]"
 910                         "mull2\t%[1],%[a]"
 911                         "subl3\t%[a],%[2],$2(fp)"
 912                         setcc({LOCAL4,LB,$2,4})         |       | |
 913 rmi stl $1==4 && $2>=0
 914                 | Xsource4 Xsource4 |
 915                         remove(displaced)
 916                         remove(LOCALS,(%[num]<=$2+3 && %[num]+%[size]>$2))
 917                         allocate(REG)
 918                         "divl3\t%[1],%[2],%[a]"
 919                         "mull2\t%[1],%[a]"
 920                         "subl3\t%[a],%[2],$2(ap)"
 921                         setcc({LOCAL4,AP,$2,4})         |       | |
 922 #ifdef REGVARS
 923 rmi sil $1==4 && inreg($2)==2
 924                 | Xsource4 Xsource4 |
 925                         REMEXTANDLOC
 926                         allocate(REG)
 927                         "divl3\t%[1],%[2],%[a]"
 928                         "mull2\t%[1],%[a]"
 929                         "subl3\t%[a],%[2],(%(regvar($2)%))"
 930                         setcc({regdef4,regvar($2)})     |       | |
 931 rmi lol stf $1==4 && inreg($2)==2
 932                 | Xsource4 Xsource4 |
 933                         REMEXTANDLOC
 934                         allocate(REG)
 935                         "divl3\t%[1],%[2],%[a]"
 936                         "mull2\t%[1],%[a]"
 937                         "subl3\t%[a],%[2],$3(%(regvar($2)%))"
 938                         setcc({displ4,regvar($2),tostring($3)}) |       | |
 939 #endif /* REGVARS */
 940 rmi sil $1==4 && $2<0
 941                 | Xsource4 Xsource4 |
 942                         REMEXTANDLOC
 943                         allocate(REG)
 944                         "divl3\t%[1],%[2],%[a]"
 945                         "mull2\t%[1],%[a]"
 946                         "subl3\t%[a],%[2],*$2(fp)"
 947                         setcc({displdef4,LB,tostring($2)})      |       | |
 948 rmi sil $1==4 && $2>=0
 949                 | Xsource4 Xsource4 |
 950                         REMEXTANDLOC
 951                         allocate(REG)
 952                         "divl3\t%[1],%[2],%[a]"
 953                         "mull2\t%[1],%[a]"
 954                         "subl3\t%[a],%[2],*$2(ap)"
 955                         setcc({displdef4,AP,tostring($2)})      |       | |
 956 rmi ste $1==4   | Xsource4 Xsource4 |
 957                         remove(externals)
 958                         allocate(REG)
 959                         "divl3\t%[1],%[2],%[a]"
 960                         "mull2\t%[1],%[a]"
 961                         "subl3\t%[a],%[2],$2"
 962                         setcc({EXTERNAL4,$2})                   |       | |
 963 rmi !defined($1) | source4 |
 964                         remove(ALL)
 965                         move(%[1],R0)
 966                         "jsb\t.rmi"
 967                         erase(R0)                               |       | |
 968 ngi $1==4       | source4 |
 969                         allocate(%[1],REG)
 970                         "mnegl\t%[1],%[a]"
 971                         setcc(%[a])                             | %[a]  | |
 972 #ifdef REGVARS
 973 ngi stl $1==4 && inreg($2)==2
 974                 | source4 |
 975                         remove(regvar($2))
 976                         "mnegl\t%[1],%(regvar($2)%)"
 977                         erase(regvar($2))
 978                         setcc(regvar($2))               |       | |
 979 #endif /* REGVARS */
 980 ngi stl $1==4 && $2<0
 981                 | source4 |
 982                         remove(displaced)
 983                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 984                         "mnegl\t%[1],$2(fp)"
 985                         setcc({LOCAL4,LB,$2,4})         |       | |
 986 ngi stl $1==4 && $2>=0
 987                 | source4 |
 988                         remove(displaced)
 989                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
 990                         "mnegl\t%[1],$2(ap)"
 991                         setcc({LOCAL4,AP,$2,4})         |       | |
 992 #ifdef REGVARS
 993 ngi sil $1==4 && inreg($2)==2
 994                 | source4 |
 995                         REMEXTANDLOC
 996                         "mnegl\t%[1],(%(regvar($2)%))"
 997                         setcc({regdef4,regvar($2)})     |       | |
 998 ngi lol stf $1==4 && inreg($2)==2
 999                 | source4 |
1000                         REMEXTANDLOC
1001                         "mnegl\t%[1],$3(%(regvar($2)%))"
1002                         setcc({displ4,regvar($2),tostring($3)}) |       | |
1003 #endif /* REGVARS */
1004 ngi sil $1==4 && $2<0
1005                 | source4 |
1006                         REMEXTANDLOC
1007                         "mnegl\t%[1],*$2(fp)"
1008                         setcc({displdef4,LB,tostring($2)})      |       | |
1009 ngi sil $1==4 && $2>=0
1010                 | source4 |
1011                         REMEXTANDLOC
1012                         "mnegl\t%[1],*$2(ap)"
1013                         setcc({displdef4,AP,tostring($2)})      |       | |
1014 ngi ste $1==4   | source4 |
1015                         remove(externals)
1016                         "mnegl\t%[1],$2"
1017                         setcc({EXTERNAL4,$2})                   |       | |
1018 ngi !defined($1) | source4 |
1019                         remove(ALL)
1020                         move(%[1],R0)
1021                         "jsb\t.ngi"                              |       | |
1022 sli $1==4       | source1or2or4 source4 |
1023                         allocate(%[1],%[2],REG)
1024                         "ashl\t%[1],%[2],%[a]"
1025                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
1026 #ifdef REGVARS
1027 sli stl $1==4 && inreg($2)==2
1028                 | source1or2or4 source4 |
1029                         remove(regvar($2))
1030                         "ashl\t%[1],%[2],%(regvar($2)%)"
1031                         erase(regvar($2))
1032                         setcc(regvar($2))       |       | |
1033 #endif /* REGVARS */
1034 sli stl $1==4 && $2<0
1035                 | source1or2or4 source4 |
1036                         remove(displaced)
1037                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
1038                         "ashl\t%[1],%[2],$2(fp)"
1039                         setcc({LOCAL4,LB,$2,4}) |       | |
1040 sli stl $1==4 && $2>=0
1041                 | source1or2or4 source4 |
1042                         remove(displaced)
1043                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
1044                         "ashl\t%[1],%[2],$2(ap)"
1045                         setcc({LOCAL4,AP,$2,4}) |       | |
1046 #ifdef REGVARS
1047 sli sil $1==4 && inreg($2)==2
1048                 | source1or2or4 source4 |
1049                         REMEXTANDLOC
1050                         "ashl\t%[1],%[2],(%(regvar($2)%))"
1051                         setcc({regdef4,regvar($2)})     |       | |
1052 sli lol stf $1==4 && inreg($2)==2
1053                 | source1or2or4 source4 |
1054                         REMEXTANDLOC
1055                         "ashl\t%[1],%[2],$3(%(regvar($2)%))"
1056                         setcc({displ4,regvar($2),tostring($3)}) |       | |
1057 #endif /* REGVARS */
1058 sli sil $1==4 && $2<0
1059                 | source1or2or4 source4 |
1060                         REMEXTANDLOC
1061                         "ashl\t%[1],%[2],*$2(fp)"
1062                         setcc({displdef4,LB,tostring($2)})      |       | |
1063 sli sil $1==4 && $2>=0
1064                 | source1or2or4 source4 |
1065                         REMEXTANDLOC
1066                         "ashl\t%[1],%[2],*$2(ap)"
1067                         setcc({displdef4,AP,tostring($2)})      |       | |
1068 sli ste $1==4   | source1or2or4 source4 |
1069                         remove(externals)
1070                         "ashl\t%[1],%[2],$2"
1071                         setcc({EXTERNAL4,$2})   |       | | (8,10)+%[1]+%[2]
1072 sli !defined($1) | source1or2or4 |
1073                         remove(ALL)
1074                         move(%[1],R0)
1075                         "jsb\t.sli"
1076                         erase(R0)                               |       | |
1077 sri $1==4       | source4 source4 |
1078                         allocate(%[1],REG)
1079                         "mnegl\t%[1],%[a]"
1080                         "ashl\t%[a],%[2],%[a]"
1081                         setcc(%[a])             | %[a]  | | (7,8)+%[1]+%[2]
1082 ...             | NC CONST source4 |
1083                         allocate(%[2],REG)
1084                         "ashl\t$$%(0-%[1.num]%),%[2],%[a]"
1085                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
1086 #ifdef REGVARS
1087 sri stl $1==4 && inreg($2)==2
1088                 | source4 source4 |
1089                         remove(regvar($2))
1090                         allocate(%[1],REG)
1091                         "mnegl\t%[1],%[a]"
1092                         "ashl\t%[a],%[2],%(regvar($2)%)"
1093                         erase(regvar($2))
1094                         setcc(regvar($2))       |       | | (9,14)+%[1]+%[2]
1095 ...             | NC CONST source4 |
1096                         remove(regvar($2))
1097                         "ashl\t$$%(0-%[1.num]%),%[2],%(regvar($2)%)"
1098                         erase(regvar($2))
1099                         setcc(regvar($2))       |       | | (6,10)+%[1]+%[2]
1100 #endif /* REGVARS */
1101 sri stl $1==4 && $2<0
1102                 | source4 source4 |
1103                         remove(displaced)
1104                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
1105                         allocate(%[1],REG)
1106                         "mnegl\t%[1],%[a]"
1107                         "ashl\t%[a],%[2],$2(fp)"
1108                         setcc({LOCAL4,LB,$2,4}) |       | | (9,11)+%[1]+%[2]
1109 ...             | NC CONST source4 |
1110                         remove(displaced)
1111                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
1112                         "ashl\t$$%(0-%[1.num]%),%[2],$2(fp)"
1113                         setcc({LOCAL4,LB,$2,4}) |       | | (6,7)+%[1]+%[2]
1114 sri stl $1==4 && $2>=0
1115                 | source4 source4 |
1116                         remove(displaced)
1117                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
1118                         allocate(%[1],REG)
1119                         "mnegl\t%[1],%[a]"
1120                         "ashl\t%[a],%[2],$2(ap)"
1121                         setcc({LOCAL4,AP,$2,4}) |       | | (9,11)+%[1]+%[2]
1122 ...             | NC CONST source4 |
1123                         remove(displaced)
1124                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
1125                         "ashl\t$$%(0-%[1.num]%),%[2],$2(ap)"
1126                         setcc({LOCAL4,AP,$2,4}) |       | | (6,7)+%[1]+%[2]
1127 #ifdef REGVARS
1128 sri sil $1==4 && inreg($2)==2
1129                 | source4 source4 |
1130                         REMEXTANDLOC
1131                         allocate(%[1],REG)
1132                         "mnegl\t%[1],%[a]"
1133                         "ashl\t%[a],%[2],(%(regvar($2)%))"
1134                         setcc({regdef4,regvar($2)}) |   | | (9,14)+%[1]+%[2]
1135 ...             | NC CONST source4 |
1136                         REMEXTANDLOC
1137                         "ashl\t$$%(0-%[1.num]%),%[2],(%(regvar($2)%))"
1138                         setcc({regdef4,regvar($2)}) |   | | (6,10)+%[1]+%[2]
1139 sri lol stf $1==4 && inreg($2)==2
1140                 | source4 source4 |
1141                         REMEXTANDLOC
1142                         allocate(%[1], REG)
1143                         "mnegl\t%[1],%[a]"
1144                         "ashl\t%[a],%[2],$3(%(regvar($2)%))"
1145                         setcc({displ4,regvar($2),tostring($3)}) |       | | (9,14)+%[1]+%[2]
1146 ...             | NC CONST source4 |
1147                         REMEXTANDLOC
1148                         "ashl\t$$%(0-%[1.num]%),%[2],$3(%(regvar($2)%))"
1149                         setcc({displ4,regvar($2),tostring($3)}) |       | | (6,10)+%[1]+%[2]
1150 #endif /* REGVARS */
1151 sri sil $1==4 && $2<0
1152                 | source4 source4 |
1153                         REMEXTANDLOC
1154                         allocate(%[1],REG)
1155                         "mnegl\t%[1],%[a]"
1156                         "ashl\t%[a],%[2],*$2(fp)"
1157                         setcc({displdef4,LB,tostring($2)})
1158                                                 |       | | (9,17)+%[1]+%[2]
1159 ...             | NC CONST source4 |
1160                         REMEXTANDLOC
1161                         "ashl\t$$%(0-%[1.num]%),%[2],*$2(fp)"
1162                         setcc({displdef4,LB,tostring($2)})
1163                                                 |       | | (6,13)+%[1]+%[2]
1164 sri sil $1==4 && $2>=0
1165                 | source4 source4 |
1166                         REMEXTANDLOC
1167                         allocate(%[1],REG)
1168                         "mnegl\t%[1],%[a]"
1169                         "ashl\t%[a],%[2],*$2(ap)"
1170                         setcc({displdef4,AP,tostring($2)})
1171                                                 |       | | (9,17)+%[1]+%[2]
1172 ...             | NC CONST source4 |
1173                         REMEXTANDLOC
1174                         "ashl\t$$%(0-%[1.num]%),%[2],*$2(ap)"
1175                         setcc({displdef4,AP,tostring($2)})
1176                                                 |       | | (6,13)+%[1]+%[2]
1177 sri ste $1==4   | source4 source4 |
1178                         remove(externals)
1179                         allocate(%[1],REG)
1180                         "mnegl\t%[1],%[a]"
1181                         "ashl\t%[a],%[2],$2"
1182                         setcc({EXTERNAL4,$2})   |       | | (11,14)+%[1]+%[2]
1183 ...             | NC CONST source4 |
1184                         remove(externals)
1185                         "ashl\t$$%(0-%[1.num]%),%[2],$2"
1186                         setcc({EXTERNAL4,$2})   |       | | (8,10)+%[1]+%[2]
1187 sri !defined($1) | source4 |
1188                         remove(ALL)
1189                         move(%[1],R0)
1190                         "jsb\t.sri"
1191                         erase(R0)                               |       | |
1192
1193 /************************************************
1194  * Group 4 : Unsigned arithmetic                *
1195  ************************************************/
1196
1197 adu             | |                             |       | adi $1 |
1198 sbu             | |                             |       | sbi $1 |
1199 mlu             | |                             |       | mli $1 |
1200 dvu $1==4       | STACK |
1201                         "jsb\t.dvu4"            | R0    | |
1202 dvu !defined($1) | source1or2or4 |
1203                         remove(ALL)
1204                         move(%[1],R0)
1205                         "jsb\t.dvu"
1206                         erase(R0)                       |       | |
1207 rmu $1==4       | STACK |
1208                         "jsb\t.rmu4"                    | R0    | |
1209 rmu !defined($1) | source1or2or4 |
1210                         remove(ALL)
1211                         move(%[1],R0)
1212                         "jsb\t.rmu"
1213                         erase(R0)                       |       | |
1214 slu             | |                                     | | sli $1 |
1215 loc slu         | |                                     | | loc $1 sli $2 |
1216 sru $1==4       | source4 source4 |
1217                         allocate(%[1],REG,QREG)
1218                         "mnegl\t%[1],%[a]"
1219                         move(%[2],%[b.1])
1220                         move({CONST4,0},%[b.2])
1221                         "ashq\t%[a],%[b],%[b]"
1222                         erase(%[b])             | %[b.1] | | (10,12)+%[1]
1223 ...             | NC CONST source4 |
1224                         allocate(%[2],QREG)
1225                         move(%[2],%[a.1])
1226                         move({CONST4,0},%[a.2])
1227                         "ashq\t$$%(0-%[1.num]%),%[a],%[a]"
1228                         erase(%[a])             | %[a.1] | | (4,4)+%[1]
1229 sru !defined($1) | source1or2or4 |
1230                         remove(ALL)
1231                         move(%[1],R0)
1232                         "jsb\t.sru"
1233                         erase(R0)                       |       | |
1234
1235 /****************************************
1236  * Group 5 : Floating point arithmetic  *
1237  ****************************************/
1238
1239 adf $1==4       | source4 source4 |
1240                         allocate(%[1],%[2],REG)
1241                         "addf3\t%[1],%[2],%[a]"
1242                         setcc(%[a])             | %[a]  | | (4,8)+%[1]+%[2]
1243 #ifdef FLOAT4
1244 ...             | source4 sreg4 |
1245                         "addf2\t%[1],%[2]"
1246                         erase(%[2])
1247                         setcc(%[2])             | %[2]  | | (3,8) + %[1]
1248 ...             | sreg4 source4 |
1249                         "addf2\t%[2],%[1]"
1250                         erase(%[1])
1251                         setcc(%[1])             | %[1]  | | (3,8) + %[2]
1252 #ifdef REGVARS
1253 adf stl $1==4 && inreg($2)==2
1254                 | source4 source4 |
1255                         remove(regvar($2))
1256                         "addf3\t%[1],%[2],%(regvar($2)%)"
1257                         erase(regvar($2))       |       | |
1258 #endif /* REGVARS */
1259 adf stl $1==4 && $2<0
1260                 | source4 source4 |
1261                         remove(displaced)
1262                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1263                         "addf3\t%[1],%[2],$2(fp)"
1264                         setcc({LOCAL4,LB,$2,4}) |          | |
1265 adf stl $1==4 && $2>=0
1266                 | source4 source4 |
1267                         remove(displaced)
1268                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1269                         "addf3\t%[1],%[2],$2(ap)"
1270                         setcc({LOCAL4,AP,$2,4}) |          | |
1271 #ifdef REGVARS
1272 adf sil $1==4 && inreg($2)==2
1273                 | source4 source4 |
1274                         remove(regvar($2))
1275                         "addf3\t%[1],%[2],(%(regvar($2)%))"
1276                         setcc(regvar($2))       |       | |
1277 #endif /* REGVARS */
1278 adf sil $1==4 && $2<0
1279                 | source4 source4 |
1280                         REMEXTANDLOC
1281                         "addf3\t%[1],%[2],*$2(fp)"
1282                         setcc({displdef4,LB,tostring($2)})      |       | |
1283 adf sil $1==4 && $2>=0
1284                 | source4 source4 |
1285                         REMEXTANDLOC
1286                         "addf3\t%[1],%[2],*$2(ap)"
1287                         setcc({displdef4,AP,tostring($2)})      |       | |
1288 adf ste $1==4   | source4 source4 |
1289                         remove(externals)
1290                         "addf3\t%[1],%[2],$2"
1291                         setcc({EXTERNAL4,$2})   |       | |
1292 #endif /* FLOAT4 */
1293 adf $1==8       | source8 source8 |
1294                         allocate(%[1],%[2],QREG)
1295                         "addd3\t%[1],%[2],%[a]"
1296                         setcc(%[a])             | %[a]  | | (4,14)+%[1]+%[2]
1297 #ifdef FLOAT8
1298 ...             | source8 sreg8 |
1299                         "addd2\t%[1],%[2]"
1300                         erase(%[2])
1301                         setcc(%[2])             | %[2]  | | (3,14) + %[1]
1302 ...             | sreg8 source8 |
1303                         "addd2\t%[2],%[1]"
1304                         erase(%[1])
1305                         setcc(%[1])             | %[1]  | | (3,14) + %[2]
1306 adf sdl $1==8 && $2<0
1307                 | source8 source8 |
1308                         remove(displaced)
1309                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1310                         "addd3\t%[1],%[2],$2(fp)"
1311                         setcc({LOCAL8,LB,$2,8})    |       | |
1312 adf sdl $1==8 && $2>=0
1313                 | source8 source8 |
1314                         remove(displaced)
1315                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1316                         "addd3\t%[1],%[2],$2(ap)"
1317                         setcc({LOCAL8,AP,$2,8})    |       | |
1318 adf sde $1==8   | source8 source8 |
1319                         remove(externals)
1320                         "addd3\t%[1],%[2],$2"
1321                         setcc({EXTERNAL8,$2})   |       | |
1322 #endif /* FLOAT8 */
1323 adf !defined($1) | source4 |
1324                         remove(ALL)
1325                         move(%[1],R0)
1326                         "jsb\t.adf"              |       | |
1327 sbf $1==4       | source4 source4 |
1328                         allocate(%[1],%[2],REG)
1329                         "subf3\t%[1],%[2],%[a]"
1330                         setcc(%[a])             | %[a]  | | (4,8)+%[1]+%[2]
1331 #ifdef FLOAT4
1332 ...             | NC source4 sreg4 |
1333                         "subf2\t%[1],%[2]"
1334                         erase(%[2])
1335                         setcc(%[2])             | %[2]  | | (3,8) + %[1]
1336 #ifdef REGVARS
1337 sbf stl $1==4 && inreg($2)==2
1338                 | source4 source4 |
1339                         remove(regvar($2))
1340                         "subf3\t%[1],%[2],%(regvar($2)%)"
1341                         erase(regvar($2))
1342                         setcc(regvar($2))       |       | |
1343 #endif /* REGVARS */
1344 sbf stl $1==4 && $2<0
1345                 | source4 source4 |
1346                         remove(displaced)
1347                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1348                         "subf3\t%[1],%[2],$2(fp)"
1349                         setcc({LOCAL4,LB,$2,4})    |    | |
1350 sbf stl $1==4 && $2>=0
1351                 | source4 source4 |
1352                         remove(displaced)
1353                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1354                         "subf3\t%[1],%[2],$2(ap)"
1355                         setcc({LOCAL4,AP,$2,4}) |       | |
1356 #ifdef REGVARS
1357 sbf sil $1==4 && inreg($2)==2
1358                 | source4 source4 |
1359                         remove(regvar($2))
1360                         "subf3\t%[1],%[2],(%(regvar($2)%))"
1361                         setcc(regvar($2))       |       | |
1362 #endif /* REGVARS */
1363 sbf sil $1==4 && $2<0
1364                 | source4 source4 |
1365                         REMEXTANDLOC
1366                         "subf3\t%[1],%[2],*$2(fp)"
1367                         setcc({displdef4,LB,tostring($2)})      |       | |
1368 sbf sil $1==4 && $2>=0
1369                 | source4 source4 |
1370                         REMEXTANDLOC
1371                         "subf3\t%[1],%[2],*$2(ap)"
1372                         setcc({displdef4,AP,tostring($2)})      |       | |
1373 sbf ste $1==4   | source4 source4 |
1374                         remove(externals)
1375                         "subf3\t%[1],%[2],$2"
1376                         setcc({EXTERNAL4,$2})   |       | |
1377 #endif /* FLOAT4 */
1378 sbf $1==8       | source8 source8 |
1379                         allocate(%[1],%[2],QREG)
1380                         "subd3\t%[1],%[2],%[a]"
1381                         setcc(%[a])             | %[a]  | | (4,14)+%[1]+%[2]
1382 #ifdef FLOAT8
1383 ...             | source8 sreg8 |
1384                         "subd2\t%[1],%[2]"
1385                         erase(%[2])
1386                         setcc(%[2])             | %[2]  | | (3,14) + %[1]
1387 sbf sdl $1==8 && $2<0
1388                 | source8 source8 |
1389                         remove(displaced)
1390                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1391                         "subd3\t%[1],%[2],$2(fp)"
1392                         setcc({LOCAL8,LB,$2,8})    |       | |
1393 sbf sdl $1==8 && $2>=0
1394                 | source8 source8 |
1395                         remove(displaced)
1396                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1397                         "subd3\t%[1],%[2],$2(ap)"
1398                         setcc({LOCAL8,AP,$2,8})    |       | |
1399 sbf sde $1==8   | source8 source8 |
1400                         remove(externals)
1401                         "subd3\t%[1],%[2],$2"
1402                         setcc({EXTERNAL8,$2})   |       | |
1403 #endif /* FLOAT8 */
1404 sbf !defined($1) | source1or2or4 |
1405                         remove(ALL)
1406                         move(%[1],R0)
1407                         "jsb\t.sbf"              |       | |
1408 mlf $1==4       | source4 source4 |
1409                         allocate(%[1],%[2],REG)
1410                         "mulf3\t%[1],%[2],%[a]"
1411                         setcc(%[a])             | %[a]  | | (4,12)+%[1]+%[2]
1412 #ifdef FLOAT4
1413 ...             | source4 sreg4 |
1414                         "mulf2\t%[1],%[2]"
1415                         erase(%[2])
1416                         setcc(%[2])             | %[2]  | | (3,12) + %[1]
1417 ...             | sreg4 source4 |
1418                         "mulf2\t%[2],%[1]"
1419                         erase(%[1])
1420                         setcc(%[1])             | %[1]  | | (3,12) + %[2]
1421 #ifdef REGVARS
1422 mlf stl $1==4 && inreg($2)==2
1423                 | source4 source4 |
1424                         remove(regvar($2))
1425                         "mulf3\t%[1],%[2],%(regvar($2)%)"
1426                         erase(regvar($2))       |       | |
1427 #endif /* REGVARS */
1428 mlf stl $1==4 && $2<0
1429                 | source4 source4 |
1430                         remove(displaced)
1431                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1432                         "mulf3\t%[1],%[2],$2(fp)"
1433                         setcc({LOCAL4,LB,$2,4}) |          | |
1434 mlf stl $1==4 && $2>=0
1435                 | source4 source4 |
1436                         remove(displaced)
1437                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1438                         "mulf3\t%[1],%[2],$2(ap)"
1439                         setcc({LOCAL4,AP,$2,4}) |       | |
1440 #ifdef REGVARS
1441 mlf sil $1==4 && inreg($2)==2
1442                 | source4 source4 |
1443                         remove(regvar($2))
1444                         "mulf3\t%[1],%[2],(%(regvar($2)%))"
1445                         setcc(regvar($2))       |       | |
1446 #endif /* REGVARS */
1447 mlf sil $1==4 && $2<0
1448                 | source4 source4 |
1449                         REMEXTANDLOC
1450                         "mulf3\t%[1],%[2],*$2(fp)"
1451                         setcc({displdef4,LB,tostring($2)})      |          | |
1452 mlf sil $1==4 && $2>=0
1453                 | source4 source4 |
1454                         REMEXTANDLOC
1455                         "mulf3\t%[1],%[2],*$2(ap)"
1456                         setcc({displdef4,AP,tostring($2)})      |          | |
1457 mlf ste $1==4   | source4 source4 |
1458                         remove(externals)
1459                         "mulf3\t%[1],%[2],$2"
1460                         setcc({EXTERNAL4,$2})   |       | |
1461 #endif /* FLOAT4 */
1462 mlf $1==8       | source8 source8 |
1463                         allocate(%[1],%[2],QREG)
1464                         "muld3\t%[1],%[2],%[a]"
1465                         setcc(%[a])             | %[a]  | | (4,20)+%[1]+%[2]
1466 #ifdef FLOAT8
1467 ...             | source8 sreg8 |
1468                         "muld2\t%[1],%[2]"
1469                         erase(%[2])
1470                         setcc(%[2])             | %[2]  | | (3,20) + %[1]
1471 ...             | sreg8 source8 |
1472                         "muld2\t%[2],%[1]"
1473                         erase(%[1])
1474                         setcc(%[1])             | %[1]  | | (3,20) + %[2]
1475 mlf sdl $1==8 && $2<0
1476                 | source8 source8 |
1477                         remove(displaced)
1478                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1479                         "muld3\t%[1],%[2],$2(fp)"
1480                         setcc({LOCAL8,LB,$2,8}) |          | |
1481 mlf sdl $1==8 && $2>=0
1482                 | source8 source8 |
1483                         remove(displaced)
1484                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1485                         "muld3\t%[1],%[2],$2(ap)"
1486                         setcc({LOCAL8,AP,$2,8}) |          | |
1487 mlf sde $1==8   | source8 source8 |
1488                         remove(externals)
1489                         "muld3\t%[1],%[2],$2"
1490                         setcc({EXTERNAL8,$2})   |       | |
1491 #endif /* FLOAT8 */
1492 mlf !defined($1) | source1or2or4 |
1493                         remove(ALL)
1494                         move(%[1],R0)
1495                         "jsb\t.mlf"              |       | |
1496 dvf $1==4       | source4 source4 |
1497                         allocate(%[1],%[2],REG)
1498                         "divf3\t%[1],%[2],%[a]"
1499                         setcc(%[a])             | %[a]  | | (4,46)+%[1]+%[2]
1500 #ifdef FLOAT4
1501 ...             | source4 sreg4 |
1502                         "divf2\t%[1],%[2]"
1503                         erase(%[2])
1504                         setcc(%[2])             | %[2]  | | (3,46) + %[1]
1505 #ifdef REGVARS
1506 dvf stl $1==4 && inreg($2)==2
1507                 | source4 source4 |
1508                         remove(regvar($2))
1509                         "divf3\t%[1],%[2],%(regvar($2)%)"
1510                         erase(regvar($2))
1511                         setcc(regvar($2))       |       | |
1512 #endif /* REGVARS */
1513 dvf stl $1==4 && $2<0
1514                 | source4 source4 |
1515                         remove(displaced)
1516                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1517                         "divf3\t%[1],%[2],$2(fp)"
1518                         setcc({LOCAL4,LB,$2,4}) |          | |
1519 dvf stl $1==4 && $2>=0
1520                 | source4 source4 |
1521                         remove(displaced)
1522                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1523                         "divf3\t%[1],%[2],$2(ap)"
1524                         setcc({LOCAL4,AP,$2,4}) |          | |
1525 #ifdef REGVARS
1526 dvf sil $1==4 && inreg($2)==2
1527                 | source4 source4 |
1528                         remove(regvar($2))
1529                         "divf3\t%[1],%[2],(%(regvar($2)%))"
1530                         setcc(regvar($2))               |          | |
1531 #endif /* REGVARS */
1532 dvf sil $1==4 && $2<0
1533                 | source4 source4 |
1534                         REMEXTANDLOC
1535                         "divf3\t%[1],%[2],*$2(fp)"
1536                         setcc({displdef4,LB,tostring($2)})      |          | |
1537 dvf sil $1==4 &&$2>=0
1538                 | source4 source4 |
1539                         REMEXTANDLOC
1540                         "divf3\t%[1],%[2],*$2(ap)"
1541                         setcc({displdef4,AP,tostring($2)})      |          | |
1542 dvf ste $1==4   | source4 source4 |
1543                         remove(externals)
1544                         "divf3\t%[1],%[2],$2"
1545                         setcc({EXTERNAL4,$2})   |       | |
1546 #endif /* FLOAT4 */
1547 dvf $1==8       | source8 source8 |
1548                         allocate(%[1],%[2],QREG)
1549                         "divd3\t%[1],%[2],%[a]"
1550                         setcc(%[a])             | %[a]  | | (4,80)+%[1]+%[2]
1551 #ifdef FLOAT8
1552 ...             | source8 sreg8 |
1553                         "divd2\t%[1],%[2]"
1554                         erase(%[2])
1555                         setcc(%[2])             | %[2]  | | (3,80) + %[1]
1556 dvf sdl $1==8 && $2<0
1557                 | source8 source8 |
1558                         remove(displaced)
1559                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1560                         "divd3\t%[1],%[2],$2(fp)"
1561                         setcc({LOCAL8,LB,$2,8}) |          | |
1562 dvf sdl $1==8 && $2>=0
1563                 | source8 source8 |
1564                         remove(displaced)
1565                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1566                         "divd3\t%[1],%[2],$2(ap)"
1567                         setcc({LOCAL8,AP,$2,8}) |          | |
1568 dvf sde $1==8   | source8 source8 |
1569                         remove(externals)
1570                         "divd3\t%[1],%[2],$2"
1571                         setcc({EXTERNAL8,$2})   |       | |
1572 #endif /* FLOAT8 */
1573 dvf !defined($1) | source1or2or4 |
1574                         remove(ALL)
1575                         move(%[1],R0)
1576                         "jsb\t.dvf"              |       | |
1577 ngf $1==4       | source4 |
1578                         allocate(%[1],REG)
1579                         "mnegf\t%[1],%[a]"
1580                         setcc(%[a])             | %[a]  | |
1581 #ifdef FLOAT4
1582 #ifdef REGVARS
1583 ngf stl $1==4 && inreg($2)==2
1584                 | source4 |
1585                         remove(regvar($2))
1586                         "mnegf\t%[1],%(regvar($2)%)"
1587                         erase(regvar($2))
1588                         setcc(regvar($2))       |       | |
1589 #endif /* REGVARS */
1590 ngf stl $1==4 && $2<0
1591                 | source4 |
1592                         remove(displaced)
1593                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1594                         "mnegf\t%[1],$2(fp)"
1595                         setcc({LOCAL4,LB,$2,4}) |          | |
1596 ngf stl $1==4 && $2>=0
1597                 | source4 |
1598                         remove(displaced)
1599                         remove(LOCALS,%[num] <= $2+3 && %[num]+%[size] > $2)
1600                         "mnegf\t%[1],$2(ap)"
1601                         setcc({LOCAL4,AP,$2,4}) |          | |
1602 #ifdef REGVARS
1603 ngf sil $1==4 && inreg($2)==2
1604                 | source4 |
1605                         remove(regvar($2))
1606                         "mnegf\t%[1],(%(regvar($2)%))"
1607                         setcc(regvar($2))       |          | |
1608 #endif /* REGVARS */
1609 ngf sil $1==4 && $2<0
1610                 | source4 |
1611                         REMEXTANDLOC
1612                         "mnegf\t%[1],*$2(fp)"
1613                         setcc({displdef4,LB,tostring($2)})      |          | |
1614 ngf sil $1==4 && $2>=0
1615                 | source4 |
1616                         REMEXTANDLOC
1617                         "mnegf\t%[1],*$2(ap)"
1618                         setcc({displdef4,AP,tostring($2)})      |          | |
1619 ngf ste $1==4   | source4 |
1620                         remove(externals)
1621                         "mnegf\t%[1],$2"
1622                         setcc({EXTERNAL4,$2})   |       | |
1623 #endif /* FLOAT4 */
1624 ngf $1==8       | source8 |
1625                         allocate(%[1],QREG)
1626                         "mnegd\t%[1],%[a]"
1627                         setcc(%[a])             | %[a]  | |
1628 #ifdef FLOAT8
1629 ngf sdl $1==8 && $2<0
1630                 | source8 |
1631                         remove(displaced)
1632                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1633                         "mnegd\t%[1],$2(fp)"
1634                         setcc({LOCAL8,LB,$2,8}) |          | |
1635 ngf sdl $1==8 && $2>=0
1636                 | source8 |
1637                         remove(displaced)
1638                         remove(LOCALS,%[num] <= $2+7 && %[num]+%[size] > $2)
1639                         "mnegd\t%[1],$2(ap)"
1640                         setcc({LOCAL8,AP,$2,8}) |          | |
1641 ngf sde $1==8   | source8 |
1642                         remove(externals)
1643                         "mnegd\t%[1],$2"
1644                         setcc({EXTERNAL8,$2})   |       | |
1645 #endif /* FLOAT8 */
1646 ngf !defined($1) | source1or2or4 |
1647                         remove(ALL)
1648                         move(%[1],R0)
1649                         "jsb\t.ngf"              |       | |
1650 fif $1==4       | source4 source4 |
1651                         allocate(%[1],%[2],REG,REG)
1652                         "mulf3\t%[1],%[2],%[a]"
1653                         /* the assembler does not do immediate floating point */
1654                         "cvtlf $$1,%[b]"
1655                         "emodf\t%[a],$$0,%[b],-(sp),%[b]"
1656                         /*
1657                          * Don't trust the integer part.
1658                          * Overflow could occur.
1659                          */
1660                         "tstl\t(sp)+"
1661                         "subf2\t%[b],%[a]"      | %[b] %[a]     | |
1662 fif $1==8       | source8 source8 |
1663                         allocate(%[1],%[2],QREG,QREG)
1664                         "muld3\t%[1],%[2],%[a]"
1665                         "cvtld $$1,%[b]"
1666                         "emodd\t%[a],$$0,%[b],-(sp),%[b]"
1667                         "tstl\t(sp)+"
1668                         "subd2\t%[b],%[a]"      | %[b] %[a]     | |
1669 fif !defined($1) | source1or2or4 |
1670                         remove(ALL)
1671                         move(%[1],R0)
1672                         "jsb\t.fif"
1673                         erase(R0)               |       | |
1674 fef defined($1) | |
1675                         remove(ALL)
1676                         move({CONST4, $1}, R0)
1677                         "jsb\t.fef"
1678                         erase(R0)               |       | |
1679 fef !defined($1) | source1or2or4 |
1680                         remove(ALL)
1681                         move(%[1],R0)
1682                         "jsb\t.fef"
1683                         erase(R0)               |       | |
1684
1685 /********************************
1686  * Group 6 : pointer arithmetic *
1687  ********************************/
1688
1689 adp $1==0       | | | | |
1690 adp             | NC ADDR_EXTERNAL |
1691                         | {ADDR_EXTERNAL,%[1.ind]+"+"+tostring($1)} | |
1692 ...             | NC ADDR_LOCAL |
1693                         | {ADDR_LOCAL,%[1.reg],%[1.num]+$1} | |
1694 ...             | NC adisplind1 |
1695                         | {adisplind1,%[1.ireg],%[1.reg],
1696                                         %[1.ind]+"+"+tostring($1)} | |
1697 ...             | NC adispldefind1 |
1698                         allocate(%[1.ireg],REG)
1699                         "addl3\t$$$1,%[1.ireg],%[a]"
1700                         | {adispldefind1,%[a],%[1.reg],%[1.ind]}        | |
1701 ...             | NC aextdefind1 |
1702                         allocate(%[1],REG)
1703                         "addl3\t$$$1,%[1.ireg],%[a]"
1704                         | {aextdefind1,%[a],%[1.ind]}   | |
1705 ...             | NC adispl | | {adispl,%[1.reg],%[1.ind]+"+"+tostring($1)} | |
1706 ...             | reg4 |        | {adispl,%[1],tostring($1)}              | |
1707 adp sil         | | | {CONST4,$1}               | adi 4 sil $2 |
1708 adp stl         | | | {CONST4,$1}               | adi 4 stl $2 |
1709 adp ste         | | | {CONST4,$1}               | adi 4 ste $2 |
1710 adp dup $2==4   | | | {CONST4,$1}               | adi 4 dup 4 |
1711 adp lol stf     | | | {CONST4,$1}               | adi 4 lol $2 stf $3 |
1712 adp lol sti $3==4
1713                 | | | {CONST4,$1}               | adi 4 lol $2 sti 4 |
1714 adp loe sti $3==4
1715                 | | | {CONST4,$1}               | adi 4 loe $2 sti 4 |
1716 adp cms $2==4   | | | {CONST4,$1}               | adi 4 cms 4 |
1717 loe lof adp loe stf $1==$4 && $2==$5
1718                 | |     REMEXTANDLOC
1719                         allocate(REG={EXTERNAL4,$1})
1720                         "addl2\t$$$3,$2(%[a])"          |       | |
1721 lol lof adp lol stf $1<0 && $1==$4 && inreg($1)!=2 && $2==$5
1722                 | |     REMEXTANDLOC
1723                         allocate(REG={LOCAL4,LB,$1,4})
1724                         "addl2\t$$$3,$2(%[a])"          |       | |
1725 lol lof adp lol stf $1>=0 && $1==$4 && inreg($1)!=2 && $2==$5
1726                 | |     REMEXTANDLOC
1727                         allocate(REG={LOCAL4,AP,$1,4})
1728                         "addl2\t$$$3,$2(%[a])"          |       | |
1729 ads $1==4       | NC reg4 adispl |
1730                         | {adisplind1,%[1],%[2.reg],%[2.ind]}   | |
1731 ...             | NC reg4 ADDR_LOCAL |
1732                         | {adisplind1,%[1],%[2.reg],tostring(%[2.num])} | |
1733 ...             | NC reg4 ADDR_EXTERNAL |
1734                         | {adispl,%[1],%[2.ind]}                | |
1735 ...             | NC reg4 aextind2 |
1736                         | {adisplind2,%[2.ireg],%[1],%[2.ind]}  | |
1737 ...             | NC reg4 aextind4 |
1738                         | {adisplind4,%[2.ireg],%[1],%[2.ind]}  | |
1739 ...             | NC reg4 aextind8 |
1740                         | {adisplind8,%[2.ireg],%[1],%[2.ind]}  | |
1741 ...             | NC reg4 displ4 |
1742                         | {adispldefind1,%[1],%[2.reg],%[2.ind]}        | |
1743 ...             | NC reg4 LOCAL4 |
1744                         | {adispldefind1,%[1],%[2.reg],tostring(%[2.num])} | |
1745 ...             | NC reg4 regdef4 |
1746                         | {adispldefind1,%[1],%[2.reg],"0"}     | |
1747 ...             | NC reg4 EXTERNAL4 |
1748                         | {aextdefind1,%[1],%[2.ind]}           | |
1749 ...             | NC reg4 reg4 |        | {adisplind1,%[1],%[2],"0"}    | |
1750 ...             | |             |               | adi 4 |
1751 ads             | |             |               | loc $1 loc 4 cii ads 4 |
1752 ads !defined($1) | |            |               | loc 4 cii ads 4 |
1753 sbs $1==4       | |             |               | sbu $1 |
1754 sbs $1!=4       | |             |               | sbu 4 loc 4 loc $1 cii |
1755 sbs !defined($1) | source1or2or4 |
1756                         remove(ALL)
1757                         move(%[1],R0)
1758                         "jsb\t.sbs"
1759                         erase(R0)               |       | |
1760 adp dup sil adp $1==(0-$4) && $2==4
1761                 | reg4 | | %[1] %[1]    | adp $1 sil $3 |
1762 adp dup loe sti adp $1==(0-$5) && $2==4 && $4==4
1763                 | reg4 | | %[1] %[1]    | adp $1 loe $3 sti 4 |
1764 dup adp lol sti $1==4 && $4==4
1765                 | bigsource4-regch4 |
1766                         allocate(REG=%[1])
1767                         | %[a] %[1] {CONST4,$2}
1768                                 | adi 4 lol $3 sti 4 |
1769 dup adp loe sti $1==4 && $4==4
1770                 | bigsource4-regch4 |
1771                         allocate(REG=%[1])
1772                         | %[a] %[1] {CONST4,$2}
1773                                 | adi 4 loe $3 sti 4 |
1774 #ifdef REGVARS
1775 lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==1 && $5==1
1776                 | |     remove(regvar($1))
1777                         erase(regvar($1))
1778                         | {reginc1,regvar($1)}          | |
1779 lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==2 && $5==2
1780                 | |     remove(regvar($1))
1781                         erase(regvar($1))
1782                         | {reginc2,regvar($1)}          | |
1783 lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==4 && $5==4
1784                 | |     remove(regvar($1))
1785                         erase(regvar($1))
1786                         | {reginc4,regvar($1)}          | |
1787 lol dup adp stl loi $1==$4 && $2==4 && inreg($1)==2 && $3==8 && $5==8
1788                 | |     remove(regvar($1))
1789                         erase(regvar($1))
1790                         | {reginc8,regvar($1)}          | |
1791 lol adp dup stl loi $1==$4 && $2==(0-1) && inreg($1)==2 && $3==4 && $5==1
1792                 | |     remove(regvar($1))
1793                         erase(regvar($1))
1794                         | {regdec1,regvar($1)}          | |
1795 lol adp dup stl loi $1==$4 && $2==(0-2) && inreg($1)==2 && $3==4 && $5==2
1796                 | |     remove(regvar($1))
1797                         erase(regvar($1))
1798                         | {regdec2,regvar($1)}          | |
1799 lol adp stl lil $1==$4 && $2==(0-4) && inreg($1)==2 && $3==$1
1800                 | |     remove(regvar($1))
1801                         erase(regvar($1))
1802                         | {regdec4,regvar($1)}          | |
1803 lol adp dup stl loi $1==$4 && $2==(0-8) && inreg($1)==2 && $3==4 && $5==8
1804                 | |     remove(regvar($1))
1805                         erase(regvar($1))
1806                         | {regdec8,regvar($1)}          | |
1807 lol dup adp stl sti $1==$4 && $2==4 && inreg($1)==2 && $3==1 && $5==1
1808                 | NC source1 |
1809                         REMEXTANDLOC
1810                         remove(regvar($1))
1811                         "movb\t%[1],(%(regvar($1)%))+"
1812                         erase(regvar($1))               |       | | (3,7)+%[1]
1813 ...             | NC source2 |
1814                         REMEXTANDLOC
1815                         remove(regvar($1))
1816                         "cvtwb\t%[1],(%(regvar($1)%))+"
1817                         erase(regvar($1))               |       | | (3,7)+%[1]
1818 ...             | source4 |
1819                         REMEXTANDLOC
1820                         remove(regvar($1))
1821                         "cvtlb\t%[1],(%(regvar($1)%))+"
1822                         erase(regvar($1))               |       | | (3,7)+%[1]
1823 lol dup adp stl sti $1==$4 && $2==4 && inreg($1)==2 && $3==2 && $5==2
1824                 | NC source2 |
1825                         REMEXTANDLOC
1826                         remove(regvar($1))
1827                         "movw\t%[1],(%(regvar($1)%))+"
1828                         erase(regvar($1))               |       | | (3,7)+%[1]
1829 ...             | source4 |
1830                         REMEXTANDLOC
1831                         remove(regvar($1))
1832                         "cvtlw\t%[1],(%(regvar($1)%))+"
1833                         erase(regvar($1))               |       | | (3,7)+%[1]
1834 lol dup adp stl sti $1==$4 && $2==4 && inreg($1)==2 && $3==4 && $5==4
1835                 | source4 |
1836                         REMEXTANDLOC
1837                         remove(regvar($1))
1838                         move(%[1],{reginc4,regvar($1)})
1839                         erase(regvar($1))               |       | |
1840 lol dup adp stl sti $1==$4 && $2==4 && inreg($1)==2 && $3==8 && $5==8
1841                 | source8 |
1842                         REMEXTANDLOC
1843                         remove(regvar($1))
1844                         move(%[1],{reginc8,regvar($1)})
1845                         erase(regvar($1))               |       | |
1846 lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-1) && $3==4 && $5==1
1847                 | NC source1 |
1848                         REMEXTANDLOC
1849                         remove(regvar($1))
1850                         "movb\t%[1],-(%(regvar($1)%))"
1851                         erase(regvar($1))               |       | | (3,7)+%[1]
1852 ...             | NC source2 |
1853                         REMEXTANDLOC
1854                         remove(regvar($1))
1855                         "cvtwb\t%[1],-(%(regvar($1)%))"
1856                         erase(regvar($1))               |       | | (3,7)+%[1]
1857 ...             | source4 |
1858                         REMEXTANDLOC
1859                         remove(regvar($1))
1860                         "cvtlb\t%[1],-(%(regvar($1)%))"
1861                         erase(regvar($1))               |       | | (3,7)+%[1]
1862 lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-2) && $3==4 && $5==2
1863                 | NC source2 |
1864                         REMEXTANDLOC
1865                         remove(regvar($1))
1866                         "movw\t%[1],-(%(regvar($1)%))"
1867                         erase(regvar($1))               |       | | (3,7)+%[1]
1868 ...             | source4 |
1869                         REMEXTANDLOC
1870                         remove(regvar($1))
1871                         "cvtlw\t%[1],-(%(regvar($1)%))"
1872                         erase(regvar($1))               |       | | (3,7)+%[1]
1873 lol adp stl sil $1==$4 && inreg($1)==2 && $2==(0-4) && $3==$4
1874                 | source4 |
1875                         REMEXTANDLOC
1876                         remove(regvar($1))
1877                         move(%[1],{regdec4,regvar($1)})
1878                         erase(regvar($1))               |       | |
1879 lol adp dup stl sti $1==$4 && inreg($1)==2 && $2==(0-8) && $3==4 && $5==8
1880                 | source8 |
1881                         REMEXTANDLOC
1882                         remove(regvar($1))
1883                         move(%[1],{regdec8,regvar($1)})
1884                         erase(regvar($1))               |       | |
1885 lol dup adp stl $1==$4 && $2==4 && inreg($1)==2
1886                 | |     remove(regvar($1))
1887                         allocate(REG=regvar($1))
1888                         "addl2\t$$$3,%(regvar($1)%)"
1889                         erase(regvar($1))               | %[a]  | |
1890 lol adp stl $1==$3 && inreg($1)==2
1891                 | |     remove(regvar($1))
1892                         "addl2\t$$$2,%(regvar($1)%)"
1893                         erase(regvar($1))               |       | |
1894 #endif /* REGVARS */
1895 lol adp stl $1==$3 && $1<0
1896                 | |     remove(displaced)
1897                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
1898                         "addl2\t$$$2,$1(fp)"
1899                         setcc({LOCAL4,LB,$1,4}) |       | |
1900 lol adp stl $1==$3 && $1>=0
1901                 | |     remove(displaced)
1902                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
1903                         "addl2\t$$$2,$1(ap)"
1904                         setcc({LOCAL4,AP,$1,4}) |       | |
1905 lol dup adp stl $1==$4 && $2==4 && $1<0
1906                 | |     remove(displaced)
1907                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
1908                         allocate(REG={LOCAL4,LB,$1,4})
1909                         "addl2\t$$$3,$1(fp)"
1910                         setcc({LOCAL4,LB,$1,4}) | %[a]  | |
1911 lol dup adp stl $1==$4 && $2==4
1912                 | |     remove(displaced)
1913                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
1914                         allocate(REG={LOCAL4,AP,$1,4})
1915                         "addl2\t$$$3,$1(ap)"
1916                         setcc({LOCAL4,AP,$1,4}) | %[a]  | |
1917 #ifdef REGVARS
1918 lil dup adp sil $1==$4 && $2==4 && inreg($1)==2
1919                 | |     REMEXTANDLOC
1920                         allocate(REG={regdef4,regvar($1)})
1921                         "addl2\t$$$3,(%(regvar($1)%))"
1922                         setcc(regvar($1))       | %[a]  | |
1923 lol lof dup adp lol stf $1==$5 && $2==$6 && $3==4 && inreg($1)==2
1924                 | |     REMEXTANDLOC
1925                         allocate(REG={displ4,regvar($1),tostring($2)})
1926                         "addl2\t$$$4,$2(%(regvar($1)%))"
1927                                                 | %[a]  | |
1928 #endif
1929 loe adp ste $1==$3
1930                 | |     remove(externals)
1931                         "addl2\t$$$2,$1"        |               | |
1932 loe dup adp ste $1==$4 && $2==4
1933                 | |     remove(externals)
1934                         allocate(REG={EXTERNAL4,$1})
1935                         "addl2\t$$$3,$1"        | %[a]          | |
1936
1937 /****************************************
1938  * Group 7 : Increment/decrement/zero   *
1939  ****************************************/
1940
1941 lil inc dup sil $3==4 && $1==$4 | | | | lil $1 loc 1 adi 4 sil $1 lil $1 |
1942 lil dec dup sil $3==4 && $1==$4 | | | | lil $1 loc 1 sbi 4 sil $1 lil $1 |
1943 inc             |       |       | {CONST1,1}    | adi 4 |
1944 loe lof inc loe stf $1==$4 && $2==$5
1945                 | |     REMEXTANDLOC
1946                         allocate(REG={EXTERNAL4,$1})
1947                         "incl\t$2(%[a])"
1948                         setcc({displ4,%[a],tostring($2)})       |       | |
1949 lol lof inc lol stf $1<0 && $1==$4 && inreg($1)!=2 && $2==$5
1950                 | |     REMEXTANDLOC
1951                         allocate(REG={LOCAL4,LB,$1,4})
1952                         "incl\t$2(%[a])"
1953                         setcc({displ4,%[a],tostring($2)})       |       | |
1954 lol lof inc lol stf $1>=0 && $1==$4 && inreg($1)!=2 && $2==$5
1955                 | |     REMEXTANDLOC
1956                         allocate(REG={LOCAL4,AP,$1,4})
1957                         "incl\t$2(%[a])"
1958                         setcc({displ4,%[a],tostring($2)})       |       | |
1959 dec             |       |       | {CONST1,1}    | sbi 4 |
1960 loe lof dec loe stf $1==$4 && $2==$5
1961                 | |     REMEXTANDLOC
1962                         allocate(REG={EXTERNAL4,$1})
1963                         "decl\t$2(%[a])"
1964                         setcc({displ4,%[a],tostring($2)})       |       | |
1965 lol lof dec lol stf $1<0 && $1==$4 && inreg($1)!=2 && $2==$5
1966                 | |     REMEXTANDLOC
1967                         allocate(REG={LOCAL4,LB,$1,4})
1968                         "decl\t$2(%[a])"
1969                         setcc({displ4,%[a],tostring($2)})       |       | |
1970 lol lof dec lol stf $1>=0 && $1==$4 && inreg($1)!=2 && $2==$5
1971                 | |     REMEXTANDLOC
1972                         allocate(REG={LOCAL4,AP,$1,4})
1973                         "decl\t$2(%[a])"
1974                         setcc({displ4,%[a],tostring($2)})       |       | |
1975 #ifdef REGVARS
1976 inl inreg($1)==2 | |    remove(regvar($1))
1977                         "incl\t%(regvar($1)%)"
1978                         erase(regvar($1))
1979                         setcc(regvar($1))       |       | |
1980 #endif /* REGVARS */
1981 inl $1<0        | |     remove(displaced)
1982                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
1983                         "incl\t$1(fp)"
1984                         setcc({LOCAL4,LB,$1,4}) |       | |
1985 inl $1>=0       | |     remove(displaced)
1986                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
1987                         "incl\t$1(ap)"
1988                         setcc({LOCAL4,AP,$1,4}) |       | |
1989 #ifdef REGVARS
1990 lol inl $1==$2 && inreg($1)==2
1991                 | |     remove(regvar($1))
1992                         allocate(REG=regvar($1))
1993                         "incl\t%(regvar($1)%)"
1994                         erase(regvar($1))
1995                         setcc(regvar($1))       | %[a]  | |
1996 #endif /* REGVARS */
1997 ine             | |     remove(externals)
1998                         "incl\t$1"
1999                         setcc({EXTERNAL4,$1})   |       | |
2000 #ifdef REGVARS
2001 del inreg($1)==2 | |    remove(regvar($1))
2002                         "decl\t%(regvar($1)%)"
2003                         erase(regvar($1))
2004                         setcc(regvar($1))       |       | |
2005 #endif /* REGVARS */
2006 del $1<0        | |     remove(displaced)
2007                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
2008                         "decl\t$1(fp)"
2009                         setcc({LOCAL4,LB,$1,4}) |       | |
2010 del $1>=0       | |     remove(displaced)
2011                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
2012                         "decl\t$1(ap)"
2013                         setcc({LOCAL4,AP,$1,4}) |       | |
2014 #ifdef REGVARS
2015 lol del $1==$2 && inreg($1)==2
2016                 | |     remove(regvar($1))
2017                         allocate(REG=regvar($1))
2018                         "decl\t%(regvar($1)%)"
2019                         erase(regvar($1))
2020                         setcc(regvar($1))       | %[a]  | |
2021 #endif /* REGVARS */
2022 dee             | |     remove(externals)
2023                         "decl\t$1"
2024                         setcc({EXTERNAL4,$1})   |       | |
2025 #ifdef REGVARS
2026 zrl inreg($1)==2 | |    remove(regvar($1))
2027                         "clrl\t%(regvar($1)%)"
2028                         erase(regvar($1))
2029                         setcc(regvar($1))       |       | |
2030 #endif /* REGVARS */
2031 zrl $1<0        | |     remove(displaced)
2032                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
2033                         "clrl\t$1(fp)"
2034                         setcc({LOCAL4,LB,$1,4}) |       | |
2035 zrl $1>=0       | |     remove(displaced)
2036                         remove(LOCALS,%[num]<=$1+3 && %[num]+%[size]>$1)
2037                         "clrl\t$1(ap)"
2038                         setcc({LOCAL4,AP,$1,4}) |       | |
2039 zrl zrl $1==$2+4 && $1<0
2040 #ifdef REGVARS
2041         && inreg($1)<2 && inreg($2)<2
2042 #endif /* REGVARS */
2043                 | |     remove(displaced)
2044                         remove(LOCALS,%[num]<=$2+7 && %[num]+%[size]>$2)
2045                         "clrq\t$2(fp)"
2046                         setcc({LOCAL8,LB,$2,8}) |       | |
2047 zrl zrl $1==$2+4 && $1>=0
2048 #ifdef REGVARS
2049         && inreg($1)<2 && inreg($2)<2
2050 #endif /* REGVARS */
2051                 | |     remove(displaced)
2052                         remove(LOCALS,%[num]<=$2+7 && %[num]+%[size]>$2)
2053                         "clrq\t$2(ap)"
2054                         setcc({LOCAL8,AP,$2,8}) |       | |
2055 zrl zrl $1==$2-4 | |                            |       | zrl $2 zrl $1 |
2056 zre             | |     remove(externals)
2057                         "clrl\t$1"
2058                         setcc({EXTERNAL4,$1})   |       | |
2059 zrf $1==4       | |     allocate(REG)
2060                         "clrl\t%[a]"            | %[a]  | |
2061 zrf $1==8       | |     allocate(QREG)
2062                         "clrq\t%[a]"            | %[a]  | |
2063 zer $1==4       | |             | {CONST4,0}            | |
2064 zer $1==8       | |     allocate(QREG)
2065                         "clrq\t%[a]"            | %[a]  | |
2066 zer $1>8&&$1<=32        | STACK |
2067                         "clrq\t-(sp)"           |       | zer $1-8 |
2068 zer defined($1) | STACK |
2069                         move({CONST4,$1/4},R0)
2070 #ifdef LOCLABS
2071                         "1:\tclrl\t-(sp)"
2072                         "sobgtr\tr0,1b"
2073 #else /* LOCLABS */
2074                         "clrl\t-(sp)"
2075                         "sobgtr\tr0,.-2"
2076 #endif /* LOCLABS */
2077                         erase(R0)               |       | |
2078 zer !defined($1) | source1or2or4 |
2079                         remove(ALL)
2080                         move(%[1],R0)
2081 #ifdef LOCLABS
2082                         "1:\tclrl\t-(sp)"
2083                         "sobgtr\tr0,1b"
2084 #else /* LOCLABS */
2085                         "clrl\t-(sp)"
2086                         "sobgtr\tr0,.-2"
2087 #endif /* LOCLABS */
2088                         erase(R0)               |       | |
2089
2090 /********************************
2091  * Group 8 : Convertions        *
2092  ********************************/
2093
2094 cii             | STACK |
2095                         "jsb\t.cii"             |       | |
2096 cfi             | STACK |
2097                         "jsb\t.cfi"             |       | |
2098 cfu             | STACK |
2099                         "jsb\t.cfu"             |       | |
2100 cuf             | STACK |
2101                         "jsb\t.cuf"             |       | |
2102 cif             | STACK |
2103                         "jsb\t.cif"             |       | |
2104 cff             | STACK |
2105                         "jsb\t.cff"             |       | |
2106 cuu             | STACK |
2107                         "jsb\t.cuu"             |       | |
2108 ciu             | |                             |       | cuu |
2109 cui             | STACK |
2110                         "jsb\t.cui"             |       | |
2111 #ifdef REGVARS
2112 loc loc cii stl $1==1 && $2==4 && inreg($4)==2
2113                 | source1or2or4 |
2114                         remove(regvar($4))
2115                         "cvtbl\t%[1],%(regvar($4)%)"
2116                         erase(regvar($1))
2117                         setcc(regvar($4))       |       | |
2118 #endif /* REGVARS */
2119 loc loc cii stl $1==1 && $2==4 && $4<0
2120                 | source1or2or4 |
2121                         remove(displaced)
2122                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2123                         "cvtbl\t%[1],$4(fp)"
2124                         setcc({LOCAL4,LB,$4,4}) |       | |
2125 loc loc cii stl $1==1 && $2==4 && $4>=0
2126                 | source1or2or4 |
2127                         remove(displaced)
2128                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2129                         "cvtbl\t%[1],$4(ap)"
2130                         setcc({LOCAL4,AP,$4,4}) |       | |
2131 loc loc cii ste $1==1 && $2==4  | source1or2or4 |
2132                         remove(externals)
2133                         "cvtbl\t%[1],$4"
2134                         setcc({EXTERNAL4,$4})   |       | |
2135 loc loc cii $1==1 && $2==4      | source1or2or4 |
2136                         allocate(%[1],REG)
2137                         "cvtbl\t%[1],%[a]"
2138                         setcc(%[a])             | %[a]  | |
2139 #ifdef REGVARS
2140 loc loc cii stl $1==2 && $2==4 && inreg($4)==2
2141                 | source2or4 |
2142                         remove(regvar($4))
2143                         "cvtwl\t%[1],%(regvar($4)%)"
2144                         erase(regvar($4))
2145                         setcc(regvar($4))       |       | |
2146 #endif /* REGVARS */
2147 loc loc cii stl $1==2 && $2==4 && $4<0
2148                 | source2or4 |
2149                         remove(displaced)
2150                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2151                         "cvtwl\t%[1],$4(fp)"
2152                         setcc({LOCAL4,LB,$4,4}) |       | |
2153 loc loc cii stl $1==2 && $2==4 && $4>=0
2154                 | source2or4 |
2155                         remove(displaced)
2156                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2157                         "cvtwl\t%[1],$4(ap)"
2158                         setcc({LOCAL4,AP,$4,4}) |       | |
2159 loc loc cii ste $1==2 && $2==4  | source2or4 |
2160                         remove(externals)
2161                         "cvtwl\t%[1],$4"
2162                         setcc({EXTERNAL4,$4})   |       | |
2163 loc loc cii $1==2 && $2==4      | source2or4 |
2164                         allocate(%[1],REG)
2165                         "cvtwl\t%[1],%[a]"
2166                         setcc(%[a])             | %[a]  | |
2167 loc loc cui $1==$2      |       |       |       |       |
2168 loc loc ciu $1==$2      |       |       |       |       |
2169 #ifdef FLOAT4
2170 #ifdef REGVARS
2171 loc loc cfi stl $1==4 && $2==4 && inreg($4)==2
2172                 | source4 |
2173                         remove(regvar($4))
2174                         "cvtfl\t%[1],%(regvar($4)%)"
2175                         erase(regvar($4))
2176                         setcc(regvar($4))       |       | |
2177 #endif /* REGVARS */
2178 loc loc cfi stl $1==4 && $2==4 && $4<0
2179                 | source4 |
2180                         remove(displaced)
2181                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2182                         "cvtfl\t%[1],$4(fp)"
2183                         setcc({LOCAL4,AP,$4,4}) |       | |
2184 loc loc cfi stl $1==4 && $2==4 && $4>=0
2185                 | source4 |
2186                         remove(displaced)
2187                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2188                         "cvtfl\t%[1],$4(ap)"
2189                         setcc({LOCAL4,AP,$4,4}) |       | |
2190 loc loc cfi ste $1==4 && $2==4  | source4 |
2191                         remove(externals)
2192                         "cvtfl\t%[1],$4"
2193                         setcc({EXTERNAL4,$4})   |       | |
2194 #endif /* FLOAT4 */
2195 loc loc cfi $1==4 && $2==4      | source4 |
2196                         allocate(%[1],REG)
2197                         "cvtfl\t%[1],%[a]"
2198                         setcc(%[a])             | %[a]  | | (3,4) + %[1]
2199 #ifdef FLOAT8
2200 #ifdef REGVARS
2201 loc loc cfi stl $1==8 && $2==4 && inreg($4)==2
2202                 | source8 |
2203                         remove(regvar($4))
2204                         "cvtdl\t%[1],%(regvar($4)%)"
2205                         erase(regvar($4))
2206                         setcc(regvar($4))       |       | |
2207 #endif /* REGVARS */
2208 loc loc cfi stl $1==8 && $2==4 && $4<0
2209                 | source8 |
2210                         remove(displaced)
2211                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2212                         "cvtdl\t%[1],$4(fp)"
2213                         setcc({LOCAL4,LB,$4,4}) |       | |
2214 loc loc cfi stl $1==8 && $2==4 && $4>=0
2215                 | source8 |
2216                         remove(displaced)
2217                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2218                         "cvtdl\t%[1],$4(ap)"
2219                         setcc({LOCAL4,AP,$4,4}) |       | |
2220 loc loc cfi ste $1==8 && $2==4  | source8 |
2221                         remove(externals)
2222                         "cvtdl\t%[1],$4"
2223                         setcc({EXTERNAL4,$4})   |       | |
2224 #endif /* FLOAT8 */
2225 loc loc cfi $1==8 && $2==4      | source8 |
2226                         allocate(%[1],REG)
2227                         "cvtdl\t%[1],%[a]"
2228                         setcc(%[a])             | %[a]  | |
2229 #ifdef FLOAT4
2230 #ifdef REGVARS
2231 loc loc cif stl $1==4 && $2==4 && inreg($4)==2
2232                 | source4 |
2233                         remove(regvar($4))
2234                         "cvtlf\t%[1],%(regvar($4)%)"
2235                         erase(regvar($4))
2236                         setcc(regvar($4))       |       | |
2237 #endif /* REGVARS */
2238 loc loc cif stl $1==4 && $2==4 && $4<0
2239                 | source4 |
2240                         remove(displaced)
2241                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2242                         "cvtlf\t%[1],$4(fp)"    |       | |
2243 loc loc cif stl $1==4 && $2==4 && $4>=0
2244                 | source4 |
2245                         remove(displaced)
2246                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2247                         "cvtlf\t%[1],$4(ap)"    |       | |
2248 loc loc cif ste $1==4 && $2==4  | source4 |
2249                         remove(externals)
2250                         "cvtlf\t%[1],$4"        |       | |
2251 #endif /* FLOAT4 */
2252 loc loc cif $1==4 && $2==4      | source4 |
2253                         allocate(%[1],REG)
2254                         "cvtlf\t%[1],%[a]"      | %[a]  | |
2255 #ifdef FLOAT8
2256 /* No double registervariables
2257 #ifdef REGVARS
2258 loc loc cif sdl $1==4 && $2==8 && inreg($4)==2
2259                 | source4 |
2260                         remove(regvar($4))
2261                         "cvtld\t%[1],%(regvar($4)%)"
2262                         erase(regvar($4))
2263                         setcc(regvar($4))       |       | |
2264 #endif
2265 */
2266 loc loc cif sdl $1==4 && $2==8 && $4<0
2267                 | source4 |
2268                         remove(displaced)
2269                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2270                         "cvtld\t%[1],$4(fp)"    |       | |
2271 loc loc cif sdl $1==4 && $2==8 && $4>=0
2272                 | source4 |
2273                         remove(displaced)
2274                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2275                         "cvtld\t%[1],$4(ap)"    |       | |
2276 loc loc cif sde $1==4 && $2==8  | source4 |
2277                         remove(externals)
2278                         "cvtld\t%[1],$4"        |       | |
2279 #endif /* FLOAT8 */
2280 loc loc cif $1==4 && $2==8      | source4 |
2281                         allocate(%[1],QREG)
2282                         "cvtld\t%[1],%[a]"      | %[a]  | |
2283 loc loc cfu $1==4       | source4 |
2284                         allocate(%[1],REG=%[1])
2285                         "bicl2\t$$32768,%[a]"   | %[a]  | loc $1 loc $2 cfi |
2286 loc loc cfu $1==8       | source8 |
2287                         allocate(%[1],QREG=%[1])
2288                         "bicl2\t$$32768,%[a]"   | %[a]  | loc $1 loc $2 cfi |
2289 #ifdef FLOAT8
2290 /* No double registervariables
2291 #ifdef REGVARS
2292 loc loc cff sdl $1==4 && $2==8 && inreg($4)==2
2293                 | source4 |
2294                         remove(regvar($4))
2295                         "cvtfd\t%[1],%(regvar($4)%)"
2296                         erase(regvar($4))
2297                         setcc(regvar($4))       |       | |
2298 #endif
2299 */
2300 loc loc cff sdl $1==4 && $2==8 && $4<0
2301                 | source4 |
2302                         remove(displaced)
2303                         remove(LOCALS,(%[num] <= $4+7 && %[num]+%[size] > $4))
2304                         "cvtfd\t%[1],$4(fp)"    |       | |
2305 loc loc cff sdl $1==4 && $2==8 && $4>=0
2306                 | source4 |
2307                         remove(displaced)
2308                         remove(LOCALS,(%[num] <= $4+7 && %[num]+%[size] > $4))
2309                         "cvtfd\t%[1],$4(ap)"    |       | |
2310 loc loc cff sde $1==4 && $2==8  | source4 |
2311                         remove(externals)
2312                         "cvtfd\t%[1],$4"        |       | |
2313 #endif /* FLOAT8 */
2314 loc loc cff $1==4 && $2==8      | source4 |
2315                         allocate(%[1],QREG)
2316                         "cvtfd\t%[1],%[a]"      | %[a]  | |
2317 #ifdef FLOAT4
2318 #ifdef REGVARS
2319 loc loc cff stl $1==8 && $2==4 && inreg($4)==2
2320                 | source8 |
2321                         remove(regvar($4))
2322                         "cvtdf\t%[1],%(regvar($4)%)"
2323                         erase(regvar($4))
2324                         setcc(regvar($4))       |       | |
2325 #endif /* REGVARS */
2326 loc loc cff stl $1==8 && $2==4 && $4<0
2327                 | source8 |
2328                         remove(displaced)
2329                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2330                         "cvtdf\t%[1],$4(fp)"    |       | |
2331 loc loc cff stl $1==8 && $2==4 && $4>=0
2332                 | source8 |
2333                         remove(displaced)
2334                         remove(LOCALS,(%[num] <= $4+3 && %[num]+%[size] > $4))
2335                         "cvtdf\t%[1],$4(ap)"    |       | |
2336 loc loc cff ste $1==8 && $2==4  | source8 |
2337                         remove(externals)
2338                         "cvtdf\t%[1],$4"        |       | |
2339 #endif /* FLOAT4 */
2340 loc loc cff $1==8 && $2==4      | source8 |
2341                         allocate(%[1],REG)
2342                         "cvtdf\t%[1],%[a]"      | %[a]  | |
2343
2344 /****************************************
2345  * Group 9 : Logical instructions       *
2346  ****************************************/
2347
2348 and $1==4       | source4 source4 |
2349                         allocate(%[1],REG)
2350                         "mcoml\t%[1],%[a]"
2351                         "bicl3\t%[a],%[2],%[a]"
2352                         setcc(%[a])             | %[a]  | | (7,6)+%[1]+%[2]
2353 ...             | NC CONST source4 |
2354                         allocate(%[2],REG)
2355                         "bicl3\t$$~%[1.num],%[2],%[a]"
2356                         setcc(%[a])             | %[a]  | | (4,3)+%[1]+%[2]
2357 ...             | NC source4 CONST |
2358                         allocate(%[1],REG)
2359                         "bicl3\t$$~%[2.num],%[1],%[a]"
2360                         setcc(%[a])             | %[a]  | | (4,3)+%[1]+%[2]
2361 and zeq $1==4   | source4 source4 |
2362                         remove(ALL)
2363                         "bitl\t%[1],%[2]"
2364                         "jeql\t$2"      |       | |
2365 and zne $1==4   | source4 source4 |
2366                         remove(ALL)
2367                         "bitl\t%[1],%[2]"
2368                         "jneq\t$2"      |       | |
2369 and tne $1==4   | source4 source4 |
2370                         allocate(REG={CONST4,0})
2371                         "bitl\t%[1],%[2]"
2372 #ifdef LOCLABS
2373                         "jeql\t1f"
2374                         "incl\t%[a]\n1:"
2375 #else
2376                         "jeql\t.+4"
2377                         "incl\t%[a]"
2378 #endif
2379                         erase(%[a])             | %[a]  | |
2380 #ifdef REGVARS
2381 and stl $1==4 && inreg($2)==2
2382                 | source4 source4 |
2383                         remove(regvar($2))
2384                         allocate(%[1],REG)
2385                         "mcoml\t%[1],%[a]"
2386                         "bicl3\t%[a],%[2],%(regvar($2)%)"
2387                         erase(regvar($2))
2388                         setcc(regvar($2))       |       | | (8,8)+%[1]+%[2]
2389 ...             | NC CONST source4 |
2390                         remove(regvar($2))
2391                         "bicl3\t$$~%[1.num],%[2],%(regvar($2)%)"
2392                         erase(regvar($2))
2393                         setcc(regvar($2))       |       | | (4,4)+%[1]+%[2]
2394 ...             | NC source4 CONST |
2395                         remove(regvar($2))
2396                         "bicl3\t$$~%[2.num],%[1],%(regvar($2)%)"
2397                         erase(regvar($2))
2398                         setcc(regvar($2))       |       | | (4,4)+%[1]+%[2]
2399 #endif /* REGVARS */
2400 and stl $1==4 && $2<0
2401                 | source4 source4 |
2402                         remove(displaced)
2403                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2404                         allocate(%[1],REG)
2405                         "mcoml\t%[1],%[a]"
2406                         "bicl3\t%[a],%[2],$2(fp)"
2407                         setcc({LOCAL4,LB,$2,4}) |       | | (9,12)+%[1]+%[2]
2408 ...             | NC CONST source4 |
2409                         remove(displaced)
2410                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2411                         "bicl3\t$$~%[1.num],%[2],$2(fp)"
2412                         setcc({LOCAL4,LB,$2,4}) |       | | (6,9)+%[1]+%[2]
2413 ...             | NC source4 CONST |
2414                         remove(displaced)
2415                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2416                         "bicl3\t$$~%[2.num],%[1],$2(fp)"
2417                         setcc({LOCAL4,LB,$2,4}) |       | | (6,9)+%[1]+%[2]
2418 and stl $1==4 && $2>=0
2419                 | source4 source4 |
2420                         remove(displaced)
2421                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2422                         allocate(%[1],REG)
2423                         "mcoml\t%[1],%[a]"
2424                         "bicl3\t%[a],%[2],$2(ap)"
2425                         setcc({LOCAL4,AP,$2,4}) |       | | (9,12)+%[1]+%[2]
2426 ...             | NC CONST source4 |
2427                         remove(displaced)
2428                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2429                         "bicl3\t$$~%[1.num],%[2],$2(ap)"
2430                         setcc({LOCAL4,AP,$2,4}) |       | | (6,9)+%[1]+%[2]
2431 ...             | NC source4 CONST |
2432                         remove(displaced)
2433                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2434                         "bicl3\t$$~%[2.num],%[1],$2(ap)"
2435                         setcc({LOCAL4,AP,$2,4}) |       | | (6,9)+%[1]+%[2]
2436 #ifdef REGVARS
2437 and sil $1==4 && inreg($2)==2
2438                 | source4 source4 |
2439                         REMEXTANDLOC
2440                         allocate(%[1],REG)
2441                         "mcoml\t%[1],%[a]"
2442                         "bicl3\t%[a],%[2],(%(regvar($2)%))"
2443                         setcc({regdef4,regvar($2)})
2444                                                 |       | | (9,15)+%[1]+%[2]
2445 ...             | NC CONST source4 |
2446                         REMEXTANDLOC
2447                         "bicl3\t$$~%[1.num],%[2],(%(regvar($2)%))"
2448                         setcc({regdef4,regvar($2)})
2449                                                 |       | | (6,12)+%[1]+%[2]
2450 ...             | NC source4 CONST |
2451                         REMEXTANDLOC
2452                         "bicl3\t$$~%[2.num],%[1],(%(regvar($2)%))"
2453                         setcc({regdef4,regvar($2)})
2454                                                 |       | | (6,12)+%[1]+%[2]
2455 #endif /* REGVARS */
2456 and sil $1==4 && $2<0
2457                 | source4 source4 |
2458                         REMEXTANDLOC
2459                         allocate(%[1],REG)
2460                         "mcoml\t%[1],%[a]"
2461                         "bicl3\t%[a],%[2],*$2(fp)"
2462                         setcc({displdef4,LB,tostring($2)})
2463                                                 |       | | (9,15)+%[1]+%[2]
2464 ...             | NC CONST source4 |
2465                         REMEXTANDLOC
2466                         "bicl3\t$$~%[1.num],%[2],*$2(fp)"
2467                         setcc({displdef4,LB,tostring($2)})
2468                                                 |       | | (6,12)+%[1]+%[2]
2469 ...             | NC source4 CONST |
2470                         REMEXTANDLOC
2471                         "bicl3\t$$~%[2.num],%[1],*$2(fp)"
2472                         setcc({displdef4,LB,tostring($2)})
2473                                                 |       | | (6,12)+%[1]+%[2]
2474 and sil $1==4 && $2>=0
2475                 | source4 source4 |
2476                         REMEXTANDLOC
2477                         allocate(%[1],REG)
2478                         "mcoml\t%[1],%[a]"
2479                         "bicl3\t%[a],%[2],*$2(ap)"
2480                         setcc({displdef4,AP,tostring($2)})
2481                                                 |       | | (9,15)+%[1]+%[2]
2482 ...             | NC CONST source4 |
2483                         REMEXTANDLOC
2484                         "bicl3\t$$~%[1.num],%[2],*$2(ap)"
2485                         setcc({displdef4,AP,tostring($2)})
2486                                                 |       | | (6,12)+%[1]+%[2]
2487 ...             | NC source4 CONST |
2488                         REMEXTANDLOC
2489                         "bicl3\t$$~%[2.num],%[1],*$2(ap)"
2490                         setcc({displdef4,AP,tostring($2)})
2491                                                 |       | | (6,12)+%[1]+%[2]
2492 and ste $1==4   | source4 source4 |
2493                         remove(externals)
2494                         allocate(%[1],REG)
2495                         "mcoml\t%[1],%[a]"
2496                         "bicl3\t%[a],%[2],$2"
2497                         setcc({EXTERNAL4,$2})   |       | | (11,12)+%[1]+%[2]
2498 ...             | NC CONST source4 |
2499                         remove(externals)
2500                         "bicl3\t$$~%[1.num],%[2],$2"
2501                         setcc({EXTERNAL4,$2})   |       | | (8,9)+%[1]+%[2]
2502 ...             | NC source4 CONST |
2503                         remove(externals)
2504                         "bicl3\t$$~%[2.num],%[1],$2"
2505                         setcc({EXTERNAL4,$2})   |       | | (8,9)+%[1]+%[2]
2506 and $1==8       | sreg8 sreg8 |
2507                         "mcoml\t%[1.1],%[1.1]"
2508                         "mcoml\t%[1.2],%[1.2]"
2509                         "bicl2\t%[1.1],%[2.1]"
2510                         "bicl2\t%[1.2],%[2.2]"
2511                         erase(%[1]) erase(%[2]) | %[2]  | |
2512 and defined($1) | |     remove(ALL)
2513                         move({CONST4,$1},R0)
2514                         "jsb\t.and"
2515                         erase(R0)               |       | |
2516 and !defined($1) | source4 |
2517                         remove(ALL)
2518                         move(%[1],R0)
2519                         "jsb\t.and"
2520                         erase(R0)               |       | |
2521 ior $1==4       | source4 source4 |
2522                         allocate(%[1],%[2],REG)
2523                         "bisl3\t%[1],%[2],%[a]"
2524                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
2525 ...             | NC sreg4 source4 |
2526                         "bisl2\t%[2],%[1]"
2527                         erase(%[1])
2528                         setcc(%[1])             | %[1]  | | (3,4) + %[2]
2529 ...             | NC source4 sreg4 |
2530                         "bisl2\t%[1],%[2]"
2531                         erase(%[2])
2532                         setcc(%[2])             | %[2]  | | (3,4) + %[1]
2533 #ifdef REGVARS
2534 ior stl $1==4 && inreg($2)==2
2535                 | source4 source4 |
2536                         remove(regvar($2))
2537                         "bisl3\t%[1],%[2],%(regvar($2)%)"
2538                         erase(regvar($2))
2539                         setcc(regvar($2))       |       | |
2540 #endif /* REGVARS */
2541 ior stl $1==4 && $2<0
2542                 | source4 source4 |
2543                         remove(displaced)
2544                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2545                         "bisl3\t%[1],%[2],$2(fp)"
2546                         setcc({LOCAL4,LB,$2,4}) |       | |
2547 ior stl $1==4 && $2>=0
2548                 | source4 source4 |
2549                         remove(displaced)
2550                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2551                         "bisl3\t%[1],%[2],$2(ap)"
2552                         setcc({LOCAL4,AP,$2,4}) |       | |
2553 #ifdef REGVARS
2554 ior sil $1==4 && inreg($2)==2
2555                 | source4 source4 |
2556                         REMEXTANDLOC
2557                         "bisl3\t%[1],%[2],(%(regvar($2)%))"
2558                         setcc({regdef4,regvar($2)})     |       | |
2559 #endif /* REGVARS */
2560 ior sil $1==4 && $2<0
2561                 | source4 source4 |
2562                         REMEXTANDLOC
2563                         "bisl3\t%[1],%[2],*$2(fp)"
2564                         setcc({displdef4,LB,tostring($2)}) |    | |
2565 ior sil $1==4 && $2>=0
2566                 | source4 source4 |
2567                         REMEXTANDLOC
2568                         "bisl3\t%[1],%[2],*$2(ap)"
2569                         setcc({displdef4,LB,tostring($2)}) |    | |
2570 ior ste $1==4   | source4 source4 |
2571                         remove(externals)
2572                         "bisl3\t%[1],%[2],$2"
2573                         setcc({EXTERNAL4,$2})   |       | |
2574 ior $1==8       | sreg8 sreg8 |
2575                         "bisl2\t%[1.1],%[2.1]"
2576                         "bisl2\t%[1.2],%[2.2]"
2577                         erase(%[2])             | %[2]  | |
2578 ior defined($1) | STACK |
2579                         move({CONST4,$1},R0)
2580                         "jsb\t.ior"
2581                         erase(R0)               |       | |
2582 ior !defined($1) | source4 |
2583                         remove(ALL)
2584                         move(%[1],R0)
2585                         "jsb\t.ior"
2586                         erase(R0)               |       | |
2587 xor $1==4       | source4 source4 |
2588                         allocate(%[1],%[2],REG)
2589                         "xorl3\t%[1],%[2],%[a]"
2590                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
2591 ...             | NC sreg4 source4 |
2592                         "xorl2\t%[2],%[1]"
2593                         erase(%[1])
2594                         setcc(%[1])             | %[1]  | | (3,4) + %[2]
2595 ...             | NC source4 sreg4 |
2596                         "xorl2\t%[1],%[2]"
2597                         erase(%[2])
2598                         setcc(%[2])             | %[2]  | | (3,4) + %[1]
2599 #ifdef REGVARS
2600 xor stl $1==4 && inreg($2)==2
2601         | source4 source4 |
2602                         remove(regvar($2))
2603                         "xorl3\t%[1],%[2],%(regvar($2)%)"
2604                         erase(regvar($2))
2605                         setcc(regvar($2))       |       | |
2606 #endif /* REGVARS */
2607 xor stl $1==4 && $2<0
2608                 | source4 source4 |
2609                         remove(displaced)
2610                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2611                         "xorl3\t%[1],%[2],$2(fp)"
2612                         setcc({LOCAL4,LB,$2,4}) |       | |
2613 xor stl $1==4 && $2>=0
2614                 | source4 source4 |
2615                         remove(displaced)
2616                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2617                         "xorl3\t%[1],%[2],$2(ap)"
2618                         setcc({LOCAL4,AP,$2,4}) |       | |
2619 #ifdef REGVARS
2620 xor sil $1==4 && inreg($2)==2
2621                 | source4 source4 |
2622                         REMEXTANDLOC
2623                         "xorl3\t%[1],%[2],(%(regvar($2)%))"
2624                         setcc({regdef4,regvar($2)})     |       | |
2625 #endif /* REGVARS */
2626 xor sil $1==4 && $2<0
2627                 | source4 source4 |
2628                         REMEXTANDLOC
2629                         "xorl3\t%[1],%[2],*$2(fp)"
2630                         setcc({displdef4,LB,tostring($2)}) |    | |
2631 xor sil $1==4 && $2>=0
2632                 | source4 source4 |
2633                         REMEXTANDLOC
2634                         "xorl3\t%[1],%[2],*$2(ap)"
2635                         setcc({displdef4,AP,tostring($2)}) |    | |
2636 xor ste $1==4   | source4 source4 |
2637                         remove(externals)
2638                         "xorl3\t%[1],%[2],$2"
2639                         setcc({EXTERNAL4,$2})   |       | |
2640 xor defined($1) | STACK |
2641                         move({CONST4,$1},R0)
2642                         "jsb\t.xor"
2643                         erase(R0)               |       | |
2644 xor !defined($1) | source4 |
2645                         remove(ALL)
2646                         move(%[1],R0)
2647                         "jsb\t.xor"
2648                         erase(R0)               |       | |
2649 com $1==4       | source4 |
2650                         allocate(%[1],REG)
2651                         "mcoml\t%[1],%[a]"
2652                         setcc(%[a])             | %[a]  | |
2653 #ifdef REGVARS
2654 com stl $1==4 && inreg($2)==2
2655                 | source4 |
2656                         remove(regvar($2))
2657                         "mcoml\t%[1],%(regvar($2)%)"
2658                         erase(regvar($2))
2659                         setcc(regvar($2))       |       | |
2660 #endif /* REGVARS */
2661 com stl $1==4 && $2<0
2662                 | source4 |
2663                         remove(displaced)
2664                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2665                         "mcoml\t%[1],$2(fp)"
2666                         setcc({LOCAL4,LB,$2,4}) |       | |
2667 com stl $1==4 && $2>=0
2668                 | source4 |
2669                         remove(displaced)
2670                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2671                         "mcoml\t%[1],$2(ap)"
2672                         setcc({LOCAL4,AP,$2,4}) |       | |
2673 #ifdef REGVARS
2674 com sil $1==4 && inreg($2)==2
2675                 | source4 |
2676                         REMEXTANDLOC
2677                         "mcoml\t%[1],(%(regvar($2)%))"
2678                         setcc({regdef4,regvar($2)})     |       | |
2679 #endif /* REGVARS */
2680 com sil $1==4 && $2<0
2681                 | source4 |
2682                         REMEXTANDLOC
2683                         "mcoml\t%[1],*$2(fp)"
2684                         setcc({displdef4,LB,tostring($2)}) |    | |
2685 com sil $1==4 && $2>=0
2686                 | source4 |
2687                         REMEXTANDLOC
2688                         "mcoml\t%[1],*$2(ap)"
2689                         setcc({displdef4,AP,tostring($2)}) |    | |
2690 com ste $1==4   | source4 |
2691                         remove(externals)
2692                         "mcoml\t%[1],$2"
2693                         setcc({EXTERNAL4,$2})   |       | |
2694 com defined($1) | STACK |
2695                         move({CONST4,$1},R0)
2696                         "jsb\t.com"
2697                         erase(R0)               |       | |
2698 com !defined($1) | source4 |
2699                         remove(ALL)
2700                         move(%[1],R0)
2701                         "jsb\t.com"
2702                         erase(R0)               |       | |
2703 rol $1==4       | source4 source4 |
2704                         allocate(%[1],REG=%[1])
2705                         "rotl\t%[a],%[2],%[a]"
2706                         erase(%[a])
2707                         setcc(%[a])             | %[a]  | |
2708 #ifdef REGVARS
2709 rol stl $1==4 && inreg($2)==2
2710                 | source4 source4 |
2711                         remove(regvar($2))
2712                         "rotl\t%[1],%[2],%(regvar($2)%)"
2713                         erase(regvar($2))
2714                         setcc(regvar($2))       |       | |
2715 #endif /* REGVARS */
2716 rol stl $1==4 && $2<0
2717                 | source4 source4 |
2718                         remove(displaced)
2719                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2720                         "rotl\t%[1],%[2],$2(fp)"
2721                         setcc({LOCAL4,LB,$2,4}) |       | |
2722 rol stl $1==4 && $2>=0
2723                 | source4 source4 |
2724                         remove(displaced)
2725                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2726                         "rotl\t%[1],%[2],$2(ap)"
2727                         setcc({LOCAL4,AP,$2,4}) |       | |
2728 #ifdef REGVARS
2729 rol sil $1==4 && inreg($2)==2
2730                 | source4 source4 |
2731                         REMEXTANDLOC
2732                         "rotl\t%[1],%[2],(%(regvar($2)%))"
2733                         setcc({regdef4,regvar($2)})     |       | |
2734 #endif /* REGVARS */
2735 rol sil $1==4 && $2<0
2736                 | source4 source4 |
2737                         REMEXTANDLOC
2738                         "rotl\t%[1],%[2],*$2(fp)"
2739                         setcc({displdef4,LB,tostring($2)})      |       | |
2740 rol sil $1==4 && $2>=0
2741                 | source4 source4 |
2742                         REMEXTANDLOC
2743                         "rotl\t%[1],%[2],*$2(ap)"
2744                         setcc({displdef4,AP,tostring($2)})      |       | |
2745 rol ste $1==4   | source4 source4 |
2746                         remove(externals)
2747                         "rotl\t%[1],%[2],$2"
2748                         setcc({EXTERNAL4,$2})   |       | |
2749 rol !defined($1) | source4 |
2750                         remove(ALL)
2751                         move(%[1],R0)
2752                         "jsb\t.rol"
2753                         erase(R0)               |       | |
2754 ror $1==4       | source4 source4 |
2755                         allocate(%[1],REG)
2756                         "subl3\t%[1],$$32,%[a]"
2757                         "rotl\t%[a],%[2],%[a]"
2758                         setcc(%[a])             | %[a]  | |
2759 ...             | NC CONST source4 |
2760                         allocate(%[2],REG)
2761                         "rotl\t$$%(32-%[1.num]%),%[2],%[a]"
2762                         setcc(%[a])             | %[a]  | |
2763 #ifdef REGVARS
2764 ror stl $1==4 && inreg($2)==2
2765                 | source4 source4 |
2766                         remove(regvar($2))
2767                         allocate(%[1],REG)
2768                         "subl3\t%[1],$$32,%[a]"
2769                         "rotl\t%[a],%[2],%(regvar($2)%)"
2770                         erase(regvar($2))
2771                         setcc(regvar($2))       |       | |
2772 ...             | NC CONST source4 |
2773                         remove(regvar($2))
2774                         "rotl\t$$%(32-%[1.num]%),%[2],%(regvar($2)%)"
2775                         erase(regvar($2))
2776                         setcc(regvar($2))       |       | |
2777 #endif /* REGVARS */
2778 ror stl $1==4 && $2<0
2779                 | source4 source4 |
2780                         remove(displaced)
2781                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2782                         allocate(%[1],REG)
2783                         "subl3\t%[1],$$32,%[a]"
2784                         "rotl\t%[a],%[2],$2(fp)"
2785                         setcc({LOCAL4,LB,$2,4}) |       | |
2786 ...             | NC CONST source4 |
2787                         remove(displaced)
2788                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2789                         "rotl\t$$%(32-%[1.num]%),%[2],$2(fp)"
2790                         setcc({LOCAL4,LB,$2,4}) |       | |
2791 ror stl $1==4 && $2>=0
2792                 | source4 source4 |
2793                         remove(displaced)
2794                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2795                         allocate(%[1],REG)
2796                         "subl3\t%[1],$$32,%[a]"
2797                         "rotl\t%[a],%[2],$2(ap)"
2798                         setcc({LOCAL4,AP,$2,4}) |       | |
2799 ...             | NC CONST source4 |
2800                         remove(displaced)
2801                         remove(LOCALS,(%[num] <= $2+3 && %[num]+%[size] > $2))
2802                         "rotl\t$$%(32-%[1.num]%),%[2],$2(ap)"
2803                         setcc({LOCAL4,AP,$2,4}) |       | |
2804 #ifdef REGVARS
2805 ror sil $1==4 && inreg($2)==2
2806                 | source4 source4 |
2807                         REMEXTANDLOC
2808                         allocate(%[1],REG)
2809                         "subl3\t%[1],$$32,%[a]"
2810                         "rotl\t%[a],%[2],(%(regvar($2)%))"
2811                         setcc({regdef4,regvar($2)})     |       | |
2812 ...             | NC CONST source4 |
2813                         REMEXTANDLOC
2814                         "rotl\t$$%(32-%[1.num]%),%[2],(%(regvar($2)%))"
2815                         setcc({regdef4,regvar($2)})     |       | |
2816 #endif /* REGVARS */
2817 ror sil $1==4 && $2<0
2818                 | source4 source4 |
2819                         REMEXTANDLOC
2820                         allocate(%[1],REG)
2821                         "subl3\t%[1],$$32,%[a]"
2822                         "rotl\t%[a],%[2],*$2(fp)"
2823                         setcc({displdef4,LB,tostring($2)})      |       | |
2824 ...             | NC CONST source4 |
2825                         REMEXTANDLOC
2826                         "rotl\t$$%(32-%[1.num]%),%[2],*$2(fp)"
2827                         setcc({displdef4,LB,tostring($2)})      |       | |
2828 ror sil $1==4 && $2>=0
2829                 | source4 source4 |
2830                         REMEXTANDLOC
2831                         allocate(%[1],REG)
2832                         "subl3\t%[1],$$32,%[a]"
2833                         "rotl\t%[a],%[2],*$2(ap)"
2834                         setcc({displdef4,AP,tostring($2)})      |       | |
2835 ...             | NC CONST source4 |
2836                         REMEXTANDLOC
2837                         "rotl\t$$%(32-%[1.num]%),%[2],*$2(ap)"
2838                         setcc({displdef4,AP,tostring($2)})      |       | |
2839 ror ste $1==4   | source4 source4 |
2840                         remove(externals)
2841                         allocate(%[1],REG)
2842                         "subl3\t%[1],$$32,%[a]"
2843                         "rotl\t%[a],%[2],$2"
2844                         setcc({EXTERNAL4,$2})   |       | |
2845 ...             | NC CONST source4 |
2846                         remove(externals)
2847                         "rotl\t$$%(32-%[1.num]%),%[2],$2"
2848                         setcc({EXTERNAL4,$2})   |       | |
2849 ror !defined($1) | source4 |
2850                         remove(ALL)
2851                         move(%[1],R0)
2852                         "jsb\t.ror"
2853                         erase(R0)               |       | |
2854 com and $1==4 && $2==4
2855                 | source4 source4 |
2856                         allocate(%[1],%[2],REG)
2857                         "bicl3\t%[1],%[2],%[a]"
2858                         setcc(%[a])             | %[a]  | | (4,4)+%[1]+%[2]
2859 ...             | NC source4 sreg4 |
2860                         "bicl2\t%[1],%[2]"
2861                         erase(%[2])
2862                         setcc(%[2])             | %[2]  | | (3,4) + %[1]
2863 #ifdef REGVARS
2864 com and stl $1==4 && $2==4 && inreg($3)==2
2865                 | source4 source4 |
2866                         remove(regvar($3))
2867                         "bicl3\t%[1],%[2],%(regvar($3)%)"
2868                         erase(regvar($3))
2869                         setcc(regvar($3))       |       | |
2870 #endif /* REGVARS */
2871 com and stl $1==4 && $2==4 && $3<0
2872                 | source4 source4 |
2873                         remove(displaced)
2874                         remove(LOCALS,(%[num] <= $3+3 && %[num]+%[size] > $3))
2875                         "bicl3\t%[1],%[2],$3(fp)"
2876                         setcc({LOCAL4,AP,$3,4}) |       | |
2877 com and stl $1==4 && $2==4 && $3>=0
2878                 | source4 source4 |
2879                         remove(displaced)
2880                         remove(LOCALS,(%[num] <= $3+3 && %[num]+%[size] > $3))
2881                         "bicl3\t%[1],%[2],$3(ap)"
2882                         setcc({LOCAL4,AP,$3,4}) |       | |
2883 #ifdef REGVARS
2884 com and sil $1==4 && $2==4 && inreg($3)==2
2885                 | source4 source4 |
2886                         REMEXTANDLOC
2887                         "bicl3\t%[1],%[2],(%(regvar($3)%))"
2888                         setcc({regdef4,regvar($3)})     |       | |
2889 #endif /* REGVARS */
2890 com and sil $1==4 && $2==4 && $3<0
2891                 | source4 source4 |
2892                         REMEXTANDLOC
2893                         "bicl3\t%[1],%[2],*$3(fp)"
2894                         setcc({displdef4,LB,tostring($3)})      |       | |
2895 com and sil $1==4 && $2==4 && $3>=0
2896                 | source4 source4 |
2897                         REMEXTANDLOC
2898                         "bicl3\t%[1],%[2],*$3(ap)"
2899                         setcc({displdef4,AP,tostring($3)})      |       | |
2900 com and ste $1==4 &&$2==4
2901                 | source4 source4 |
2902                         remove(externals)
2903                         "bicl3\t%[1],%[2],$3"
2904                         setcc({EXTERNAL4,$3})   |       | |
2905 com and $1==$2  | STACK |
2906                         move({CONST4,$1},R0)
2907                         "jsb\t.cmand"
2908                         erase(R0)               |       | |
2909
2910 /********************************
2911  * Group 10: Set instructions   *
2912  ********************************/
2913
2914 loc inn $1==0 && $2==4  | source4 |
2915                         allocate(%[1],REG)
2916                         "bicl3\t$$~1,%[1],%[a]"
2917                         setcc(%[a])             | %[a]  | |
2918 loc inn $2==4   | source4 |
2919                         allocate(%[1],REG)
2920                         "ashl\t$$%(0-$1%),%[1],%[a]"
2921                         "bicl2\t$$~1,%[a]"
2922                         setcc(%[a])             | %[a]  | |
2923 #ifdef LOCLABS
2924 inn $1==4       | source4 source4 |
2925                         allocate(REG={CONST1,0})
2926                         "cmpl\t%[1],$$31"
2927                         "bgtru\t1f"
2928                         "mnegl\t%[1],%[a]"
2929                         "ashl\t%[a],%[2],%[a]"
2930                         "bicl2\t$$~1,%[a]\n1:"
2931                         setcc(%[a])
2932                         erase(%[a])             | %[a]  | |
2933 #endif
2934 loc inn zeq $2==4       | source4 |
2935                         remove(ALL)
2936                         "bitl\t%[1],$$%(1<<$1%)"
2937                         "jeql\t$3"              |       | |
2938 loc inn zne $2==4       | source4 |
2939                         remove(ALL)
2940                         "bitl\t%[1],$$%(1<<$1%)"
2941                         "jneq\t$3"              |       | |
2942 inn zeq $1==4   | source4-(reginc4+regdec4+ind4) source4 |
2943                         remove(ALL)
2944                         allocate(REG)
2945                         "cmpl\t%[1],$$31"
2946                         "jgtru\t$2"
2947                         "ashl\t%[1],$$1,%[a]"
2948                         "bitl\t%[2],%[a]"
2949                         "jeql\t$2"              |       | |
2950 ...             | NC source1 source4 |
2951                         remove(ALL)
2952                         allocate(REG)
2953                         "cmpb\t%[1],$$31"
2954                         "jgtru\t$2"
2955                         "ashl\t%[1],$$1,%[a]"
2956                         "bitl\t%[2],%[a]"
2957                         "jeql\t$2"              |       | |
2958 #ifdef LOCLABS
2959 inn zne $1==4   | source4-(reginc4+regdec4+ind4) source4 |
2960                         remove(ALL)
2961                         allocate(REG)
2962                         "cmpl\t%[1],$$31"
2963                         "bgtru\t1f"
2964                         "ashl\t%[1],$$1,%[a]"
2965                         "bitl\t%[2],%[a]"
2966                         "jneq\t$2\n1:"          |       | |
2967 ...             | NC source1 source4 |
2968                         remove(ALL)
2969                         allocate(REG)
2970                         "cmpb\t%[1],$$31"
2971                         "bgtru\t1f"
2972                         "ashl\t%[1],$$1,%[a]"
2973                         "bitl\t%[2],%[a]"
2974                         "jneq\t$2\n1:"          |       | |
2975 #endif
2976 loc inn zeq $2==8 && $1<32      /* First half of set. */
2977                 | REG REG |
2978                         remove(ALL)
2979                         "bitl\t%[1],$$%(1<<$1%)"
2980                         "jeql\t$3"              |       | |
2981 loc inn zeq $2==8 && $1>=32     /* Second half. */
2982                 | REG REG |
2983                         remove(ALL)
2984                         "bitl\t%[2],$$%(1<<($1-32)%)"
2985                         "jeql\t$3"              |       | |
2986 loc inn zne $2==8 && $1<32      /* First half of set. */
2987                 | REG REG |
2988                         remove(ALL)
2989                         "bitl\t%[1],$$%(1<<$1%)"
2990                         "jneq\t$3"              |       | |
2991 loc inn zne $2==8 && $1>=32     /* Second half. */
2992                 | REG REG |
2993                         remove(ALL)
2994                         "bitl\t%[2],$$%(1<<($1-32)%)"
2995                         "jneq\t$3"              |       | |
2996 inn defined($1) | STACK |
2997                         move({CONST4,$1},R0)
2998                         "jsb\t.inn"
2999                         erase(R0)               | R1    | |
3000 inn !defined($1) | source4 |
3001                         remove(ALL)
3002                         move(%[1],R0)
3003                         "jsb\t.inn"
3004                         erase(R0)               | R1    | |
3005 set $1==4       | source4 | |   {CONST4,1} %[1] | sli 4 |
3006 set defined($1) | STACK |
3007                         move({CONST4,$1},R0)
3008                         "jsb\t.setx"
3009                         erase(R0)               |       | |
3010 set !defined($1) | source4 |
3011                         remove(ALL)
3012                         move(%[1],R0)
3013                         "jsb\t.setx"
3014                         erase(R0)               |       | |
3015
3016 /****************************************
3017  * Group 11 : Array instructions        *
3018  ****************************************/
3019
3020 lae aar $2==4 && rom(1,3)==1    | | | | ads 4 adp 0-rom(1,1) |
3021 lae aar $2==4 && rom(1,3)==2    | | | | loc 1 sli 4 ads 4 adp 0-2*rom(1,1) |
3022 lae aar $2==4 && rom(1,3)==4    | | | | loc 2 sli 4 ads 4 adp 0-4*rom(1,1) |
3023 lae aar $2==4 && rom(1,3)==8    | | | | loc 3 sli 4 ads 4 adp 0-8*rom(1,1) |
3024 lae aar $2==4 && defined(rom(1,3)) && rom(1,1)==0
3025                 | source4 adispl |
3026                         allocate(%[1],REG)
3027                         "mull3\t$$%(rom(1,3)%),%[1],%[a]"
3028                         | {adisplind1,%[a],%[2.reg],%[2.ind]}   | | (8,10)+%[1]
3029 ...             | NC source4 ADDR_EXTERNAL |
3030                         allocate(%[1],REG)
3031                         "mull3\t$$%(rom(1,3)%),%[1],%[a]"
3032                         | {adispl,%[a],%[2.ind]}        | | (7,16)+%[1]
3033 lae aar $2==4 && defined(rom(1,3))
3034                 | source4 adispl |
3035                         allocate(%[1],REG)
3036                         "mull3\t$$%(rom(1,3)%),%[1],%[a]"
3037                         | {adisplind1,%[a],%[2.reg],
3038                                 %[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))}
3039                                 | | (8,10)+%[1]
3040 ...             | NC source4 ADDR_EXTERNAL |
3041                         allocate(%[1],REG)
3042                         "mull3\t$$%(rom(1,3)%),%[1],%[a]"
3043                         | {adispl,%[a],
3044                                 %[2.ind]+"+"+tostring(0-rom(1,1)*rom(1,3))}
3045                                 | | (7,16)+%[1]
3046 /* Sequence used by the CEM-compiler and the codegenerator. */
3047 loc sli ads $1==2 && $2==4 && $3==4
3048                 | reg4 ADDR_EXTERNAL |
3049                                 | {aextind4,%[1],%[2.ind]} | |
3050 ...             | reg4 adispl |
3051                                 | {adisplind4,%[1],%[2.reg],%[2.ind]} | |
3052 ...             | reg4 displ4 |
3053                                 | {adispldefind4,%[1],%[2.reg],%[2.ind]} | |
3054 ...             | reg4 EXTERNAL4 |
3055                                 | {aextdefind4,%[1],%[2.ind]} | |
3056 loc sli ads $1==3 && $2==4 && $3==4
3057                 | reg4 ADDR_EXTERNAL |
3058                                 | {aextind8,%[1],%[2.ind]} | |
3059 ...             | reg4 adispl |
3060                                 | {adisplind8,%[1],%[2.reg],%[2.ind]} | |
3061 ...             | reg4 displ4 |
3062                                 | {adispldefind8,%[1],%[2.reg],%[2.ind]} | |
3063 ...             | reg4 EXTERNAL4 |
3064                                 | {aextdefind8,%[1],%[2.ind]} | |
3065 aar $1==4       | STACK |
3066                         "jsb\t.aar4"             | R0   | |
3067 aar !defined($1) | source4 |
3068                         remove(ALL)
3069                         move(%[1],R0)
3070                         "jsb\t.aar"
3071                         erase(R0)               | R0    | |
3072 lae sar defined(rom(1,3))       | | |   | lae $1 aar $2 sti rom(1,3)    |
3073 lae lar defined(rom(1,3))       | | |   | lae $1 aar $2 loi rom(1,3)    |
3074 sar $1==4       | STACK |
3075                         "jsb\t.sar4"             |       | |
3076 sar !defined($1) | source4 |
3077                         remove(ALL)
3078                         move(%[1],R0)
3079                         "jsb\t.sar"
3080                         erase(R0)               |       | |
3081 lar $1==4       | STACK |
3082                         "jsb\t.lar4"             |       | |
3083 lar !defined($1) | source4 |
3084                         remove(ALL)
3085                         move(%[1],R0)
3086                         "jsb\t.lar"
3087                         erase(R0)               |       | |
3088
3089 /****************************************
3090  * Group 12 : Compare instructions      *
3091  ****************************************/
3092
3093 cmi $1==4       | source4 source4 |
3094                         allocate(REG={CONST1,0})
3095                         "cmpl\t%[1],%[2]"
3096 #ifdef LOCLABS
3097                         "beql\t2f"
3098                         "bgtr\t1f"
3099 #else
3100                         "beql\t.+10"
3101                         "bgtr\t.+6"
3102 #endif
3103                         "incl\t%[a]"
3104 #ifdef LOCLABS
3105                         "brb\t2f\n1:"
3106                         "decl\t%[a]\n2:"
3107 #else
3108                         "brb\t.+4"
3109                         "decl\t%[a]"
3110 #endif
3111                         erase(%[a])
3112                         setcc(%[a])             | %[a]  | |
3113 cmi !defined($1) | source4 |
3114                         remove(ALL)
3115                         move(%[1],R0)
3116                         "jsb\t.cmi"
3117                         setcc(R0)
3118                         erase(R0)               | R0    | |
3119 cmf $1==4       | source4 source4 |
3120                         allocate(REG={CONST1,0})
3121                         "cmpf\t%[1],%[2]"
3122 #ifdef LOCLABS
3123                         "beql\t2f"
3124                         "bgtr\t1f"
3125 #else
3126                         "beql\t.+10"
3127                         "bgtr\t.+6"
3128 #endif
3129                         "incl\t%[a]"
3130 #ifdef LOCLABS
3131                         "brb\t2f\n1:"
3132                         "decl\t%[a]\n2:"
3133 #else
3134                         "brb\t.+4"
3135                         "decl\t%[a]"
3136 #endif
3137                         erase(%[a])
3138                         setcc(%[a])             | %[a]  | |
3139 cmf $1==8       | source8 source8 |
3140 /* trouble, possible lack of scratch registers */
3141                         allocate(%[1],%[2],REG)
3142                         "cmpd\t%[1],%[2]"
3143 #ifdef LOCLABS
3144                         "blss\t2f"
3145                         "bgtr\t1f"
3146 #else
3147                         "blss\t.+8"
3148                         "bgtr\t.+11"
3149 #endif
3150                         "clrl\t%[a]"
3151 #ifdef LOCLABS
3152                         "brb\t3f\n2:"
3153 #else
3154                         "brb\t.+10"
3155 #endif
3156                         "movl\t$$1,%[a]"
3157 #ifdef LOCLABS
3158                         "brb\t3f\n1:"
3159                         "mnegl\t$$1,%[a]\n3:"
3160 #else
3161                         "brb\t.+5"
3162                         "mnegl\t$$1,%[a]"
3163 #endif
3164                         erase(%[a])
3165                         setcc(%[a])             | %[a]  | |
3166 cmf !defined($1) | source4 |
3167                         remove(ALL)
3168                         move(%[1],R0)
3169                         "jsb\t.cmf"
3170                         setcc(R0)
3171                         erase(R0)               | R0    | |
3172 cmu $1==4       | |                             |       | cmp |
3173 cmu !defined($1) | source4 |
3174                         remove(ALL)
3175                         move(%[1],R0)
3176                         "jsb\t.cmu"
3177                         setcc(R0)
3178                         erase(R0)               | R0    | |
3179 cmp             | source4 source4 |
3180                         allocate(REG={CONST1,0})
3181                         "cmpl\t%[1],%[2]"
3182 #ifdef LOCLABS
3183                         "beqlu\t2f"
3184                         "bgtru\t1f"
3185 #else
3186                         "beqlu\t.+10"
3187                         "bgtru\t.+6"
3188 #endif
3189                         "incl\t%[a]"
3190 #ifdef LOCLABS
3191                         "brb\t2f\n1:"
3192                         "decl\t%[a]\n2:"
3193 #else
3194                         "brb\t.+4"
3195                         "decl\t%[a]"
3196 #endif
3197                         erase(%[a])
3198                         setcc(%[a])             | %[a]  | |
3199 cms $1==4       | source4 source4 |
3200                         allocate(%[1],%[2],REG)
3201                         "xorl3\t%[1],%[2],%[a]"
3202                         setcc(%[a])
3203                         erase(%[a])             | %[a]  | |
3204 cms defined($1) | STACK |
3205                         move({CONST1,$1},R0)
3206                         "jsb\t.cms"
3207                         setcc(R0)
3208                         erase(R0)               | R0    | |
3209 cms !defined($1) | source4 |
3210                         remove(ALL)
3211                         move(%[1],R0)
3212                         "jsb\t.cms"
3213                         setcc(R0)
3214                         erase(R0)               | R0    | |
3215 tlt             | source4 |
3216                         allocate(REG={CONST1,0})
3217                         test(%[1])
3218 #ifdef LOCLABS
3219                         "bgeq\t1f"
3220                         "incl\t%[a]\n1:"
3221 #else
3222                         "bgeq\t.+4"
3223                         "incl\t%[a]"
3224 #endif
3225                         erase(%[a])
3226                         setcc(%[a])             | %[a]  | |
3227 ...             | NC source1or2-regch4 |        | {CONST1,0}    | |
3228 tlt and $2==4   | source4 sreg4 |
3229                         test(%[1])
3230 #ifdef LOCLABS
3231                         "blss\t1f"
3232                         "clrl\t%[2]\n1:"
3233 #else
3234                         "blss\t.+4"
3235                         "clrl\t%[2]"
3236 #endif
3237                         setcc(%[2])
3238                         erase(%[2])             | %[2]  | |
3239 tlt ior $2==4   | source4 sreg4 |
3240                         test(%[1])
3241 #ifdef LOCLABS
3242                         "bgeq\t1f"
3243                         "bisl2\t$$1,%[2]\n1:"
3244 #else
3245                         "bgeq\t.+4"
3246                         "bisl2\t$$1,%[2]"
3247 #endif
3248                         setcc(%[2])
3249                         erase(%[2])             | %[2]  | |
3250 tle             | source4 |
3251                         allocate(REG={CONST1,0})
3252                         test(%[1])
3253 #ifdef LOCLABS
3254                         "bgtr\t1f"
3255                         "incl\t%[a]\n1:"
3256 #else
3257                         "bgtr\t.+4"
3258                         "incl\t%[a]"
3259 #endif
3260                         erase(%[a])
3261                         setcc(%[a])             | %[a]  | |
3262 ...             | NC source1or2 |               | %[1]  | teq |
3263 tle and $2==4   | source4 sreg4 |
3264                         test(%[1])
3265 #ifdef LOCLABS
3266                         "bleq\t1f"
3267                         "clrl\t%[2]\n1:"
3268 #else
3269                         "bleq\t.+4"
3270                         "clrl\t%[2]"
3271 #endif
3272                         setcc(%[2])
3273                         erase(%[2])             | %[2]  | |
3274 tle ior $2==4   | source4 sreg4 |
3275                         test(%[1])
3276 #ifdef LOCLABS
3277                         "bgtr\t1f"
3278                         "bisl2\t$$1,%[2]\n1:"
3279 #else
3280                         "bgtr\t.+4"
3281                         "bisl2\t$$1,%[2]"
3282 #endif
3283                         setcc(%[2])
3284                         erase(%[2])             | %[2]  | |
3285 tge             | source4 |
3286                         allocate(REG={CONST1,0})
3287                         test(%[1])
3288 #ifdef LOCLABS
3289                         "blss\t1f"
3290                         "incl\t%[a]\n1:"
3291 #else
3292                         "blss\t.+4"
3293                         "incl\t%[a]"
3294 #endif
3295                         erase(%[a])
3296                         setcc(%[a])             | %[a]  | |
3297 ...             | NC source1or2-regch4 |        | {CONST1,1} | |
3298 tge and $2==4   | source4 sreg4 |
3299                         test(%[1])
3300 #ifdef LOCLABS
3301                         "bgeq\t1f"
3302                         "clrl\t%[2]\n1:"
3303 #else
3304                         "bgeq\t.+4"
3305                         "clrl\t%[2]"
3306 #endif
3307                         setcc(%[2])
3308                         erase(%[2])             | %[2]  | |
3309 tge ior $2==4   | source4 sreg4 |
3310                         test(%[1])
3311 #ifdef LOCLABS
3312                         "blss\t1f"
3313                         "bisl2\t$$1,%[2]\n1:"
3314 #else
3315                         "blss\t.+4"
3316                         "bisl2\t$$1,%[2]"
3317 #endif
3318                         setcc(%[2])
3319                         erase(%[2])             | %[2]  | |
3320 tgt             | source4 |
3321                         allocate(REG={CONST1,0})
3322                         test(%[1])
3323 #ifdef LOCLABS
3324                         "bleq\t1f"
3325                         "incl\t%[a]\n1:"
3326 #else
3327                         "bleq\t.+4"
3328                         "incl\t%[a]"
3329 #endif
3330                         erase(%[a])
3331                         setcc(%[a])             | %[a]  | |
3332 ...             | NC source1or2 |       | %[1]  | tne |
3333 tgt and $2==4   | source4 sreg4 |
3334                         test(%[1])
3335 #ifdef LOCLABS
3336                         "bgtr\t1f"
3337                         "clrl\t%[2]\n1:"
3338 #else
3339                         "bgtr\t.+4"
3340                         "clrl\t%[2]"
3341 #endif
3342                         setcc(%[2])
3343                         erase(%[2])             | %[2]  | |
3344 tgt ior $2==4   | source4 sreg4 |
3345                         test(%[1])
3346 #ifdef LOCLABS
3347                         "bleq\t1f"
3348                         "bisl2\t$$1,%[2]\n1:"
3349 #else
3350                         "bleq\t.+4"
3351                         "bisl2\t$$1,%[2]"
3352 #endif
3353                         setcc(%[2])
3354                         erase(%[2])             | %[2]  | |
3355 teq             | source1or2or4 |
3356                         allocate(REG={CONST1,0})
3357                         test(%[1])
3358 #ifdef LOCLABS
3359                         "bneq\t1f"
3360                         "incl\t%[a]\n1:"
3361 #else
3362                         "bneq\t.+4"
3363                         "incl\t%[a]"
3364 #endif
3365                         erase(%[a])
3366                         setcc(%[a])             | %[a]  | |
3367 teq and $2==4   | source4 sreg4 |
3368                         test(%[1])
3369 #ifdef LOCLABS
3370                         "beql\t1f"
3371                         "clrl\t%[2]\n1:"
3372 #else
3373                         "beql\t.+4"
3374                         "clrl\t%[2]"
3375 #endif
3376                         setcc(%[2])
3377                         erase(%[2])             | %[2]  | |
3378 teq ior $2==4   | source4 sreg4 |
3379                         test(%[1])
3380 #ifdef LOCLABS
3381                         "bneq\t1f"
3382                         "bisl2\t$$1,%[2]\n1:"
3383 #else
3384                         "bneq\t.+4"
3385                         "bisl2\t$$1,%[2]"
3386 #endif
3387                         setcc(%[2])
3388                         erase(%[2])             | %[2]  | |
3389 tne             | source1or2or4 |
3390                         allocate(REG={CONST1,0})
3391                         test(%[1])
3392 #ifdef LOCLABS
3393                         "beql\t1f"
3394                         "incl\t%[a]\n1:"
3395 #else
3396                         "beql\t.+4"
3397                         "incl\t%[a]"
3398 #endif
3399                         erase(%[a])
3400                         setcc(%[a])             | %[a]  | |
3401 tne and $2==4   | source4 sreg4 |
3402                         test(%[1])
3403 #ifdef LOCLABS
3404                         "bneq\t1f"
3405                         "clrl\t%[2]\n1:"
3406 #else
3407                         "bneq\t.+4"
3408                         "clrl\t%[2]"
3409 #endif
3410                         setcc(%[2])
3411                         erase(%[2])             | %[2]  | |
3412 tne ior $2==4   | source4 sreg4 |
3413                         test(%[1])
3414 #ifdef LOCLABS
3415                         "beql\t1f"
3416                         "bisl2\t$$1,%[2]\n1:"
3417 #else
3418                         "beql\t.+4"
3419                         "bisl2\t$$1,%[2]"
3420 #endif
3421                         setcc(%[2])
3422                         erase(%[2])             | %[2]  | |
3423 cmi tlt $1==4   | source4 source4 |
3424                         allocate(REG={CONST4,0})
3425                         "cmpl\t%[1],%[2]"
3426 #ifdef LOCLABS
3427                         "bleq\t1f"
3428                         "incl\t%[a]\n1:"
3429 #else
3430                         "bleq\t.+4"
3431                         "incl\t%[a]"
3432 #endif
3433                         erase(%[a])
3434                         setcc(%[a])             | %[a]  | |
3435 ...             | NC source1or2 source1or2 |    | %[2] %[1] | cmu 4 tlt |
3436 cmi tle $1==4   | source4 source4 |
3437                         allocate(REG={CONST4,0})
3438                         "cmpl\t%[1],%[2]"
3439 #ifdef LOCLABS
3440                         "blss\t1f"
3441                         "incl\t%[a]\n1:"
3442 #else
3443                         "blss\t.+4"
3444                         "incl\t%[a]"
3445 #endif
3446                         erase(%[a])
3447                         setcc(%[a])             |  %[a]  | |
3448 ...             | NC source1or2 source1or2 |    | %[2] %[1] | cmu 4 tle |
3449 cmi teq $1==4   | source4 source4 |
3450                         allocate(REG={CONST4,0})
3451                         "cmpl\t%[1],%[2]"
3452 #ifdef LOCLABS
3453                         "bneq\t1f"
3454                         "incl\t%[a]\n1:"
3455 #else
3456                         "bneq\t.+4"
3457                         "incl\t%[a]"
3458 #endif
3459                         erase(%[a])
3460                         setcc(%[a])             | %[a]  | |
3461 ...             | NC source1or2 source1or2 |    | %[2] %[1] | cmu 4 teq |
3462 cmi tne $1==4   | source4 source4 |
3463                         allocate(REG={CONST4,0})
3464                         "cmpl\t%[1],%[2]"
3465 #ifdef LOCLABS
3466                         "beql\t1f"
3467                         "incl\t%[a]\n1:"
3468 #else
3469                         "beql\t.+4"
3470                         "incl\t%[a]"
3471 #endif
3472                         erase(%[a])
3473                         setcc(%[a])             | %[a]  | |
3474 ...             | NC source1or2 source1or2 |    | %[2] %[1] | cmu 4 tne |
3475 cmi tge $1==4   | source4 source4 |
3476                         allocate(REG={CONST4,0})
3477                         "cmpl\t%[1],%[2]"
3478 #ifdef LOCLABS
3479                         "bgtr\t1f"
3480                         "incl\t%[a]\n1:"
3481 #else
3482                         "bgtr\t.+4"
3483                         "incl\t%[a]"
3484 #endif
3485                         erase(%[a])
3486                         setcc(%[a])             | %[a]  | |
3487 ...             | NC source1or2 source1or2 |    | %[2] %[1] | cmu 4 tge |
3488 cmi tgt $1==4   | source4 source4 |
3489                         allocate(REG={CONST4,0})
3490                         "cmpl\t%[1],%[2]"
3491 #ifdef LOCLABS
3492                         "bgeq\t1f"
3493                         "incl\t%[a]\n1:"
3494 #else
3495                         "bgeq\t.+4"
3496                         "incl\t%[a]"
3497 #endif
3498                         erase(%[a])
3499                         setcc(%[a])             | %[a]  | |
3500 ...             | NC source1or2 source1or2 |    | %[2] %[1] | cmu 4 tgt |
3501 cmi tlt and $1==4 && $3==4
3502                 | source4 source4 sreg4 |
3503                         "cmpl\t%[2],%[1]"
3504 #ifdef LOCLABS
3505                         "blss\t1f"
3506                         "clrl\t%[3]\n1:"
3507 #else
3508                         "blss\t.+4"
3509                         "clrl\t%[3]"
3510 #endif
3511                         setcc(%[3])
3512                         erase(%[3])             | %[3]  | |
3513 cmi tle and $1==4 && $3==4
3514                 | source4 source4 sreg4 |
3515                         "cmpl\t%[2],%[1]"
3516 #ifdef LOCLABS
3517                         "bleq\t1f"
3518                         "clrl\t%[3]\n1:"
3519 #else
3520                         "bleq\t.+4"
3521                         "clrl\t%[3]"
3522 #endif
3523                         setcc(%[3])
3524                         erase(%[3])             | %[3]  | |
3525 cmi teq and $1==4 && $3==4
3526                 | source4 source4 sreg4 |
3527                         "cmpl\t%[2],%[1]"
3528 #ifdef LOCLABS
3529                         "beql\t1f"
3530                         "clrl\t%[3]\n1:"
3531 #else
3532                         "beql\t.+4"
3533                         "clrl\t%[3]"
3534 #endif
3535                         setcc(%[3])
3536                         erase(%[3])             | %[3]  | |
3537 cmi tne and $1==4 && $3==4
3538                 | source4 source4 sreg4 |
3539                         "cmpl\t%[2],%[1]"
3540 #ifdef LOCLABS
3541                         "bneq\t1f"
3542                         "clrl\t%[3]\n1:"
3543 #else
3544                         "bneq\t.+4"
3545                         "clrl\t%[3]"
3546 #endif
3547                         setcc(%[3])
3548                         erase(%[3])             | %[3]  | |
3549 cmi tge and $1==4 && $3==4
3550                 | source4 source4 sreg4 |
3551                         "cmpl\t%[2],%[1]"
3552 #ifdef LOCLABS
3553                         "bgeq\t1f"
3554                         "clrl\t%[3]\n1:"
3555 #else
3556                         "bgeq\t.+4"
3557                         "clrl\t%[3]"
3558 #endif
3559                         setcc(%[3])
3560                         erase(%[3])             | %[3]  | |
3561 cmi tgt and $1==4 && $3==4
3562                 | source4 source4 sreg4 |
3563                         "cmpl\t%[2],%[1]"
3564 #ifdef LOCLABS
3565                         "bgtr\t1f"
3566                         "clrl\t%[3]\n1:"
3567 #else
3568                         "bgtr\t.+4"
3569                         "clrl\t%[3]"
3570 #endif
3571                         setcc(%[3])
3572                         erase(%[3])             | %[3]  | |
3573 cmi tlt ior $1==4 && $3==4
3574                 | source4 source4 sreg4 |
3575                         "cmpl\t%[2],%[1]"
3576 #ifdef LOCLABS
3577                         "bgeq\t1f"
3578                         "bisl2\t$$1,%[3]\n1:"
3579 #else
3580                         "bgeq\t.+7"
3581                         "bisl2\t$$1,%[3]"
3582 #endif
3583                         setcc(%[3])
3584                         erase(%[3])             | %[3]  | |
3585 cmi tle ior $1==4 && $3==4
3586                 | source4 source4 sreg4 |
3587                         "cmpl\t%[2],%[1]"
3588 #ifdef LOCLABS
3589                         "bgtr\t1f"
3590                         "bisl2\t$$1,%[3]\n1:"
3591 #else
3592                         "bgtr\t.+7"
3593                         "bisl2\t$$1,%[3]"
3594 #endif
3595                         setcc(%[3])
3596                         erase(%[3])             | %[3]  | |
3597 cmi teq ior $1==4 && $3==4
3598                 | source4 source4 sreg4 |
3599                         "cmpl\t%[2],%[1]"
3600 #ifdef LOCLABS
3601                         "bneq\t1f"
3602                         "bisl2\t$$1,%[3]\n1:"
3603 #else
3604                         "bneq\t.+7"
3605                         "bisl2\t$$1,%[3]"
3606 #endif
3607                         setcc(%[3])
3608                         erase(%[3])             | %[3]  | |
3609 cmi tne ior $1==4 && $3==4
3610                 | source4 source4 sreg4 |
3611                         "cmpl\t%[2],%[1]"
3612 #ifdef LOCLABS
3613                         "beql\t1f"
3614                         "bisl2\t$$1,%[3]\n1:"
3615 #else
3616                         "beql\t.+7"
3617                         "bisl2\t$$1,%[3]"
3618 #endif
3619                         setcc(%[3])
3620                         erase(%[3])             | %[3]  | |
3621 cmi tge ior $1==4 && $3==4
3622                 | source4 source4 sreg4 |
3623                         "cmpl\t%[2],%[1]"
3624 #ifdef LOCLABS
3625                         "blss\t1f"
3626                         "bisl2\t$$1,%[3]\n1:"
3627 #else
3628                         "blss\t.+7"
3629                         "bisl2\t$$1,%[3]"
3630 #endif
3631                         setcc(%[3])
3632                         erase(%[3])             | %[3]  | |
3633 cmi tgt ior $1==4 && $3==4
3634                 | source4 source4 sreg4 |
3635                         "cmpl\t%[2],%[1]"
3636 #ifdef LOCLABS
3637                         "bleq\t1f"
3638                         "bisl2\t$$1,%[3]\n1:"
3639 #else
3640                         "bleq\t.+7"
3641                         "bisl2\t$$1,%[3]"
3642 #endif
3643                         setcc(%[3])
3644                         erase(%[3])             | %[3]  | |
3645 #ifdef FLOAT4
3646 cmf tlt $1==4   | source4 source4 |
3647                         allocate(REG={CONST1,0})
3648                         "cmpf\t%[1],%[2]"
3649 #ifdef LOCLABS
3650                         "bleq\t1f"
3651                         "incl\t%[a]\n1:"
3652 #else
3653                         "bleq\t.+4"
3654                         "incl\t%[a]"
3655 #endif
3656                         erase(%[a])
3657                         setcc(%[a])             | %[a]  | |
3658 cmf tle $1==4   | source4 source4 |
3659                         allocate(REG={CONST1,0})
3660                         "cmpf\t%[1],%[2]"
3661 #ifdef LOCLABS
3662                         "blss\t1f"
3663                         "incl\t%[a]\n1:"
3664 #else
3665                         "blss\t.+4"
3666                         "incl\t%[a]"
3667 #endif
3668                         erase(%[a])
3669                         setcc(%[a])             |  %[a]  | |
3670 cmf teq $1==4   | source4 source4 |
3671                         allocate(REG={CONST1,0})
3672                         "cmpf\t%[1],%[2]"
3673 #ifdef LOCLABS
3674                         "bneq\t1f"
3675                         "incl\t%[a]\n1:"
3676 #else
3677                         "bneq\t.+4"
3678                         "incl\t%[a]"
3679 #endif
3680                         erase(%[a])
3681                         setcc(%[a])             | %[a]  | |
3682 cmf tne $1==4   | source4 source4 |
3683                         allocate(REG={CONST1,0})
3684                         "cmpf\t%[1],%[2]"
3685 #ifdef LOCLABS
3686                         "beql\t1f"
3687                         "incl\t%[a]\n1:"
3688 #else
3689                         "beql\t.+4"
3690                         "incl\t%[a]"
3691 #endif
3692                         erase(%[a])
3693                         setcc(%[a])             | %[a]  | |
3694 cmf tge $1==4   | source4 source4 |
3695                         allocate(REG={CONST1,0})
3696                         "cmpf\t%[1],%[2]"
3697 #ifdef LOCLABS
3698                         "bgtr\t1f"
3699                         "incl\t%[a]\n1:"
3700 #else
3701                         "bgtr\t.+4"
3702                         "incl\t%[a]"
3703 #endif
3704                         erase(%[a])
3705                         setcc(%[a])             | %[a]  | |
3706 cmf tgt $1==4   | source4 source4 |
3707                         allocate(REG={CONST1,0})
3708                         "cmpf\t%[1],%[2]"
3709 #ifdef LOCLABS
3710                         "bgeq\t1f"
3711                         "incl\t%[a]\n1:"
3712 #else
3713                         "bgeq\t.+4"
3714                         "incl\t%[a]"
3715 #endif
3716                         erase(%[a])
3717                         setcc(%[a])             | %[a]  | |
3718 #endif /* FLOAT4 */
3719 #ifdef FLOAT8
3720 cmf tlt $1==8   | source8 source8 |
3721                         allocate(%[1],%[2],REG)
3722                         "cmpd\t%[1],%[2]"
3723 #ifdef LOCLABS
3724                         "bleq\t1f"
3725                         "movl\t$$1,%[a]"
3726                         "brb\t2f\n1:"
3727                         "clrl\t%[a]\n2:"
3728 #else
3729                         "bleq\t.+9"
3730                         "movl\t$$1,%[a]"
3731                         "brb\t.+4"
3732                         "clrl\t%[a]"
3733 #endif
3734
3735                         erase(%[a])
3736                         setcc(%[a])             | %[a]  | |
3737 cmf tle $1==8   | source8 source8 |
3738                         allocate(%[1],%[2],REG)
3739                         "cmpd\t%[1],%[2]"
3740 #ifdef LOCLABS
3741                         "blss\t1f"
3742                         "movl\t$$1,%[a]"
3743                         "brb\t2f\n1:"
3744                         "clrl\t%[a]\n2:"
3745 #else
3746                         "blss\t.+9"
3747                         "movl\t$$1,%[a]"
3748                         "brb\t.+4"
3749                         "clrl\t%[a]"
3750 #endif
3751                         erase(%[a])
3752                         setcc(%[a])             |  %[a]  | |
3753 cmf teq $1==8   | source8 source8 |
3754                         allocate(%[1],%[2],REG)
3755                         "cmpd\t%[1],%[2]"
3756 #ifdef LOCLABS
3757                         "bneq\t1f"
3758                         "movl\t$$1,%[a]"
3759                         "brb\t2f\n1:"
3760                         "clrl\t%[a]\n2:"
3761 #else
3762                         "bneq\t.+9"
3763                         "movl\t$$1,%[a]"
3764                         "brb\t.+4"
3765                         "clrl\t%[a]"
3766 #endif
3767                         erase(%[a])
3768                         setcc(%[a])             | %[a]  | |
3769 cmf tne $1==8   | source8 source8 |
3770                         allocate(%[1],%[2],REG)
3771                         "cmpd\t%[1],%[2]"
3772 #ifdef LOCLABS
3773                         "beql\t1f"
3774                         "movl\t$$1,%[a]"
3775                         "brb\t2f\n1:"
3776                         "clrl\t%[a]\n2:"
3777 #else
3778                         "beql\t.+9"
3779                         "movl\t$$1,%[a]"
3780                         "brb\t.+4"
3781                         "clrl\t%[a]"
3782 #endif
3783                         erase(%[a])
3784                         setcc(%[a])             | %[a]  | |
3785 cmf tge $1==8   | source8 source8 |
3786                         allocate(%[1],%[2],REG)
3787                         "cmpd\t%[1],%[2]"
3788 #ifdef LOCLABS
3789                         "bgtr\t1f"
3790                         "movl\t$$1,%[a]"
3791                         "brb\t2f\n1:"
3792                         "clrl\t%[a]\n2:"
3793 #else
3794                         "bgtr\t.+9"
3795                         "movl\t$$1,%[a]"
3796                         "brb\t.+4"
3797                         "clrl\t%[a]"
3798 #endif
3799                         erase(%[a])
3800                         setcc(%[a])             | %[a]  | |
3801 cmf tgt $1==8   | source8 source8 |
3802                         allocate(%[1],%[2],REG)
3803                         "cmpd\t%[1],%[2]"
3804 #ifdef LOCLABS
3805                         "bgeq\t1f"
3806                         "movl\t$$1,%[a]"
3807                         "brb\t2f\n1:"
3808                         "clrl\t%[a]\n2:"
3809 #else
3810                         "bgeq\t.+9"
3811                         "movl\t$$1,%[a]"
3812                         "brb\t.+4"
3813                         "clrl\t%[a]"
3814 #endif
3815                         erase(%[a])
3816                         setcc(%[a])             | %[a]  | |
3817 #endif /* FLOAT8 */
3818 /* Remember that cmu was replaced by cmp. */
3819 cmp tlt         | source4 source4 |
3820                         allocate(REG={CONST1,0})
3821                         "cmpl\t%[1],%[2]"
3822 #ifdef LOCLABS
3823                         "blequ\t1f"
3824                         "incl\t%[a]\n1:"
3825 #else
3826                         "blequ\t.+4"
3827                         "incl\t%[a]"
3828 #endif
3829                         erase(%[a])
3830                         setcc(%[a])             | %[a]  | |
3831 ...             | NC source1 source1 |
3832                         allocate(REG={CONST1,0})
3833                         "cmpb\t%[1],%[2]"
3834 #ifdef LOCLABS
3835                         "blequ\t1f"
3836                         "incl\t%[a]\n1:"
3837 #else
3838                         "blequ\t.+4"
3839                         "incl\t%[a]"
3840 #endif
3841                         erase(%[a])
3842                         setcc(%[a])             | %[a]  | |
3843 ...             | NC source2 source2 |
3844                         allocate(REG={CONST1,0})
3845                         "cmpw\t%[1],%[2]"
3846 #ifdef LOCLABS
3847                         "blequ\t1f"
3848                         "incl\t%[a]\n1:"
3849 #else
3850                         "blequ\t.+4"
3851                         "incl\t%[a]"
3852 #endif
3853                         erase(%[a])
3854                         setcc(%[a])             | %[a]  | |
3855 cmp tle         | source4 source4 |
3856                         allocate(REG={CONST1,0})
3857                         "cmpl\t%[1],%[2]"
3858 #ifdef LOCLABS
3859                         "blssu\t1f"
3860                         "incl\t%[a]\n1:"
3861 #else
3862                         "blssu\t.+4"
3863                         "incl\t%[a]"
3864 #endif
3865                         erase(%[a])
3866                         setcc(%[a])             | %[a]  | |
3867 ...             | NC source1 source1 |
3868                         allocate(REG={CONST1,0})
3869                         "cmpb\t%[1],%[2]"
3870 #ifdef LOCLABS
3871                         "blssu\t1f"
3872                         "incl\t%[a]\n1:"
3873 #else
3874                         "blssu\t.+4"
3875                         "incl\t%[a]"
3876 #endif
3877                         erase(%[a])
3878                         setcc(%[a])             | %[a]  | |
3879 ...             | NC source2 source2 |
3880                         allocate(REG={CONST1,0})
3881                         "cmpw\t%[1],%[2]"
3882 #ifdef LOCLABS
3883                         "blssu\t1f"
3884                         "incl\t%[a]\n1:"
3885 #else
3886                         "blssu\t.+4"
3887                         "incl\t%[a]"
3888 #endif
3889                         erase(%[a])
3890                         setcc(%[a])             | %[a]  | |
3891 cmp teq         | source4 source4 |
3892                         allocate(REG={CONST1,0})
3893                         "cmpl\t%[1],%[2]"
3894 #ifdef LOCLABS
3895                         "bnequ\t1f"
3896                         "incl\t%[a]\n1:"
3897 #else
3898                         "bnequ\t.+4"
3899                         "incl\t%[a]"
3900 #endif
3901                         erase(%[a])
3902                         setcc(%[a])             | %[a]  | |
3903 ...             | NC source1 source1 |
3904                         allocate(REG={CONST1,0})
3905                         "cmpb\t%[1],%[2]"
3906 #ifdef LOCLABS
3907                         "bnequ\t1f"
3908                         "incl\t%[a]\n1:"
3909 #else
3910                         "bnequ\t.+4"
3911                         "incl\t%[a]"
3912 #endif
3913                         erase(%[a])
3914                         setcc(%[a])             | %[a]  | |
3915 ...             | NC source2 source2 |
3916                         allocate(REG={CONST1,0})
3917                         "cmpw\t%[1],%[2]"
3918 #ifdef LOCLABS
3919                         "bnequ\t1f"
3920                         "incl\t%[a]\n1:"
3921 #else
3922                         "bnequ\t.+4"
3923                         "incl\t%[a]"
3924 #endif
3925                         erase(%[a])
3926                         setcc(%[a])             | %[a]  | |
3927 cmp tne         | source4 source4 |
3928                         allocate(REG={CONST1,0})
3929                         "cmpl\t%[1],%[2]"
3930 #ifdef LOCLABS
3931                         "beqlu\t1f"
3932                         "incl\t%[a]\n1:"
3933 #else
3934                         "beqlu\t.+4"
3935                         "incl\t%[a]"
3936 #endif
3937                         erase(%[a])
3938                         setcc(%[a])             | %[a]  | |
3939 ...             | NC source1 source1 |
3940                         allocate(REG={CONST1,0})
3941                         "cmpb\t%[1],%[2]"
3942 #ifdef LOCLABS
3943                         "beqlu\t1f"
3944                         "incl\t%[a]\n1:"
3945 #else
3946                         "beqlu\t.+4"
3947                         "incl\t%[a]"
3948 #endif
3949                         erase(%[a])
3950                         setcc(%[a])             | %[a]  | |
3951 ...             | NC source2 source2 |
3952                         allocate(REG={CONST1,0})
3953                         "cmpw\t%[1],%[2]"
3954 #ifdef LOCLABS
3955                         "beqlu\t1f"
3956                         "incl\t%[a]\n1:"
3957 #else
3958                         "beqlu\t.+4"
3959                         "incl\t%[a]"
3960 #endif
3961                         erase(%[a])
3962                         setcc(%[a])             | %[a]  | |
3963 cmp tge         | source4 source4 |
3964                         allocate(REG={CONST1,0})
3965                         "cmpl\t%[1],%[2]"
3966 #ifdef LOCLABS
3967                         "bgtru\t1f"
3968                         "incl\t%[a]\n1:"
3969 #else
3970                         "bgtru\t.+4"
3971                         "incl\t%[a]"
3972 #endif
3973                         erase(%[a])
3974                         setcc(%[a])             | %[a]  | |
3975 ...             | NC source1 source1 |
3976                         allocate(REG={CONST1,0})
3977                         "cmpb\t%[1],%[2]"
3978 #ifdef LOCLABS
3979                         "bgtru\t1f"
3980                         "incl\t%[a]\n1:"
3981 #else
3982                         "bgtru\t.+4"
3983                         "incl\t%[a]"
3984 #endif
3985                         erase(%[a])
3986                         setcc(%[a])             | %[a]  | |
3987 ...             | NC source2 source2 |
3988                         allocate(REG={CONST1,0})
3989                         "cmpw\t%[1],%[2]"
3990 #ifdef LOCLABS
3991                         "bgtru\t1f"
3992                         "incl\t%[a]\n1:"
3993 #else
3994                         "bgtru\t.+4"
3995                         "incl\t%[a]"
3996 #endif
3997                         erase(%[a])
3998                         setcc(%[a])             | %[a]  | |
3999 cmp tgt         | source4 source4 |
4000                         allocate(REG={CONST1,0})
4001                         "cmpl\t%[1],%[2]"
4002 #ifdef LOCLABS
4003                         "bgequ\t1f"
4004                         "incl\t%[a]\n1:"
4005 #else
4006                         "bgequ\t.+4"
4007                         "incl\t%[a]"
4008 #endif
4009                         erase(%[a])
4010                         setcc(%[a])             | %[a]  | |
4011 ...             | NC source1 source1 |
4012                         allocate(REG={CONST1,0})
4013                         "cmpb\t%[1],%[2]"
4014 #ifdef LOCLABS
4015                         "bgequ\t1f"
4016                         "incl\t%[a]\n1:"
4017 #else
4018                         "bgequ\t.+4"
4019                         "incl\t%[a]"
4020 #endif
4021                         erase(%[a])
4022                         setcc(%[a])             | %[a]  | |
4023 ...             | NC source2 source2 |
4024                         allocate(REG={CONST1,0})
4025                         "cmpw\t%[1],%[2]"
4026 #ifdef LOCLABS
4027                         "bgequ\t1f"
4028                         "incl\t%[a]\n1:"
4029 #else
4030                         "bgequ\t.+4"
4031                         "incl\t%[a]"
4032 #endif
4033                         erase(%[a])
4034                         setcc(%[a])             | %[a]  | |
4035 cmp teq and $3==4
4036                 | source4 source4 sreg4 |
4037                         "cmpl\t%[2],%[1]"
4038 #ifdef LOCLABS
4039                         "beql\t1f"
4040                         "clrl\t%[3]\n1:"
4041 #else
4042                         "beql\t.+4"
4043                         "clrl\t%[3]"
4044 #endif
4045                         setcc(%[3])
4046                         erase(%[3])             | %[3]  | |
4047 cmp tne and $3==4
4048                 | source4 source4 sreg4 |
4049                         "cmpl\t%[2],%[1]"
4050 #ifdef LOCLABS
4051                         "bneq\t1f"
4052                         "clrl\t%[3]\n1:"
4053 #else
4054                         "bneq\t.+4"
4055                         "clrl\t%[3]"
4056 #endif
4057                         setcc(%[3])
4058                         erase(%[3])             | %[3]  | |
4059 cmp teq ior $3==4
4060                 | source4 source4 sreg4 |
4061                         "cmpl\t%[2],%[1]"
4062 #ifdef LOCLABS
4063                         "bneq\t1f"
4064                         "bisl2\t$$1,%[3]\n1:"
4065 #else
4066                         "bneq\t.+7"
4067                         "bisl2\t$$1,%[3]"
4068 #endif
4069                         setcc(%[3])
4070                         erase(%[3])             | %[3]  | |
4071 cmp tne ior $3==4
4072                 | source4 source4 sreg4 |
4073                         "cmpl\t%[2],%[1]"
4074 #ifdef LOCLABS
4075                         "beql\t1f"
4076                         "bisl2\t$$1,%[3]\n1:"
4077 #else
4078                         "beql\t.+7"
4079                         "bisl2\t$$1,%[3]"
4080 #endif
4081                         setcc(%[3])
4082                         erase(%[3])             | %[3]  | |
4083 cms teq $1==4   |       |                       |       | cmp teq       |
4084 cms tne $1==4   |       |                       |       | cmp tne       |
4085
4086 /****************************************
4087  * Group 13 : Branch instructions       *
4088  ****************************************/
4089
4090 bra             | STACK |
4091                         "jbr\t$1"                |       | |
4092 blt             | source4 source4 STACK |
4093                         "cmpl\t%[1],%[2]"
4094                         "jgtr\t$1"              |       | |
4095 ...             | NC source2 source2 STACK |
4096                         "cmpw\t%[1],%[2]"
4097                         "jgtru\t$1"             |       | |
4098 ...             | NC source1 source1 STACK |
4099                         "cmpb\t%[1],%[2]"
4100                         "jgtru\t$1"             |       | |
4101 ...             | NC source4 STACK |
4102                         "cmpl\t%[1],(sp)+"
4103                         "jgtr\t$1"              |       | |
4104 ...             | STACK |
4105                         "cmpl\t(sp)+,(sp)+"
4106                         "jgtr\t$1"              |       | |
4107 ble             | source4 source4 STACK |
4108                         "cmpl\t%[1],%[2]"
4109                         "jgeq\t$1"              |       | |
4110 ...             | NC source2 source2 STACK |
4111                         "cmpw\t%[1],%[2]"
4112                         "jgequ\t$1"             |       | |
4113 ...             | NC source1 source1 STACK |
4114                         "cmpb\t%[1],%[2]"
4115                         "jgequ\t$1"             |       | |
4116 ...             | NC source4 STACK |
4117                         "cmpl\t%[1],(sp)+"
4118                         "jgeq\t$1"              |       | |
4119 ...             | STACK |
4120                         "cmpl\t(sp)+,(sp)+"
4121                         "jgeq\t$1"              |       | |
4122 beq             | source4 source4 STACK |
4123                         "cmpl\t%[1],%[2]"
4124                         "jeql\t$1"              |       | |
4125 ...             | NC source2 source2 STACK |
4126                         "cmpw\t%[1],%[2]"
4127                         "jeqlu\t$1"             |       | |
4128 ...             | NC source1 source1 STACK |
4129                         "cmpb\t%[1],%[2]"
4130                         "jeqlu\t$1"             |       | |
4131 ...             | NC source4 STACK |
4132                         "cmpl\t%[1],(sp)+"
4133                         "jeql\t$1"              |       | |
4134 ...             | STACK |
4135                         "cmpl\t(sp)+,(sp)+"
4136                         "jeql\t$1"              |       | |
4137 bne             | source4 source4 STACK |
4138                         "cmpl\t%[1],%[2]"
4139                         "jneq\t$1"              |       | |
4140 ...             | NC source2 source2 STACK |
4141                         "cmpw\t%[1],%[2]"
4142                         "jnequ\t$1"             |       | |
4143 ...             | NC source1 source1 STACK |
4144                         "cmpb\t%[1],%[2]"
4145                         "jnequ\t$1"             |       | |
4146 ...             | NC source4 STACK |
4147                         "cmpl\t%[1],(sp)+"
4148                         "jneq\t$1"              |       | |
4149 ...             | STACK |
4150                         "cmpl\t(sp)+,(sp)+"
4151                         "jneq\t$1"              |       | |
4152 bge             | source4 source4 STACK |
4153                         "cmpl\t%[1],%[2]"
4154                         "jleq\t$1"              |       | |
4155 ...             | NC source2 source2 STACK |
4156                         "cmpw\t%[1],%[2]"
4157                         "jlequ\t$1"             |       | |
4158 ...             | NC source1 source1 STACK |
4159                         "cmpb\t%[1],%[2]"
4160                         "jlequ\t$1"             |       | |
4161 ...             | NC source4 STACK |
4162                         "cmpl\t%[1],(sp)+"
4163                         "jleq\t$1"              |       | |
4164 ...             | STACK |
4165                         "cmpl\t(sp)+,(sp)+"
4166                         "jleq\t$1"              |       | |
4167 bgt             | source4 source4 STACK |
4168                         "cmpl\t%[1],%[2]"
4169                         "jlss\t$1"              |       | |
4170 ...             | NC source2 source2 STACK |
4171                         "cmpw\t%[1],%[2]"
4172                         "jlssu\t$1"             |       | |
4173 ...             | NC source1 source1 STACK |
4174                         "cmpb\t%[1],%[2]"
4175                         "jlssu\t$1"             |       | |
4176 ...             | NC source4 STACK |
4177                         "cmpl\t%[1],(sp)+"
4178                         "jlss\t$1"              |       | |
4179 ...             | STACK |
4180                         "cmpl\t(sp)+,(sp)+"
4181                         "jlss\t$1"              |       | |
4182 zlt             | source4 STACK |
4183                         test(%[1])
4184                         "jlss\t$1"
4185                         samecc                  |       | |
4186 ...             | NC source1or2 |       | %[1]  | asp 4 |
4187 zle             | source4 STACK |
4188                         test(%[1])
4189                         "jleq\t$1"
4190                         samecc                  |       | |
4191 ...             | NC source1or2 |       | %[1]  | zeq $1 |
4192 zeq             | source1or2or4 STACK |
4193                         test(%[1])
4194                         "jeql\t$1"
4195                         samecc                  |       | |
4196 zne             | source1or2or4 STACK |
4197                         test(%[1])
4198                         "jneq\t$1"
4199                         samecc                  |       | |
4200 zge             | source4 STACK |
4201                         test(%[1])
4202                         "jgeq\t$1"
4203                         samecc                  |       | |
4204 ...             | NC source1or2 |       | %[1]  | asp 4 bra $1 |
4205 zgt             | source4 STACK |
4206                         test(%[1])
4207                         "jgtr\t$1"
4208                         samecc                  |       | |
4209 ...             | NC source1or2 |       | %[1]  | zne $1 |
4210 cmf zlt $1==4   | source4 source4 STACK |
4211                         "cmpf\t%[1],%[2]"
4212                         "jgtr\t$2"               |       | |
4213 cmf zle $1==4   | source4 source4 STACK |
4214                         "cmpf\t%[1],%[2]"
4215                         "jgeq\t$2"               |       | |
4216 cmf zne $1==4   | source4 source4 STACK |
4217                         "cmpf\t%[1],%[2]"
4218                         "jneq\t$2"               |       | |
4219 cmf zeq $1==4   | source4 source4 STACK |
4220                         "cmpf\t%[1],%[2]"
4221                         "jeql\t$2"               |       | |
4222 cmf zge $1==4   | source4 source4 STACK |
4223                         "cmpf\t%[1],%[2]"
4224                         "jleq\t$2"               |       | |
4225 cmf zgt $1==4   | source4 source4 STACK |
4226                         "cmpf\t%[1],%[2]"
4227                         "jlss\t$2"               |       | |
4228 cmf zlt $1==8   | source8 source8 |
4229                         remove(ALL)
4230                         "cmpd\t%[1],%[2]"
4231                         "jgtr\t$2"               |       | |
4232 cmf zle $1==8   | source8 source8 |
4233                         remove(ALL)
4234                         "cmpd\t%[1],%[2]"
4235                         "jgeq\t$2"               |       | |
4236 cmf zne $1==8   | source8 source8 |
4237                         remove(ALL)
4238                         "cmpd\t%[1],%[2]"
4239                         "jneq\t$2"               |       | |
4240 cmf zeq $1==8   | source8 source8 |
4241                         remove(ALL)
4242                         "cmpd\t%[1],%[2]"
4243                         "jeql\t$2"               |       | |
4244 cmf zge $1==8   | source8 source8 |
4245                         remove(ALL)
4246                         "cmpd\t%[1],%[2]"
4247                         "jleq\t$2"               |       | |
4248 cmf zgt $1==8   | source8 source8 |
4249                         remove(ALL)
4250                         "cmpd\t%[1],%[2]"
4251                         "jlss\t$2"               |       | |
4252 cmp zlt         | source4 source4 STACK |
4253                         "cmpl\t%[1],%[2]"
4254                         "jgtru\t$2"              |       | |
4255 ...             | NC source1or2 source1or2 | | %[2] %[1] | blt $2 |
4256 cmp zle         | source4 source4 STACK |
4257                         "cmpl\t%[1],%[2]"
4258                         "jgequ\t$2"              |       | |
4259 ...             | NC source1or2 source1or2 | | %[2] %[1] | ble $2 |
4260 cmp zne         | |                                     | | bne $2 |
4261 cmp zeq         | |                                     | | beq $2 |
4262 cmp zge         | source4 source4 STACK |
4263                         "cmpl\t%[1],%[2]"
4264                         "jlequ\t$2"              |       | |
4265 ...             | NC source1or2 source1or2 | | %[2] %[1] | bge $2 |
4266 cmp zgt         | source4 source4 STACK |
4267                         "cmpl\t%[1],%[2]"
4268                         "jlssu\t$2"              |       | |
4269 ...             | NC source1or2 source1or2 | | %[2] %[1] | bgt $2 |
4270 cms zeq $1==4   | |                             |       | cmp zeq $2 |
4271 cms zne $1==4   | |                             |       | cmp zne $2 |
4272
4273 /************************************************
4274  * Group 14 : Procedure call instructions       *
4275  ************************************************/
4276
4277 cai asp $2%4 == 0 && $2>=0 && $2 < 1024
4278                 | reg4 |
4279                         remove(ALL)
4280                         "calls\t$$%($2/4%),(%[1])"      |       | |
4281 cai             | reg4 |
4282                         remove(ALL)
4283                         "calls\t$$0,(%[1])"             |       | |
4284 cal asp $2%4 == 0 && $2>=0 && $2 < 1024
4285                 | |     remove(ALL)
4286                         "calls\t$$%($2/4%),$1"          |       | |
4287 cal             | |     remove(ALL)
4288                         "calls\t$$0,$1"                 |       | |
4289 lfr $1==4       | |                                     | R0    | |
4290 lfr $1==8       | |                                     | QR0   | |
4291 asp ret $2==0   | | "ret"                               |       | |
4292 ass ret $2==0   | | "ret"                               |       | |
4293 asp lfr ret $2==$3 | | "ret"                            |       | |
4294 ass lfr ret $2==$3 | | "ret"                            |       | |
4295 lfr ret $1==$2  | | "ret"                               |       | |
4296 ret $1==0       | | "ret"                               |       | |
4297 ret $1==4       | NC bigsource4 |
4298                         move(%[1],R0)
4299                         "ret"                           |       | |
4300 ...             | STACK |
4301                         "movl\t(sp)+,r0"
4302                         "ret"                           |       | |
4303 ret $1==8       | NC bigsource8 |
4304                         move(%[1],QR0)
4305                         "ret"                           |       | |
4306 ...             | STACK |
4307                         "movq\t(sp)+,r0"
4308                         "ret"                           |       | |
4309
4310 /********************************
4311  * Group 15 : Miscellaneous     *
4312  ********************************/
4313
4314 #ifdef REGVARS
4315 asp $1==4       | bigsource4 - regch4 |         |       | |
4316 #else /* REGVARS */
4317 asp $1==4       | NC bigsource4 |               |       | |
4318 #endif /* REGVARS */
4319 ...             | STACK |
4320                         "tstl\t(sp)+"           |       | | (2,7)
4321 asp $1>0        | STACK |
4322                         "addl2\t$$$1,sp"        |       | |
4323 asp $1==(0-4)   | |                             | {CONST4,0} | |
4324 asp $1==(0-8)   | |                             | {CONST8,"0"} | |
4325 asp             | STACK |
4326                         "subl2\t$$%(0-$1%),sp"  |       | |
4327 ass $1==4       | source4 |
4328                         remove(ALL)
4329                         "addl2\t%[1],sp"        |       | |
4330 ass !defined($1) | source4 |
4331                         remove(ALL)
4332                         move(%[1],R2)   /* R2 <= leave return area intact. */
4333                         "jsb\t.ass"
4334                         erase(R2)               |       | |
4335 blm $1==4       | nonexist1 nonexist1 |
4336                         remove(ALL)
4337                         "movl\t%[2],%[1]"       |       | |
4338 blm $1==8       | nonexist1 nonexist1 |
4339                         remove(ALL)
4340                         "movq\t%[2],%[1]"       |       | |
4341 blm $1==12      | sreg4 sreg4 |
4342                         remove(ALL)
4343                         "movl\t(%[2])+,(%[1])+"
4344                         "movq\t(%[2]),(%[1])"
4345                         erase(%[1]) erase(%[2]) |       | |
4346 blm $1==16      | sreg4 sreg4 |
4347                         remove(ALL)
4348                         "movq\t(%[2])+,(%[1])+"
4349                         "movq\t(%[2]),(%[1])"
4350                         erase(%[1]) erase(%[2]) |       | |
4351 blm             | sreg4 sreg4 |
4352                         remove(ALL)
4353                         allocate(REG={CONST1,$1/4})
4354 #ifdef LOCLABS
4355                         "1:\nmovl\t(%[2])+,(%[1])+"
4356                         "sobgtr\t%[a],1b"
4357 #else
4358                         "\nmovl\t(%[2])+,(%[1])+"
4359                         "sobgtr\t%[a],.-3"
4360 #endif
4361                         erase(%[1]) erase(%[2]) erase(%[a])
4362                                                 |       | |
4363 bls $1==4       | |     remove(ALL)
4364                         move({CONST1,4},R0)
4365                         "jsb\t.bls"
4366                         erase(R0)               |       | |
4367 bls !defined($1) | source4 |
4368                         remove(ALL)
4369                         move(%[1],R0)
4370                         "jsb\t.bls"
4371                         erase(R0)               |       | |
4372 csa $1==4       | STACK |
4373                         "jmp\t.csa4"            |       | |
4374 csa !defined($1) | source4 |
4375                         remove(ALL)
4376                         move(%[1],R0)
4377                         "jmp\t.csa"
4378                         erase(R0)               |       | |
4379 csb $1==4       | STACK |
4380                         "jmp\t.csb4"            |       | |
4381 csb !defined($1) | source4 |
4382                         remove(ALL)
4383                         move(%[1],R0)
4384                         "jmp\t.csb"
4385                         erase(R0)               |       | |
4386 dch             | reg4  |       | {displ4,%[1],"12"}    | |
4387 dup stl $1==4   |       |                       |       | stl $2 lol $2 |
4388 dup $1==4       | dups4 |               | %[1] %[1]     | |
4389 #ifdef REGVARS
4390 dup $1==8       | bigsource8-regch8 |   | %[1] %[1]     | |
4391 #else /* REGVARS */
4392 dup $1==8       | bigsource8 |          | %[1] %[1]     | |
4393 #endif /* REGVARS */
4394 ...             | dups4 dups4 |         | %[2] %[1] %[2] %[1] | |
4395 dup             | STACK |
4396                         allocate(REG,REG={CONST1,$1/4})
4397                         "addl3\tsp,$$$1,%[a]"
4398 #ifdef LOCLABS
4399                         "1:\nmovl\t-(%[a]),-(sp)"
4400                         "sobgtr\t%[b],1b"
4401 #else
4402                         "movl\t-(%[a]),-(sp)"
4403                         "sobgtr\t%[b],.-3"
4404 #endif
4405                         erase(%[b])             |       | |
4406 dus $1==4       | source4 |
4407                         remove(ALL)
4408                         allocate(REG,REG)
4409                         "ashl\t$$-2,%[1],%[b]"
4410                         "addl3\tsp,%[1],%[a]"
4411 #ifdef LOCLABS
4412                         "1:\nmovl\t-(%[a]),-(sp)"
4413                         "sobgtr\t%[b],1b"
4414 #else
4415                         "movl\t-(%[a]),-(sp)"
4416                         "sobgtr\t%[b],.-3"
4417 #endif
4418                                                 |       | |
4419 dus !defined($1) | source4 |
4420                         remove(ALL)
4421                         move(%[1],R0)
4422                         "jsb\t.dus"
4423                         erase(R0)               |       | |
4424 exg $1==4       | bigsource4-regch4 bigsource4-regch4 | | %[1] %[2] | |
4425 exg $1==8       | bigsource8-regch8 bigsource8-regch8 | | %[1] %[2] | |
4426 exg defined($1) | STACK |
4427                         move({CONST4,$1},R0)
4428                         "jsb\t.exg"
4429                         erase(R0)               |       | |
4430 exg !defined($1) | source4 |
4431                         remove(ALL)
4432                         move(%[1],R0)
4433                         "jsb\t.exg"
4434                         erase(R0)               |       | |
4435 fil             | |     "movl\t$$$1,hol0+4"     |       | |
4436 lim             | |     allocate(REG)
4437                         "movl\t.trpim,%[a]"     | %[a]  | |
4438 lin             | |     "movl\t$$$1,hol0"       |       | |
4439 lni             | |     "incl\thol0"            |       | |
4440 gto             | STACK |
4441                         "pushl\t$$$1"
4442                         "jmp\t.gto"             |       | |
4443 lor $1==0       | |                             | LB    | |
4444 lor $1==1       | STACK |
4445                         allocate(REG)
4446                         "movl\tsp,%[a]"         | %[a]  | |
4447 lor $1==2       | |     allocate(REG)
4448                         "movl\t.reghp,%[a]"     | %[a] | |
4449 lpb             | bigsource4 |
4450                         remove(ALL)
4451                         move(%[1],R0)
4452                         "jsb\t.lpb"
4453                         erase(R0)               | R0    | |
4454 mon             | STACK |
4455                         "jsb\t.mon"             |       | |
4456 nop             | STACK |
4457 #ifdef DEBUG
4458                         "jsb\t.nop"
4459 #endif
4460                                                 |       | |
4461
4462 #ifdef DORCK
4463 rck $1==4       | STACK |
4464                         "jsb\t.rck4"            |       | |
4465 rck !defined($1) | source4 |
4466                         remove(ALL)
4467                         move(%[1],R0)
4468                         "jsb\t.rck"
4469                         erase(R0)               |       | |
4470 #else /* DORCK */
4471 #ifdef REGVARS
4472 rck defined($1) | bigsource4-regch4 |           |       | |
4473 rck !defined($1) | bigsource4-regch4 bigsource4-regch4 | | | |
4474 #else /* REGVARS */
4475 rck defined($1) | bigsource4 |          |       | |
4476 rck !defined($1) | bigsource4 bigsource4 |      |       | |
4477 #endif /* REGVARS */
4478 #endif /* DORCK */
4479 rtt             | | "ret"                       |       | |
4480 sig             | STACK |
4481                         "jsb\t.sig"             |       | |
4482 sim             | STACK |
4483                         "jsb\t.sim"             |       | |
4484 str $1==0       | STACK |
4485                         "jsb\t.strlb"           |       | |
4486 str $1==1       | source4 |
4487                         remove(ALL)
4488                         "movl\t%[1],sp"         |       | |
4489 str $1==2       | STACK |
4490                         "jsb\t.strhp"           |       | |
4491 trp             | STACK |
4492                         "jsb\t.trp"             |       | |
4493
4494 /********************************
4495  * Coercions:                   *
4496  *                              *
4497  * A: From source to register,  *
4498  *    from nonexist to source.  *
4499  ********************************/
4500
4501 | ADDR_EXTERNAL |                               | {DOUBLE,%[1.ind]} | |
4502 | source1 |     allocate(%[1],REG=%[1])         | %[a]  | |
4503 | source2 |     allocate(%[1],REG=%[1])         | %[a]  | |
4504 | bigsource4 |  allocate(%[1],REG=%[1])         | %[a]  | |
4505 | bigsource8 |  allocate(%[1],QREG=%[1])        | %[a]  | |
4506 | reg4 |                        | {adispl,%[1],"0"}     | |
4507 | ADDR_LOCAL |  | {adispl,%[1.reg],tostring(%[1.num])}  | |
4508 | bigsource4-adispl-reg4-ADDR_LOCAL |
4509                 allocate(%[1],REG=%[1]) | {adispl,%[a],"0"}     | |
4510
4511 /********************************
4512  * B: From STACK to register    *
4513  ********************************/
4514
4515 | STACK |       allocate(REG)
4516                 "movl\t(sp)+,%[a]"
4517                 setcc(%[a])                     | %[a]  | | (3,7)
4518 | STACK |       allocate(QREG)
4519                 "movq\t(sp)+,%[a]"
4520                 setcc(%[a])                     | %[a]  | | (3,10)
4521 | STACK |       allocate(REG)
4522                 "movl\t(sp)+,%[a]"
4523                 setcc(%[a])                     | {adispl,%[a],"0"} | | (3,7)
4524
4525 /****************
4526  * C: General   *
4527  ****************/
4528
4529 | regdef8 |     | {displ4,%[1.reg],"4"} {regdef4,%[1.reg]}              | |
4530 | displ8 |      | {displ4,%[1.reg],%[1.ind]+"+4"}
4531                   {displ4,%[1.reg],%[1.ind]}                            | |
4532 | LOCAL8 |      | {LOCAL4,%[1.reg],%[1.num]+4,4} {LOCAL4,%[1.reg],%[1.num],4}| |
4533 | EXTERNAL8 |   | {EXTERNAL4,%[1.ind]+"+4"} {EXTERNAL4,%[1.ind]}        | |
4534 | QREG |        | %[1.2] %[1.1]                         | |
4535 | regdef4 |     | {displ4,%[1.reg],"0"}                 | |
4536 | LOCAL4 |      | {displ4,%[1.reg],tostring(%[1.num])}  | |
4537
4538 MOVES:
4539 (CONST %[num]==0,source1,       "clrb\t%[2]",           (2,4)+%[2])
4540 (CONST %[num]==0,source2,       "clrw\t%[2]",           (2,4)+%[2])
4541 (CONST %[num]==0,source4,       "clrl\t%[2]"
4542                                 setcc(%[2]),            (2,4)+%[2])
4543 (CONST %[num]<0 && ufit(0-%[num],6),source2,
4544                                 "mnegw\t$$%(0-%[1.num]%),%[2]"
4545                                 setcc(%[2]),            (2,4)+%[2])
4546 (CONST ufit(%[num],8) && !ufit(%[num],6),source2,
4547                                 "movzbw\t%[1],%[2]"
4548                                 setcc(%[2]),            (2,4)+%[2])
4549 (CONST sfit(%[num],8) && !ufit(%[num],6),source2,
4550                                 "cvtbw\t%[1],%[2]"
4551                                 setcc(%[2]),            (2,4)+%[2])
4552 (CONST %[num]<0 && ufit(0-%[num],6),source4,
4553                                 "mnegl\t$$%(0-%[1.num]%),%[2]"
4554                                 setcc(%[2]),            (2,4)+%[2])
4555 (CONST ufit(%[num],8) && !ufit(%[num],6),source4,
4556                                 "movzbl\t%[1],%[2]"
4557                                 setcc(%[2]),            (2,4)+%[2])
4558 (CONST sfit(%[num],8) && !ufit(%[num],6),source4,
4559                                 "cvtbl\t%[1],%[2]"
4560                                 setcc(%[2]),            (2,4)+%[2])
4561 (CONST ufit(%[num],16) && !ufit(%[num],6),source4,
4562                                 "movzwl\t%[1],%[2]"
4563                                 setcc(%[2]),            (2,4)+%[2])
4564 (CONST sfit(%[num],16) && !ufit(%[num],6),source4,
4565                                 "cvtwl\t%[1],%[2]"
4566                                 setcc(%[2]),            (2,4)+%[2])
4567 (CONST8 %[ind]=="0",source8,    "clrq\t%[2]"
4568                                 setcc(%[2]),            (2,4)+%[2])
4569 #ifdef REGVARS
4570 /* Tokens with side effects should not be remembered. */
4571 (reginc1+regdec1,reg4,          "movzbl\t%[1],%[2]"
4572                                 setcc(%[2]) erase(%[2]),(3,4)+%[1])
4573 (reginc2+regdec2,reg4,          "movzwl\t%[1],%[2]"
4574                                 setcc(%[2]) erase(%[2]),(3,4)+%[1])
4575 (reginc4+regdec4,reg4,          "movl\t%[1],%[2]"
4576                                 setcc(%[2]) erase(%[2]),(3,4)+%[1])
4577 (reginc8+regdec8,reg8,          "movq\t%[1],%[2]"
4578                                 setcc(%[2]) erase(%[2]),(3,7)+%[1])
4579 #endif /* REGVARS */
4580 (source8,source8,               "movq\t%[1],%[2]"
4581                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4582 (source4,source4,               "movl\t%[1],%[2]"
4583                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4584 (source2,source2,               "movw\t%[1],%[2]"
4585                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4586 (source1,source1,               "movb\t%[1],%[2]"
4587                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4588 (source1, reg4,                 "movzbl\t%[1],%[2]"
4589                                 setcc(%[2]) erase(%[2]),(3,4)+%[1])
4590 (source2, reg4,                 "movzwl\t%[1],%[2]"
4591                                 setcc(%[2]) erase(%[2]),(3,4)+%[1])
4592 (reg4, source1,                 "cvtlb\t%[1],%[2]"
4593                                 setcc(%[2]) erase(%[1]),(3,4)+%[2])
4594 (reg4, source2,                 "cvtlw\t%[1],%[2]"
4595                                 setcc(%[2]) erase(%[1]),(3,4)+%[2])
4596 (source1,source2,               "movzbw\t%[1],%[2]"
4597                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4598 (source1,source4,               "movzbl\t%[1],%[2]"
4599                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4600 (source2,source4,               "movzwl\t%[1],%[2]"
4601                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4602 (source2,source1,               "cvtwb\t%[1],%[2]"
4603                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4604 (source4,source1,               "cvtlb\t%[1],%[2]"
4605                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4606 (source4,source2,               "cvtlw\t%[1],%[2]"
4607                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4608 (aind1,source4,         "movab\t%[1],%[2]"
4609                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4610 (aind2,source4,         "movaw\t%[1],%[2]"
4611                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4612 (aind4,source4,         "moval\t%[1],%[2]"
4613                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4614 (aind8,source4,         "movaq\t%[1],%[2]"
4615                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4616 (nonexist1,source4,             "movab\t%[1],%[2]"
4617                                 setcc(%[2]),            (3,4)+%[1]+%[2])
4618 TESTS:
4619 (source1,       "tstb\t%[1]"             ,(2,4) + %[1])
4620 (source2,       "tstw\t%[1]"             ,(2,4) + %[1])
4621 (source4,       "tstl\t%[1]"             ,(2,4) + %[1])
4622
4623 STACKS:
4624
4625 (CONST %[num]==0,,
4626                 "clrl\t-(sp)",          (2,7))
4627 (CONST %[num]<0 && ufit(0-%[num],6),,
4628                 "mnegl\t$$%(0-%[1.num]%),-(sp)",
4629                                         (2,7) + %[1])
4630 (CONST ufit(%[num],6),,
4631                 "pushl\t%[1]",          (2,7) + %[1])
4632 (CONST8 %[ind]=="0",,
4633                 "clrq\t-(sp)",          (2,10))
4634 (CONST sfit(%[num],8),,
4635                 "cvtbl\t%[1],-(sp)",    (3,7) + %[1])
4636 (source1,,      "movzbl\t%[1],-(sp)",   (3,7) + %[1])
4637 (CONST sfit(%[num],16),,
4638                 "cvtwl\t%[1],-(sp)",    (3,7) + %[1])
4639 (source2,,      "movzwl\t%[1],-(sp)",   (3,7) + %[1])
4640 (source4,,      "pushl\t%[1]"
4641                 setcc(%[1]),            (2,7) + %[1])
4642 (source8,,      "movq\t%[1],-(sp)"
4643                 setcc(%[1]),            (3,10)+ %[1])
4644 (nonexist1,,    "pushal\t%[1]",         (2,7) + %[1])
4645 (aind1,,        "pushab\t%[1]",         (2,7) + %[1])
4646 (aind2,,        "pushaw\t%[1]",         (2,7) + %[1])
4647 (aind4,,        "pushal\t%[1]",         (2,7) + %[1])
4648 (aind8,,        "pushaq\t%[1]",         (2,7) + %[1])