mach/mantra/int/mloop6

   1         .define mlu4
   2         .define dvu4
   3 .sect .text
   4 .sect .rom
   5 .sect .data
   6 .sect .bss
   7 .sect .text
   8 !----------------------------------------------------------------------------
   9 !               SIGNED INTEGER ARITHMETIC
  10 !------------------------------------------------------------------------------
  11
  12 adi_l:          adroff          ;       move.w  (a5),d0 ;       bra 1f
  13 adi_z:          mov     (sp)+,d0
  14 1:              sub.w   wrd,d0  ;       beq     adi_1W
  15                 sub.w   wrd,d0  ;       beq     adi_2W
  16                 bra     e_oddz
  17 adi_1W:
  18 #if test
  19                 comp    und,(sp) ;      beq     6f
  20                 comp    und,word(sp);   bne     7f
  21 6:              bsr     e_iund
  22 #endif
  23 7:              mov     (sp)+,d0 ;      ad      d0,(sp)
  24 #if test
  25                 bvs     9f
  26 #endif
  27                 jmp     (a4)
  28 adi_2W:
  29 #ifdef lword
  30                 bsr     no8bar  ;       add.l   #8,sp
  31                 jmp     (a4)
  32 #else
  33                 move.l  (sp)+,d0 ;      add.l   d0,(sp)
  34 #endif
  35 #if test
  36                 bvs     9f
  37 #endif
  38                 jmp     (a4)
  39
  40 !--------------------------------------------------------------------------
  41
  42 sbi_z:          mov     (sp)+,d0 ;      bra     1f
  43 sbi_l:          adroff          ;       move.w  (a5),d0
  44 1:              sub.w   wrd,d0  ;       beq     sbi_1W
  45                 sub.w   wrd,d0  ;       beq     sbi_2W
  46                 bra     e_oddz
  47 sbi_1W:
  48 #if test
  49                 comp    und,(sp) ;      beq     6f
  50                 comp    und,word(sp) ; bne      7f
  51 6:              bsr     e_iund
  52 #endif
  53 7:              mov     (sp)+,d0 ;      subt    d0,(sp)
  54 #if test
  55                 bvs     9f
  56 #endif
  57                 jmp     (a4)
  58 sbi_2W:
  59 #ifdef lword
  60                 add.l   #8,sp   ;       bsr     no8bar
  61                 jmp     (a4)
  62 #else
  63                 move.l  (sp)+,d0 ;      sub.l   d0,(sp)
  64 #endif
  65 #if test
  66                 bvs     9f
  67 #endif
  68                 jmp     (a4)
  69 9:              bsr     e_iovfl ;       jmp     (a4)
  70
  71 !----------------------------------------------------------------------------
  72
  73 mli_z:          mov     (sp)+,d0 ;      bra     0f
  74 mli_l:          adroff          ;       move.w  (a5),d0
  75 0:              sub.w   wrd,d0  ;       beq     mli_1W
  76                 sub.w   wrd,d0  ;       beq     mli_2W
  77                 bra     e_oddz
  78 mli_1W:         mov     (sp)+,d0
  79 #if test
  80                 comp    und,d0 ;        beq     1f
  81                 comp    und,(sp) ;      bne     2f
  82 1:              bsr     e_iund
  83 #endif
  84 2:
  85 #ifdef lword
  86                 move.l  (sp)+,d1 ;      bra     4f
  87 #else
  88                 muls    (sp),d0 ;       move.w  d0,(sp)
  89 #if test
  90                 bpl     3f      ;       not.l   d0
  91 3:              swap    d0      ;       tst.w   d0      ;       bne 9b
  92 #endif
  93                 jmp     (a4)
  94 #endif
  95 mli_2W:
  96 #ifdef lword
  97                 bsr     no8bar  ;       add.l   #4,sp
  98                 move.l  (sp)+,d0 ;      add.l   #4,sp
  99                 move.l  (sp)+,d1
 100 #else
 101                 move.l  (sp)+,d0 ;      move.l  (sp)+,d1
 102 #endif
 103 4:              move.l  #0,d5   ;       tst.l   d0      ;       bpl 5f
 104                 neg.l   d0      ;       not.w   d5
 105 5:              tst.l   d1      ;       bpl     6f
 106                 neg.l   d1      ;       not.w   d5
 107 6:              bsr     mlu4
 108 #if test
 109                 tst.l   d4      ;       bne     7f
 110                 tst.l   d0      ;       bpl     8f
 111 7:              bsr     e_iovfl
 112 #endif
 113 8:              tst.w   d5      ;       beq     0f
 114                 neg.l   d0
 115 0:              move.l  d0,-(sp)
 116 !next 4 lines only in case 8 byte arithmetic
 117 !#ifdef lword
 118 !               bmi     1f      ;       clr.l   -(sp)   ;       bra 2f
 119 !1:             move.l  #-1,-(sp)
 120 !#endif
 121 2:              jmp     (a4)
 122
 123 !subroutine for unsigned 4byte multiplication . Expects multiplier in d0 and
 124 ! multiplicant in d1 . Returns 4 byte result in d0 . If d4=0 overflow did
 125 ! not occur on the multiplication , else it did .
 126
 127         .sect .text
 128
 129 mlu4:           move.l  d1,d3   ;       move.l  d0,d2
 130                 swap    d2      ;       swap    d3
 131 #if test
 132                 move.l  d3,d4   ;       mulu    d2,d4
 133 #endif
 134                 mulu    d0,d3   ;       swap    d3
 135                 mulu    d1,d2   ;       swap    d2
 136 #if test
 137                 or.w    d3,d4   ;       or.w    d2,d4
 138 #endif
 139                 clr.w   d3      ;       clr.w   d2
 140                 mulu    d1,d0   ;       add.l   d3,d0
 141 #if test
 142                 bvc     1f      ;       bset    #0,d4
 143 #endif
 144 1:              add.l   d2,d0
 145 #if test
 146                 bvc     2f      ;       bset    #0,d4
 147 #endif
 148 2:              rts
 149
 150 !---------------------------------------------------------------------------
 151
 152 dvi_z:          mov     (sp)+,d0 ;      bra     0f
 153 dvi_l:          adroff          ;       move.w  (a5),d0
 154 0:              sub.w   wrd,d0  ;       beq     dvi_1W
 155                 sub.w   wrd,d0  ;       beq     dvi_2W
 156                 bra     e_oddz
 157 dvi_1W:
 158 #ifdef lword
 159                 bsr     dvi4    ;       move.l  d1,-(sp)
 160 #else
 161                 bsr     dvi2    ;       move.w  d1,-(sp)
 162 #endif
 163                 jmp     (a4)
 164 dvi_2W:
 165 #ifdef lword
 166                 bsr     no8bar  ;       tst.l   (sp)+
 167                 move.l  (sp)+,(sp) ;    bsr     dvi4
 168                 move.l  d1,-(sp) ;      clr.l   -(sp)
 169 #else
 170                 bsr     dvi4    ;       move.l  d1,-(sp)
 171 #endif
 172                 jmp     (a4)
 173
 174 rmi_z:          mov     (sp)+,d0 ;      bra     1f
 175 rmi_l:          adroff          ;       move.w  (a5),d0
 176 1:              sub.l   wrd,d0  ;       beq     rmi_1W
 177                 sub.l   wrd,d0  ;       beq     rmi_2W
 178                 bra     e_oddz
 179 rmi_1W:
 180 #ifdef lword
 181                 bsr     dvi4    ;       move.l  d3,-(sp)
 182 #else
 183                 bsr     dvi2    ;       swap    d1
 184                 move.w  d1,-(sp)
 185 #endif
 186                 jmp     (a4)
 187 rmi_2W:
 188 #ifdef lword
 189                 bsr     no8bar  ;       tst.l   (sp)+
 190                 move.l  (sp)+,(sp) ;    bsr     dvi4
 191                 move.l  d3,-(sp) ;      clr.l   -(sp)
 192 #else
 193                 bsr     dvi4    ;       move.l  d3,-(sp)
 194 #endif
 195                 jmp     (a4)
 196
 197 ! 2byte division . In d1: quotient=low word ; remainder=high word
 198 #ifndef lword
 199 dvi2:           move.l  (sp)+,d2
 200                 move.w  (sp)+,d0                                !divisor
 201                 move.w  (sp)+,d1 ;      ext.l   d1              !dividend
 202 #if test
 203                 cmp.w   und,d1  ;       bne     1f
 204                 bsr     e_iund
 205 1:              cmp.w   und,d0  ;       bne     2f
 206                 bsr     e_iund
 207 2:              tst.w   d0      ;       bne     3f
 208                 bsr     e_idivz ;       move.l  und,d1  ;       bra 4f
 209 3:
 210 #endif
 211                 divs    d0,d1
 212 4:              move.l  d2,-(sp) ;      rts
 213 #endif
 214
 215 ! long signed division . quotient in d1 , remainder in d3
 216 dvi4:           move.l  (sp)+,d5
 217                 move.l  (sp)+,d0                !divisor
 218                 move.l  (sp)+,d1                !dividend
 219 #ifdef lword
 220                 cmp.l   und,d0  ;       beq     0f
 221                 cmp.l   und,d1  ;       bne     1f
 222 0:              bsr     e_iund
 223 1:
 224 #endif
 225                 move.l  #0,d4                   !sign in d4
 226                 tst.l   d0      ;       bpl     1f
 227                 neg.l   d0      ;       not.w   d4
 228 1:              tst.l   d1      ;       bpl     2f
 229                 neg.l   d1
 230                 not.w   d4      ;       swap    d4
 231                 not.w   d4      ;       swap    d4
 232 2:              bsr     dvu4
 233                 tst.w   d4      ;       beq     3f
 234                 neg.l   d1                      !quotient
 235 3:              tst.l   d4      ;       bpl     4f
 236                 neg.l   d3                              !remainder
 237 4:              move.l  d5,-(sp) ;      rts
 238
 239 !Expects d0 divisor , d1 dividend. Gives d1 quotient ,d3 remainder
 240
 241         .sect .text
 242 dvu4:
 243 #if test
 244                 tst.l   d0      ;       bne     1f
 245                 bsr     e_idivz
 246 1:
 247 #endif
 248                 move.l  #0,d3   ;       move.l  #32,d2
 249 3:              lsl.l   #1,d1   ;       roxl.l  #1,d3
 250                 cmp.l   d0,d3   ;       blt     4f
 251                 sub.l   d0,d3   ;       add.l   #1,d1
 252 4:              sub.w   #1,d2   ;       bgt     3b
 253                 rts
 254
 255 !----------------------------------------------------------------------------
 256
 257 ngi_z:          mov     (sp)+,d0 ;      bra     0f
 258 ngi_l:          adroff          ;       move.w  (a5),d0
 259 0:              sub.l   wrd,d0  ;       bne     2f
 260 #if test
 261                 comp    und,(sp) ;      bne     1f
 262                 bsr     e_iund
 263 1:
 264 #endif
 265                 nega    (sp)    ;       jmp     (a4)
 266 2:              cmp.l   wrd,d0  ;       beq     3f
 267                 bra     e_oddz
 268 3:
 269 #ifdef lword
 270                 bsr     no8bar  ;       not.l   (sp)
 271                 neg.l   4(sp)
 272 #else
 273                 neg.l   (sp)
 274 #endif
 275 #if test
 276                 bvc     4f      ;       bsr     e_iovfl
 277 4:
 278 #endif
 279                 jmp     (a4)
 280
 281 !--------------------------------------------------------------------------
 282
 283 sli_z:          mov     (sp)+,d0 ;      bra     0f
 284 sli_l:          adroff          ;       move.w  (a5),d0
 285 0:              sub.w   wrd,d0  ;       beq     sli_1W
 286                 sub.w   wrd,d0  ;       beq     sli2
 287                 bra     e_oddz
 288 sli_1W:         mov     (sp)+,d0        !d0 contains the shift count
 289                 bmi     5f
 290 9:              mov     (sp)+,d1                !integer to shift
 291 #if test
 292                 comp    und,d0  ;       bne     1f
 293                 bsr     e_iund
 294 1:
 295 #endif
 296                 asle    d0,d1                   ! ASLE
 297 #if test
 298                 bvc     2f      ;       bsr     e_iovfl
 299 2:
 300 #endif
 301                 mov     d1,-(sp) ;      jmp     (a4)
 302 sli2:
 303 #ifdef lword
 304                 bsr     no8bar  ;       move.l  (sp)+,d1
 305                 move.l  (sp)+,d2 ;      move.l  (sp)+,d0
 306 3:              asl.l   #1,d0   ;       roxl.l  #1,d2
 307                 sub.l   #1,d1   ;       bgt     3b
 308                 move.l  d0,-(sp) ;      move.l  d2,-(sp)
 309 #else
 310                 move.w  (sp)+,d0
 311                 bmi     6f
 312 8:              move.l  (sp),d1
 313                 asl.l   d0,d1
 314 #if test
 315                 bvc     4f      ;       bsr     e_iovfl
 316 4:
 317 #endif
 318                 move.l  d1,(sp)
 319 #endif
 320                 jmp     (a4)
 321 5:              nega    d0      ;       bra     8f
 322 #ifndef lword
 323 6:              neg.w   d0      ;       bra     9f
 324 #endif
 325
 326 !------------------------------------------------------------------------------
 327 7:              nega    d0      ;       bra     9b
 328 #ifndef lword
 329 6:              neg.w   d0      ;       bra     8b
 330 #endif
 331
 332 sri_z:          mov     (sp)+,d0 ;      bra     0f
 333 sri_l:          adroff          ;       move.w  (a5),d0
 334 0:              sub.w   wrd,d0  ;       bne     sri2
 335                 mov     (sp)+,d0
 336                 bmi     7b
 337 8:              mov     (sp)+,d1
 338 #if test
 339                 comp    und,d0  ;       bne     1f
 340                 bsr     e_iund
 341 1:
 342 #endif
 343                 asri    d0,d1
 344 #if test
 345                 bvc     2f      ;       bsr     e_iovfl
 346 2:
 347 #endif
 348                 mov     d1,-(sp) ;      jmp     (a4)
 349 sri2:           sub.w   wrd,d0  ;       beq     3f
 350                 bra     e_oddz
 351 3:
 352 #ifdef lword
 353                 bsr     no8bar  ;       move.l  (sp)+,d1
 354                 move.l  (sp)+,d2 ;      move.l  (sp),d0
 355                 sub.l   #1,d1
 356 4:              asr.l   #1,d2   ;       roxr.l  #1,d0   ;       dbra d1,4b
 357                 move.l  d0,(sp) ;       move.l  d2,-(sp)
 358 #else
 359                 move.w  (sp)+,d0
 360                 bmi     6b
 361 9:              move.l  (sp),d1
 362                 asr.l   d0,d1
 363 #if test
 364                 bvc     5f      ;       bsr     e_iovfl
 365 5:
 366 #endif
 367                 move.l  d1,(sp)
 368 #endif
 369                 jmp     (a4)