libgcc/config/rl78/divmodsi.S

   1 /* SImode div/mod functions for the GCC support library for the Renesas RL78 processors.
   2    Copyright (C) 2012-2015 Free Software Foundation, Inc.
   3    Contributed by Red Hat.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published
   9    by the Free Software Foundation; either version 3, or (at your
  10    option) any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    Under Section 7 of GPL version 3, you are granted additional
  18    permissions described in the GCC Runtime Library Exception, version
  19    3.1, as published by the Free Software Foundation.
  20
  21    You should have received a copy of the GNU General Public License and
  22    a copy of the GCC Runtime Library Exception along with this program;
  23    see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  24    <http://www.gnu.org/licenses/>.  */
  25
  26 #include "vregs.h"
  27
  28 .macro MAKE_GENERIC  which,need_result
  29
  30         .if \need_result
  31         quot = r8
  32         num = r12
  33         den = r16
  34         bit = r20
  35         .else
  36         num = r8
  37         quot = r12
  38         den = r16
  39         bit = r20
  40         .endif
  41
  42         quotH = quot+2
  43         quotL = quot
  44         quotB0 = quot
  45         quotB1 = quot+1
  46         quotB2 = quot+2
  47         quotB3 = quot+3
  48
  49         numH = num+2
  50         numL = num
  51         numB0 = num
  52         numB1 = num+1
  53         numB2 = num+2
  54         numB3 = num+3
  55
  56 #define denH bc
  57         denL = den
  58         denB0 = den
  59         denB1 = den+1
  60 #define denB2 c
  61 #define denB3 b
  62
  63         bitH = bit+2
  64         bitL = bit
  65         bitB0 = bit
  66         bitB1 = bit+1
  67         bitB2 = bit+2
  68         bitB3 = bit+3
  69
  70 START_FUNC __generic_sidivmod\which
  71
  72 num_lt_den\which:
  73         .if \need_result
  74         movw    r8, #0
  75         movw    r10, #0
  76         .else
  77         movw    ax, [sp+8]
  78         movw    r8, ax
  79         movw    ax, [sp+10]
  80         movw    r10, ax
  81         .endif
  82         ret
  83
  84 shift_den_bit16\which:
  85         movw    ax, denL
  86         movw    denH, ax
  87         movw    denL, #0
  88         .if \need_result
  89         movw    ax, bitL
  90         movw    bitH, ax
  91         movw    bitL, #0
  92         .else
  93         mov     a, bit
  94         add     a, #16
  95         mov     bit, a
  96         .endif
  97         br      $shift_den_bit\which
  98
  99         ;; These routines leave DE alone - the signed functions use DE
 100         ;; to store sign information that must remain intact
 101
 102         .if \need_result
 103         .global __generic_sidiv
 104 __generic_sidiv:
 105
 106         .else
 107
 108         .global __generic_simod
 109 __generic_simod:
 110
 111         .endif
 112
 113         ;; (quot,rem) = 8[sp] /% 12[sp]
 114
 115         movw    hl, sp
 116         movw    ax, [hl+14] ; denH
 117         cmpw    ax, [hl+10] ; numH
 118         movw    ax, [hl+12] ; denL
 119         sknz
 120         cmpw    ax, [hl+8] ; numL
 121         bh      $num_lt_den\which
 122
 123 #ifdef __RL78_G10__
 124         movw    ax, denL
 125         push    ax
 126         movw    ax, bitL
 127         push    ax
 128         movw    ax, bitH
 129         push    ax
 130 #else
 131         sel     rb2
 132         push    ax              ; denL
 133 ;       push    bc              ; denH
 134         push    de              ; bitL
 135         push    hl              ; bitH - stored in BC
 136         sel     rb0
 137 #endif
 138
 139         ;; (quot,rem) = 16[sp] /% 20[sp]
 140
 141         ;; copy numerator
 142         movw    ax, [hl+8]
 143         movw    numL, ax
 144         movw    ax, [hl+10]
 145         movw    numH, ax
 146
 147         ;; copy denomonator
 148         movw    ax, [hl+12]
 149         movw    denL, ax
 150         movw    ax, [hl+14]
 151         movw    denH, ax
 152
 153         movw    ax, denL
 154         or      a, denB2
 155         or      a, denB3        ; not x
 156         cmpw    ax, #0
 157         bnz     $den_not_zero\which
 158         movw    numL, #0
 159         movw    numH, #0
 160         ret
 161
 162 den_not_zero\which:
 163         .if \need_result
 164         ;; zero out quot
 165         movw    quotL, #0
 166         movw    quotH, #0
 167         .endif
 168
 169         ;; initialize bit to 1
 170         movw    bitL, #1
 171         movw    bitH, #0
 172
 173 ; while (den < num && !(den & (1L << BITS_MINUS_1)))
 174
 175         .if 1
 176         ;; see if we can short-circuit a bunch of shifts
 177         movw    ax, denH
 178         cmpw    ax, #0
 179         bnz     $shift_den_bit\which
 180         movw    ax, denL
 181         cmpw    ax, numH
 182         bnh     $shift_den_bit16\which
 183         .endif
 184
 185 shift_den_bit\which:
 186         movw    ax, denH
 187         mov1    cy,a.7
 188         bc      $enter_main_loop\which
 189         cmpw    ax, numH
 190         movw    ax, denL        ; we re-use this below
 191         sknz
 192         cmpw    ax, numL
 193         bh      $enter_main_loop\which
 194
 195         ;; den <<= 1
 196 ;       movw    ax, denL        ; already has it from the cmpw above
 197         shlw    ax, 1
 198         movw    denL, ax
 199 ;       movw    ax, denH
 200         rolwc   denH, 1
 201 ;       movw    denH, ax
 202
 203         ;; bit <<= 1
 204         .if \need_result
 205         movw    ax, bitL
 206         shlw    ax, 1
 207         movw    bitL, ax
 208         movw    ax, bitH
 209         rolwc   ax, 1
 210         movw    bitH, ax
 211         .else
 212         ;; if we don't need to compute the quotent, we don't need an
 213         ;; actual bit *mask*, we just need to keep track of which bit
 214         inc     bitB0
 215         .endif
 216
 217         br      $shift_den_bit\which
 218
 219         ;; while (bit)
 220 main_loop\which:
 221
 222         ;; if (num >= den) (cmp den > num)
 223         movw    ax, numH
 224         cmpw    ax, denH
 225         movw    ax, numL
 226         sknz
 227         cmpw    ax, denL
 228         skz
 229         bnh     $next_loop\which
 230
 231         ;; num -= den
 232 ;       movw    ax, numL        ; already has it from the cmpw above
 233         subw    ax, denL
 234         movw    numL, ax
 235         movw    ax, numH
 236         sknc
 237         decw    ax
 238         subw    ax, denH
 239         movw    numH, ax
 240
 241         .if \need_result
 242         ;; res |= bit
 243         mov     a, quotB0
 244         or      a, bitB0
 245         mov     quotB0, a
 246         mov     a, quotB1
 247         or      a, bitB1
 248         mov     quotB1, a
 249         mov     a, quotB2
 250         or      a, bitB2
 251         mov     quotB2, a
 252         mov     a, quotB3
 253         or      a, bitB3
 254         mov     quotB3, a
 255         .endif
 256
 257 next_loop\which:
 258
 259         ;; den >>= 1
 260         movw    ax, denH
 261         shrw    ax, 1
 262         movw    denH, ax
 263         mov     a, denB1
 264         rorc    a, 1
 265         mov     denB1, a
 266         mov     a, denB0
 267         rorc    a, 1
 268         mov     denB0, a
 269
 270         ;; bit >>= 1
 271         .if \need_result
 272         movw    ax, bitH
 273         shrw    ax, 1
 274         movw    bitH, ax
 275         mov     a, bitB1
 276         rorc    a, 1
 277         mov     bitB1, a
 278         mov     a, bitB0
 279         rorc    a, 1
 280         mov     bitB0, a
 281         .else
 282         dec     bitB0
 283         .endif
 284
 285 enter_main_loop\which:
 286         .if \need_result
 287         movw    ax, bitH
 288         cmpw    ax, #0
 289         bnz     $main_loop\which
 290         .else
 291         cmp     bitB0, #15
 292         bh      $main_loop\which
 293         .endif
 294         ;; bit is HImode now; check others
 295         movw    ax, numH        ; numerator
 296         cmpw    ax, #0
 297         bnz     $bit_high_set\which
 298         movw    ax, denH        ; denominator
 299         cmpw    ax, #0
 300         bz      $switch_to_himode\which
 301 bit_high_set\which:
 302         .if \need_result
 303         movw    ax, bitL
 304         cmpw    ax, #0
 305         .else
 306         cmp0    bitB0
 307         .endif
 308         bnz     $main_loop\which
 309
 310 switch_to_himode\which:
 311         .if \need_result
 312         movw    ax, bitL
 313         cmpw    ax, #0
 314         .else
 315         cmp0    bitB0
 316         .endif
 317         bz      $main_loop_done_himode\which
 318
 319         ;; From here on in, r22, r14, and r18 are all zero
 320         ;; while (bit)
 321 main_loop_himode\which:
 322
 323         ;; if (num >= den) (cmp den > num)
 324         movw    ax, denL
 325         cmpw    ax, numL
 326         bh      $next_loop_himode\which
 327
 328         ;; num -= den
 329         movw    ax, numL
 330         subw    ax, denL
 331         movw    numL, ax
 332         movw    ax, numH
 333         sknc
 334         decw    ax
 335         subw    ax, denH
 336         movw    numH, ax
 337
 338         .if \need_result
 339         ;; res |= bit
 340         mov     a, quotB0
 341         or      a, bitB0
 342         mov     quotB0, a
 343         mov     a, quotB1
 344         or      a, bitB1
 345         mov     quotB1, a
 346         .endif
 347
 348 next_loop_himode\which:
 349
 350         ;; den >>= 1
 351         movw    ax, denL
 352         shrw    ax, 1
 353         movw    denL, ax
 354
 355         .if \need_result
 356         ;; bit >>= 1
 357         movw    ax, bitL
 358         shrw    ax, 1
 359         movw    bitL, ax
 360         .else
 361         dec     bitB0
 362         .endif
 363
 364         .if \need_result
 365         movw    ax, bitL
 366         cmpw    ax, #0
 367         .else
 368         cmp0    bitB0
 369         .endif
 370         bnz     $main_loop_himode\which
 371
 372 main_loop_done_himode\which:
 373 #ifdef __RL78_G10__
 374         pop     ax
 375         movw    bitH, ax
 376         pop     ax
 377         movw    bitL, ax
 378         pop     ax
 379         movw    denL, ax
 380 #else
 381         sel     rb2
 382         pop     hl              ; bitH - stored in BC
 383         pop     de              ; bitL
 384 ;       pop     bc              ; denH
 385         pop     ax              ; denL
 386         sel     rb0
 387 #endif
 388
 389         ret
 390 END_FUNC __generic_sidivmod\which
 391 .endm
 392
 393 ;----------------------------------------------------------------------
 394
 395         MAKE_GENERIC _d 1
 396         MAKE_GENERIC _m 0
 397
 398 ;----------------------------------------------------------------------
 399
 400 START_FUNC ___udivsi3
 401         ;; r8 = 4[sp] / 8[sp]
 402         call    $!__generic_sidiv
 403         ret
 404 END_FUNC ___udivsi3
 405
 406
 407 START_FUNC ___umodsi3
 408         ;; r8 = 4[sp] % 8[sp]
 409         call    $!__generic_simod
 410         ret
 411 END_FUNC ___umodsi3
 412
 413 ;----------------------------------------------------------------------
 414
 415 .macro NEG_AX
 416         movw    hl, ax
 417         movw    ax, #0
 418         subw    ax, [hl]
 419         movw    [hl], ax
 420         movw    ax, #0
 421         sknc
 422         decw    ax
 423         subw    ax, [hl+2]
 424         movw    [hl+2], ax
 425 .endm
 426
 427 ;----------------------------------------------------------------------
 428
 429 START_FUNC ___divsi3
 430         ;; r8 = 4[sp] / 8[sp]
 431         movw    de, #0
 432         mov     a, [sp+7]
 433         mov1    cy, a.7
 434         bc      $div_signed_num
 435         mov     a, [sp+11]
 436         mov1    cy, a.7
 437         bc      $div_signed_den
 438         call    $!__generic_sidiv
 439         ret
 440
 441 div_signed_num:
 442         ;; neg [sp+4]
 443         movw    ax, sp
 444         addw    ax, #4
 445         NEG_AX
 446         mov     d, #1
 447         mov     a, [sp+11]
 448         mov1    cy, a.7
 449         bnc     $div_unsigned_den
 450 div_signed_den:
 451         ;; neg [sp+8]
 452         movw    ax, sp
 453         addw    ax, #8
 454         NEG_AX
 455         mov     e, #1
 456 div_unsigned_den:
 457         call    $!__generic_sidiv
 458
 459         mov     a, d
 460         cmp0    a
 461         bz      $div_skip_restore_num
 462         ;;  We have to restore the numerator [sp+4]
 463         movw    ax, sp
 464         addw    ax, #4
 465         NEG_AX
 466         mov     a, d
 467 div_skip_restore_num:
 468         xor     a, e
 469         bz      $div_no_neg
 470         movw    ax, #r8
 471         NEG_AX
 472 div_no_neg:
 473         mov     a, e
 474         cmp0    a
 475         bz      $div_skip_restore_den
 476         ;;  We have to restore the denominator [sp+8]
 477         movw    ax, sp
 478         addw    ax, #8
 479         NEG_AX
 480 div_skip_restore_den:
 481         ret
 482 END_FUNC ___divsi3
 483
 484
 485 START_FUNC ___modsi3
 486         ;; r8 = 4[sp] % 8[sp]
 487         movw    de, #0
 488         mov     a, [sp+7]
 489         mov1    cy, a.7
 490         bc      $mod_signed_num
 491         mov     a, [sp+11]
 492         mov1    cy, a.7
 493         bc      $mod_signed_den
 494         call    $!__generic_simod
 495         ret
 496
 497 mod_signed_num:
 498         ;; neg [sp+4]
 499         movw    ax, sp
 500         addw    ax, #4
 501         NEG_AX
 502         mov     d, #1
 503         mov     a, [sp+11]
 504         mov1    cy, a.7
 505         bnc     $mod_unsigned_den
 506 mod_signed_den:
 507         ;; neg [sp+8]
 508         movw    ax, sp
 509         addw    ax, #8
 510         NEG_AX
 511         mov     e, #1
 512 mod_unsigned_den:
 513         call    $!__generic_simod
 514
 515         mov     a, d
 516         cmp0    a
 517         bz      $mod_no_neg
 518         movw    ax, #r8
 519         NEG_AX
 520         ;;  We have to restore [sp+4] as well.
 521         movw    ax, sp
 522         addw    ax, #4
 523         NEG_AX
 524 mod_no_neg:
 525  .if 1
 526         mov     a, e
 527         cmp0    a
 528         bz      $mod_skip_restore_den
 529         movw    ax, sp
 530         addw    ax, #8
 531         NEG_AX
 532 mod_skip_restore_den:
 533  .endif
 534         ret
 535 END_FUNC ___modsi3