libgcc/config/avr/lib1funcs.S

   1 /*  -*- Mode: Asm -*-  */
   2 /* Copyright (C) 1998-2024 Free Software Foundation, Inc.
   3    Contributed by Denis Chertykov <chertykov@gmail.com>
   4
   5 This file is free software; you can redistribute it and/or modify it
   6 under the terms of the GNU General Public License as published by the
   7 Free Software Foundation; either version 3, or (at your option) any
   8 later version.
   9
  10 This file is distributed in the hope that it will be useful, but
  11 WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13 General Public License for more details.
  14
  15 Under Section 7 of GPL version 3, you are granted additional
  16 permissions described in the GCC Runtime Library Exception, version
  17 3.1, as published by the Free Software Foundation.
  18
  19 You should have received a copy of the GNU General Public License and
  20 a copy of the GCC Runtime Library Exception along with this program;
  21 see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #if defined (__AVR_TINY__)
  25 #define __zero_reg__ r17
  26 #define __tmp_reg__ r16
  27 #else
  28 #define __zero_reg__ r1
  29 #define __tmp_reg__ r0
  30 #endif
  31 #define __SREG__ 0x3f
  32 #if defined (__AVR_HAVE_SPH__)
  33 #define __SP_H__ 0x3e
  34 #endif
  35 #define __SP_L__ 0x3d
  36 #define __RAMPZ__ 0x3B
  37 #define __EIND__  0x3C
  38
  39 /* Most of the functions here are called directly from avr.md
  40    patterns, instead of using the standard libcall mechanisms.
  41    This can make better code because GCC knows exactly which
  42    of the call-used registers (not all of them) are clobbered.  */
  43
  44 /* FIXME:  At present, there is no SORT directive in the linker
  45            script so that we must not assume that different modules
  46            in the same input section like .libgcc.text.mul will be
  47            located close together.  Therefore, we cannot use
  48            RCALL/RJMP to call a function like __udivmodhi4 from
  49            __divmodhi4 and have to use lengthy XCALL/XJMP even
  50            though they are in the same input section and all same
  51            input sections together are small enough to reach every
  52            location with a RCALL/RJMP instruction.  */
  53
  54 #if defined (__AVR_HAVE_EIJMP_EICALL__) && !defined (__AVR_HAVE_ELPMX__)
  55 #error device not supported
  56 #endif
  57
  58         .macro  mov_l  r_dest, r_src
  59 #if defined (__AVR_HAVE_MOVW__)
  60         movw    \r_dest, \r_src
  61 #else
  62         mov     \r_dest, \r_src
  63 #endif
  64         .endm
  65
  66         .macro  mov_h  r_dest, r_src
  67 #if defined (__AVR_HAVE_MOVW__)
  68         ; empty
  69 #else
  70         mov     \r_dest, \r_src
  71 #endif
  72         .endm
  73
  74 .macro  wmov  r_dest, r_src
  75 #if defined (__AVR_HAVE_MOVW__)
  76     movw \r_dest,   \r_src
  77 #else
  78     mov \r_dest,    \r_src
  79     mov \r_dest+1,  \r_src+1
  80 #endif
  81 .endm
  82
  83 .macro  mov4  r_dest, r_src
  84     wmov \r_dest,   \r_src
  85     wmov \r_dest+2, \r_src+2
  86 .endm
  87
  88 #if defined (__AVR_HAVE_JMP_CALL__)
  89 #define XCALL call
  90 #define XJMP  jmp
  91 #else
  92 #define XCALL rcall
  93 #define XJMP  rjmp
  94 #endif
  95
  96 #if defined (__AVR_HAVE_EIJMP_EICALL__)
  97 #define XICALL eicall
  98 #define XIJMP  eijmp
  99 #else
 100 #define XICALL icall
 101 #define XIJMP  ijmp
 102 #endif
 103
 104 ;; Prologue stuff
 105
 106 .macro do_prologue_saves n_pushed n_frame=0
 107     ldi r26, lo8(\n_frame)
 108     ldi r27, hi8(\n_frame)
 109     ldi r30, lo8(gs(.L_prologue_saves.\@))
 110     ldi r31, hi8(gs(.L_prologue_saves.\@))
 111     XJMP __prologue_saves__ + ((18 - (\n_pushed)) * 2)
 112 .L_prologue_saves.\@:
 113 .endm
 114
 115 ;; Epilogue stuff
 116
 117 .macro do_epilogue_restores n_pushed n_frame=0
 118     in      r28, __SP_L__
 119 #ifdef __AVR_HAVE_SPH__
 120     in      r29, __SP_H__
 121 .if \n_frame > 63
 122     subi    r28, lo8(-\n_frame)
 123     sbci    r29, hi8(-\n_frame)
 124 .elseif \n_frame > 0
 125     adiw    r28, \n_frame
 126 .endif
 127 #else
 128     clr     r29
 129 .if \n_frame > 0
 130     subi    r28, lo8(-\n_frame)
 131 .endif
 132 #endif /* HAVE SPH */
 133     ldi     r30, \n_pushed
 134     XJMP __epilogue_restores__ + ((18 - (\n_pushed)) * 2)
 135 .endm
 136
 137 ;; Support function entry and exit for convenience
 138
 139 .macro wsubi r_arg1, i_arg2
 140 #if defined (__AVR_TINY__)
 141     subi \r_arg1,   lo8(\i_arg2)
 142     sbci \r_arg1+1, hi8(\i_arg2)
 143 #else
 144     sbiw \r_arg1, \i_arg2
 145 #endif
 146 .endm
 147
 148 .macro waddi r_arg1, i_arg2
 149 #if defined (__AVR_TINY__)
 150     subi \r_arg1,   lo8(-\i_arg2)
 151     sbci \r_arg1+1, hi8(-\i_arg2)
 152 #else
 153     adiw \r_arg1, \i_arg2
 154 #endif
 155 .endm
 156
 157 .macro DEFUN name
 158 .global \name
 159 .func \name
 160 \name:
 161 .endm
 162
 163 .macro ENDF name
 164 .size \name, .-\name
 165 .endfunc
 166 .endm
 167
 168 .macro FALIAS name
 169 .global \name
 170 .func \name
 171 \name:
 172 .size \name, .-\name
 173 .endfunc
 174 .endm
 175
 176 ;; Skip next instruction, typically a jump target
 177 #define skip cpse 16,16
 178
 179 ;; Negate a 2-byte value held in consecutive registers
 180 .macro NEG2  reg
 181     com     \reg+1
 182     neg     \reg
 183     sbci    \reg+1, -1
 184 .endm
 185
 186 ;; Negate a 4-byte value held in consecutive registers
 187 ;; Sets the V flag for signed overflow tests if REG >= 16
 188 .macro NEG4  reg
 189     com     \reg+3
 190     com     \reg+2
 191     com     \reg+1
 192 .if \reg >= 16
 193     neg     \reg
 194     sbci    \reg+1, -1
 195     sbci    \reg+2, -1
 196     sbci    \reg+3, -1
 197 .else
 198     com     \reg
 199     adc     \reg,   __zero_reg__
 200     adc     \reg+1, __zero_reg__
 201     adc     \reg+2, __zero_reg__
 202     adc     \reg+3, __zero_reg__
 203 .endif
 204 .endm
 205
 206 #define exp_lo(N)  hlo8 ((N) << 23)
 207 #define exp_hi(N)  hhi8 ((N) << 23)
 208
 209 \f
 210 .section .text.libgcc.mul, "ax", @progbits
 211
 212 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 213 /* Note: mulqi3, mulhi3 are open-coded on the enhanced core.  */
 214 #if !defined (__AVR_HAVE_MUL__)
 215 /*******************************************************
 216     Multiplication  8 x 8  without MUL
 217 *******************************************************/
 218 #if defined (L_mulqi3)
 219
 220 #define r_arg2  r22             /* multiplicand */
 221 #define r_arg1  r24             /* multiplier */
 222 #define r_res   __tmp_reg__     /* result */
 223
 224 DEFUN __mulqi3
 225         clr     r_res           ; clear result
 226 __mulqi3_loop:
 227         sbrc    r_arg1,0
 228         add     r_res,r_arg2
 229         add     r_arg2,r_arg2   ; shift multiplicand
 230         breq    __mulqi3_exit   ; while multiplicand != 0
 231         lsr     r_arg1          ;
 232         brne    __mulqi3_loop   ; exit if multiplier = 0
 233 __mulqi3_exit:
 234         mov     r_arg1,r_res    ; result to return register
 235         ret
 236 ENDF __mulqi3
 237
 238 #undef r_arg2
 239 #undef r_arg1
 240 #undef r_res
 241
 242 #endif  /* defined (L_mulqi3) */
 243
 244
 245 /*******************************************************
 246     Widening Multiplication  16 = 8 x 8  without MUL
 247     Multiplication  16 x 16  without MUL
 248 *******************************************************/
 249
 250 #define A0  22
 251 #define A1  23
 252 #define B0  24
 253 #define BB0 20
 254 #define B1  25
 255 ;; Output overlaps input, thus expand result in CC0/1
 256 #define C0  24
 257 #define C1  25
 258 #define CC0  __tmp_reg__
 259 #define CC1  21
 260
 261 #if defined (L_umulqihi3)
 262 ;;; R25:R24 = (unsigned int) R22 * (unsigned int) R24
 263 ;;; (C1:C0) = (unsigned int) A0  * (unsigned int) B0
 264 ;;; Clobbers: __tmp_reg__, R21..R23
 265 DEFUN __umulqihi3
 266     clr     A1
 267     clr     B1
 268     XJMP    __mulhi3
 269 ENDF __umulqihi3
 270 #endif /* L_umulqihi3 */
 271
 272 #if defined (L_mulqihi3)
 273 ;;; R25:R24 = (signed int) R22 * (signed int) R24
 274 ;;; (C1:C0) = (signed int) A0  * (signed int) B0
 275 ;;; Clobbers: __tmp_reg__, R20..R23
 276 DEFUN __mulqihi3
 277     ;; Sign-extend B0
 278     clr     B1
 279     sbrc    B0, 7
 280     com     B1
 281     ;; The multiplication runs twice as fast if A1 is zero, thus:
 282     ;; Zero-extend A0
 283     clr     A1
 284 #ifdef __AVR_HAVE_JMP_CALL__
 285     ;; Store  B0 * sign of A
 286     clr     BB0
 287     sbrc    A0, 7
 288     mov     BB0, B0
 289     call    __mulhi3
 290 #else /* have no CALL */
 291     ;; Skip sign-extension of A if A >= 0
 292     ;; Same size as with the first alternative but avoids errata skip
 293     ;; and is faster if A >= 0
 294     sbrs    A0, 7
 295     rjmp    __mulhi3
 296     ;; If  A < 0  store B
 297     mov     BB0, B0
 298     rcall   __mulhi3
 299 #endif /* HAVE_JMP_CALL */
 300     ;; 1-extend A after the multiplication
 301     sub     C1, BB0
 302     ret
 303 ENDF __mulqihi3
 304 #endif /* L_mulqihi3 */
 305
 306 #if defined (L_mulhi3)
 307 ;;; R25:R24 = R23:R22 * R25:R24
 308 ;;; (C1:C0) = (A1:A0) * (B1:B0)
 309 ;;; Clobbers: __tmp_reg__, R21..R23
 310 DEFUN __mulhi3
 311
 312     ;; Clear result
 313     clr     CC0
 314     clr     CC1
 315     rjmp 3f
 316 1:
 317     ;; Bit n of A is 1  -->  C += B << n
 318     add     CC0, B0
 319     adc     CC1, B1
 320 2:
 321     lsl     B0
 322     rol     B1
 323 3:
 324     ;; If B == 0 we are ready
 325     wsubi   B0, 0
 326     breq 9f
 327
 328     ;; Carry = n-th bit of A
 329     lsr     A1
 330     ror     A0
 331     ;; If bit n of A is set, then go add  B * 2^n  to  C
 332     brcs 1b
 333
 334     ;; Carry = 0  -->  The ROR above acts like  CP A0, 0
 335     ;; Thus, it is sufficient to CPC the high part to test A against 0
 336     cpc     A1, __zero_reg__
 337     ;; Only proceed if A != 0
 338     brne    2b
 339 9:
 340     ;; Move Result into place
 341     mov     C0, CC0
 342     mov     C1, CC1
 343     ret
 344 ENDF  __mulhi3
 345 #endif /* L_mulhi3 */
 346
 347 #undef A0
 348 #undef A1
 349 #undef B0
 350 #undef BB0
 351 #undef B1
 352 #undef C0
 353 #undef C1
 354 #undef CC0
 355 #undef CC1
 356
 357 \f
 358 #define A0 22
 359 #define A1 A0+1
 360 #define A2 A0+2
 361 #define A3 A0+3
 362
 363 #define B0 18
 364 #define B1 B0+1
 365 #define B2 B0+2
 366 #define B3 B0+3
 367
 368 #define CC0 26
 369 #define CC1 CC0+1
 370 #define CC2 30
 371 #define CC3 CC2+1
 372
 373 #define C0 22
 374 #define C1 C0+1
 375 #define C2 C0+2
 376 #define C3 C0+3
 377
 378 /*******************************************************
 379     Widening Multiplication  32 = 16 x 16  without MUL
 380 *******************************************************/
 381
 382 #if defined (L_umulhisi3)
 383 DEFUN __umulhisi3
 384     wmov    B0, 24
 385     ;; Zero-extend B
 386     clr     B2
 387     clr     B3
 388     ;; Zero-extend A
 389     wmov    A2, B2
 390     XJMP    __mulsi3
 391 ENDF __umulhisi3
 392 #endif /* L_umulhisi3 */
 393
 394 #if defined (L_mulhisi3)
 395 DEFUN __mulhisi3
 396     wmov    B0, 24
 397     ;; Sign-extend B
 398     lsl     r25
 399     sbc     B2, B2
 400     mov     B3, B2
 401 #ifdef __AVR_ERRATA_SKIP_JMP_CALL__
 402     ;; Sign-extend A
 403     clr     A2
 404     sbrc    A1, 7
 405     com     A2
 406     mov     A3, A2
 407     XJMP __mulsi3
 408 #else /*  no __AVR_ERRATA_SKIP_JMP_CALL__ */
 409     ;; Zero-extend A and __mulsi3 will run at least twice as fast
 410     ;; compared to a sign-extended A.
 411     clr     A2
 412     clr     A3
 413     sbrs    A1, 7
 414     XJMP __mulsi3
 415     ;; If  A < 0  then perform the  B * 0xffff.... before the
 416     ;; very multiplication by initializing the high part of the
 417     ;; result CC with -B.
 418     wmov    CC2, A2
 419     sub     CC2, B0
 420     sbc     CC3, B1
 421     XJMP __mulsi3_helper
 422 #endif /*  __AVR_ERRATA_SKIP_JMP_CALL__ */
 423 ENDF __mulhisi3
 424 #endif /* L_mulhisi3 */
 425
 426
 427 /*******************************************************
 428     Multiplication  32 x 32  without MUL
 429 *******************************************************/
 430
 431 #if defined (L_mulsi3)
 432 DEFUN __mulsi3
 433 #if defined (__AVR_TINY__)
 434     in     r26, __SP_L__ ; safe to use X, as it is CC0/CC1
 435     in     r27, __SP_H__
 436     subi   r26, lo8(-3)   ; Add 3 to point past return address
 437     sbci   r27, hi8(-3)
 438     push   B0    ; save callee saved regs
 439     push   B1
 440     ld     B0, X+   ; load from caller stack
 441     ld     B1, X+
 442     ld     B2, X+
 443     ld     B3, X
 444 #endif
 445     ;; Clear result
 446     clr     CC2
 447     clr     CC3
 448     ;; FALLTHRU
 449 ENDF  __mulsi3
 450
 451 DEFUN __mulsi3_helper
 452     clr     CC0
 453     clr     CC1
 454     rjmp 3f
 455
 456 1:  ;; If bit n of A is set, then add  B * 2^n  to the result in CC
 457     ;; CC += B
 458     add  CC0,B0  $  adc  CC1,B1  $  adc  CC2,B2  $  adc  CC3,B3
 459
 460 2:  ;; B <<= 1
 461     lsl  B0      $  rol  B1      $  rol  B2      $  rol  B3
 462
 463 3:  ;; A >>= 1:  Carry = n-th bit of A
 464     lsr  A3      $  ror  A2      $  ror  A1      $  ror  A0
 465
 466     brcs 1b
 467     ;; Only continue if  A != 0
 468     sbci    A1, 0
 469     brne 2b
 470     wsubi   A2, 0
 471     brne 2b
 472
 473     ;; All bits of A are consumed:  Copy result to return register C
 474     wmov    C0, CC0
 475     wmov    C2, CC2
 476 #if defined (__AVR_TINY__)
 477     pop     B1      ; restore callee saved regs
 478     pop     B0
 479 #endif  /* defined (__AVR_TINY__) */
 480
 481     ret
 482 ENDF __mulsi3_helper
 483 #endif /* L_mulsi3 */
 484
 485 #undef A0
 486 #undef A1
 487 #undef A2
 488 #undef A3
 489 #undef B0
 490 #undef B1
 491 #undef B2
 492 #undef B3
 493 #undef C0
 494 #undef C1
 495 #undef C2
 496 #undef C3
 497 #undef CC0
 498 #undef CC1
 499 #undef CC2
 500 #undef CC3
 501
 502 #endif /* !defined (__AVR_HAVE_MUL__) */
 503 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 504 \f
 505 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 506 #if defined (__AVR_HAVE_MUL__)
 507 #define A0 26
 508 #define B0 18
 509 #define C0 22
 510
 511 #define A1 A0+1
 512
 513 #define B1 B0+1
 514 #define B2 B0+2
 515 #define B3 B0+3
 516
 517 #define C1 C0+1
 518 #define C2 C0+2
 519 #define C3 C0+3
 520
 521 /*******************************************************
 522     Widening Multiplication  32 = 16 x 16  with MUL
 523 *******************************************************/
 524
 525 #if defined (L_mulhisi3)
 526 ;;; R25:R22 = (signed long) R27:R26 * (signed long) R19:R18
 527 ;;; C3:C0   = (signed long) A1:A0   * (signed long) B1:B0
 528 ;;; Clobbers: __tmp_reg__
 529 DEFUN __mulhisi3
 530     XCALL   __umulhisi3
 531     ;; Sign-extend B
 532     tst     B1
 533     brpl    1f
 534     sub     C2, A0
 535     sbc     C3, A1
 536 1:  ;; Sign-extend A
 537     XJMP __usmulhisi3_tail
 538 ENDF __mulhisi3
 539 #endif /* L_mulhisi3 */
 540
 541 #if defined (L_usmulhisi3)
 542 ;;; R25:R22 = (signed long) R27:R26 * (unsigned long) R19:R18
 543 ;;; C3:C0   = (signed long) A1:A0   * (unsigned long) B1:B0
 544 ;;; Clobbers: __tmp_reg__
 545 DEFUN __usmulhisi3
 546     XCALL   __umulhisi3
 547     ;; FALLTHRU
 548 ENDF __usmulhisi3
 549
 550 DEFUN __usmulhisi3_tail
 551     ;; Sign-extend A
 552     sbrs    A1, 7
 553     ret
 554     sub     C2, B0
 555     sbc     C3, B1
 556     ret
 557 ENDF __usmulhisi3_tail
 558 #endif /* L_usmulhisi3 */
 559
 560 #if defined (L_umulhisi3)
 561 ;;; R25:R22 = (unsigned long) R27:R26 * (unsigned long) R19:R18
 562 ;;; C3:C0   = (unsigned long) A1:A0   * (unsigned long) B1:B0
 563 ;;; Clobbers: __tmp_reg__
 564 DEFUN __umulhisi3
 565     mul     A0, B0
 566     movw    C0, r0
 567     mul     A1, B1
 568     movw    C2, r0
 569     mul     A0, B1
 570 #ifdef __AVR_HAVE_JMP_CALL__
 571     ;; This function is used by many other routines, often multiple times.
 572     ;; Therefore, if the flash size is not too limited, avoid the RCALL
 573     ;; and inverst 6 Bytes to speed things up.
 574     add     C1, r0
 575     adc     C2, r1
 576     clr     __zero_reg__
 577     adc     C3, __zero_reg__
 578 #else
 579     rcall   1f
 580 #endif
 581     mul     A1, B0
 582 1:  add     C1, r0
 583     adc     C2, r1
 584     clr     __zero_reg__
 585     adc     C3, __zero_reg__
 586     ret
 587 ENDF __umulhisi3
 588 #endif /* L_umulhisi3 */
 589
 590 /*******************************************************
 591     Widening Multiplication  32 = 16 x 32  with MUL
 592 *******************************************************/
 593
 594 #if defined (L_mulshisi3)
 595 ;;; R25:R22 = (signed long) R27:R26 * R21:R18
 596 ;;; (C3:C0) = (signed long) A1:A0   * B3:B0
 597 ;;; Clobbers: __tmp_reg__
 598 DEFUN __mulshisi3
 599 #ifdef __AVR_ERRATA_SKIP_JMP_CALL__
 600     ;; Some cores have problem skipping 2-word instruction
 601     tst     A1
 602     brmi    __mulohisi3
 603 #else
 604     sbrs    A1, 7
 605 #endif /* __AVR_HAVE_JMP_CALL__ */
 606     XJMP    __muluhisi3
 607     ;; FALLTHRU
 608 ENDF __mulshisi3
 609
 610 ;;; R25:R22 = (one-extended long) R27:R26 * R21:R18
 611 ;;; (C3:C0) = (one-extended long) A1:A0   * B3:B0
 612 ;;; Clobbers: __tmp_reg__
 613 DEFUN __mulohisi3
 614     XCALL   __muluhisi3
 615     ;; One-extend R27:R26 (A1:A0)
 616     sub     C2, B0
 617     sbc     C3, B1
 618     ret
 619 ENDF __mulohisi3
 620 #endif /* L_mulshisi3 */
 621
 622 #if defined (L_muluhisi3)
 623 ;;; R25:R22 = (unsigned long) R27:R26 * R21:R18
 624 ;;; (C3:C0) = (unsigned long) A1:A0   * B3:B0
 625 ;;; Clobbers: __tmp_reg__
 626 DEFUN __muluhisi3
 627     XCALL   __umulhisi3
 628     mul     A0, B3
 629     add     C3, r0
 630     mul     A1, B2
 631     add     C3, r0
 632     mul     A0, B2
 633     add     C2, r0
 634     adc     C3, r1
 635     clr     __zero_reg__
 636     ret
 637 ENDF __muluhisi3
 638 #endif /* L_muluhisi3 */
 639
 640 /*******************************************************
 641     Multiplication  32 x 32  with MUL
 642 *******************************************************/
 643
 644 #if defined (L_mulsi3)
 645 ;;; R25:R22 = R25:R22 * R21:R18
 646 ;;; (C3:C0) = C3:C0   * B3:B0
 647 ;;; Clobbers: R26, R27, __tmp_reg__
 648 DEFUN __mulsi3
 649     movw    A0, C0
 650     push    C2
 651     push    C3
 652     XCALL   __muluhisi3
 653     pop     A1
 654     pop     A0
 655     ;; A1:A0 now contains the high word of A
 656     mul     A0, B0
 657     add     C2, r0
 658     adc     C3, r1
 659     mul     A0, B1
 660     add     C3, r0
 661     mul     A1, B0
 662     add     C3, r0
 663     clr     __zero_reg__
 664     ret
 665 ENDF __mulsi3
 666 #endif /* L_mulsi3 */
 667
 668 #undef A0
 669 #undef A1
 670
 671 #undef B0
 672 #undef B1
 673 #undef B2
 674 #undef B3
 675
 676 #undef C0
 677 #undef C1
 678 #undef C2
 679 #undef C3
 680
 681 #endif /* __AVR_HAVE_MUL__ */
 682
 683 /*******************************************************
 684        Multiplication 24 x 24 with MUL
 685 *******************************************************/
 686
 687 #if defined (L_mulpsi3)
 688
 689 ;; A[0..2]: In: Multiplicand; Out: Product
 690 #define A0  22
 691 #define A1  A0+1
 692 #define A2  A0+2
 693
 694 ;; B[0..2]: In: Multiplier
 695 #define B0  18
 696 #define B1  B0+1
 697 #define B2  B0+2
 698
 699 #if defined (__AVR_HAVE_MUL__)
 700
 701 ;; C[0..2]: Expand Result
 702 #define C0  22
 703 #define C1  C0+1
 704 #define C2  C0+2
 705
 706 ;; R24:R22 *= R20:R18
 707 ;; Clobbers: r21, r25, r26, r27, __tmp_reg__
 708
 709 #define AA0 26
 710 #define AA2 21
 711
 712 DEFUN __mulpsi3
 713     wmov    AA0, A0
 714     mov     AA2, A2
 715     XCALL   __umulhisi3
 716     mul     AA2, B0     $  add  C2, r0
 717     mul     AA0, B2     $  add  C2, r0
 718     clr     __zero_reg__
 719     ret
 720 ENDF __mulpsi3
 721
 722 #undef AA2
 723 #undef AA0
 724
 725 #undef C2
 726 #undef C1
 727 #undef C0
 728
 729 #else /* !HAVE_MUL */
 730 ;; C[0..2]: Expand Result
 731 #if defined (__AVR_TINY__)
 732 #define C0  16
 733 #else
 734 #define C0  0
 735 #endif /* defined (__AVR_TINY__) */
 736 #define C1  C0+1
 737 #define C2  21
 738
 739 ;; R24:R22 *= R20:R18
 740 ;; Clobbers: __tmp_reg__, R18, R19, R20, R21
 741
 742 DEFUN __mulpsi3
 743 #if defined (__AVR_TINY__)
 744     in r26,__SP_L__
 745     in r27,__SP_H__
 746     subi r26, lo8(-3)   ; Add 3 to point past return address
 747     sbci r27, hi8(-3)
 748     push B0    ; save callee saved regs
 749     push B1
 750     ld B0,X+   ; load from caller stack
 751     ld B1,X+
 752     ld B2,X+
 753 #endif /* defined (__AVR_TINY__) */
 754
 755     ;; C[] = 0
 756     clr     __tmp_reg__
 757     clr     C2
 758
 759 0:  ;; Shift N-th Bit of B[] into Carry.  N = 24 - Loop
 760     LSR  B2     $  ror  B1     $  ror  B0
 761
 762     ;; If the N-th Bit of B[] was set...
 763     brcc    1f
 764
 765     ;; ...then add A[] * 2^N to the Result C[]
 766     ADD  C0,A0  $  adc  C1,A1  $  adc  C2,A2
 767
 768 1:  ;; Multiply A[] by 2
 769     LSL  A0     $  rol  A1     $  rol  A2
 770
 771     ;; Loop until B[] is 0
 772     subi B0,0   $  sbci B1,0   $  sbci B2,0
 773     brne    0b
 774
 775     ;; Copy C[] to the return Register A[]
 776     wmov    A0, C0
 777     mov     A2, C2
 778
 779     clr     __zero_reg__
 780 #if defined (__AVR_TINY__)
 781     pop B1
 782     pop B0
 783 #endif /* (__AVR_TINY__) */
 784     ret
 785 ENDF __mulpsi3
 786
 787 #undef C2
 788 #undef C1
 789 #undef C0
 790
 791 #endif /* HAVE_MUL */
 792
 793 #undef B2
 794 #undef B1
 795 #undef B0
 796
 797 #undef A2
 798 #undef A1
 799 #undef A0
 800
 801 #endif /* L_mulpsi3 */
 802
 803 #if defined (L_mulsqipsi3) && defined (__AVR_HAVE_MUL__)
 804
 805 ;; A[0..2]: In: Multiplicand
 806 #define A0  22
 807 #define A1  A0+1
 808 #define A2  A0+2
 809
 810 ;; BB: In: Multiplier
 811 #define BB  25
 812
 813 ;; C[0..2]: Result
 814 #define C0  18
 815 #define C1  C0+1
 816 #define C2  C0+2
 817
 818 ;; C[] = A[] * sign_extend (BB)
 819 DEFUN __mulsqipsi3
 820     mul     A0, BB
 821     movw    C0, r0
 822     mul     A2, BB
 823     mov     C2, r0
 824     mul     A1, BB
 825     add     C1, r0
 826     adc     C2, r1
 827     clr     __zero_reg__
 828     sbrs    BB, 7
 829     ret
 830     ;; One-extend BB
 831     sub     C1, A0
 832     sbc     C2, A1
 833     ret
 834 ENDF __mulsqipsi3
 835
 836 #undef C2
 837 #undef C1
 838 #undef C0
 839
 840 #undef BB
 841
 842 #undef A2
 843 #undef A1
 844 #undef A0
 845
 846 #endif /* L_mulsqipsi3  &&  HAVE_MUL */
 847
 848 /*******************************************************
 849        Multiplication 64 x 64
 850 *******************************************************/
 851
 852 ;; A[] = A[] * B[]
 853
 854 ;; A[0..7]: In: Multiplicand
 855 ;; Out: Product
 856 #define A0  18
 857 #define A1  A0+1
 858 #define A2  A0+2
 859 #define A3  A0+3
 860 #define A4  A0+4
 861 #define A5  A0+5
 862 #define A6  A0+6
 863 #define A7  A0+7
 864
 865 ;; B[0..7]: In: Multiplier
 866 #define B0  10
 867 #define B1  B0+1
 868 #define B2  B0+2
 869 #define B3  B0+3
 870 #define B4  B0+4
 871 #define B5  B0+5
 872 #define B6  B0+6
 873 #define B7  B0+7
 874
 875 #ifndef __AVR_TINY__
 876 #if defined (__AVR_HAVE_MUL__)
 877 ;; Define C[] for convenience
 878 ;; Notice that parts of C[] overlap A[] respective B[]
 879 #define C0  16
 880 #define C1  C0+1
 881 #define C2  20
 882 #define C3  C2+1
 883 #define C4  28
 884 #define C5  C4+1
 885 #define C6  C4+2
 886 #define C7  C4+3
 887
 888 #if defined (L_muldi3)
 889
 890 ;; A[]     *= B[]
 891 ;; R25:R18 *= R17:R10
 892 ;; Ordinary ABI-Function
 893
 894 DEFUN __muldi3
 895     push    r29
 896     push    r28
 897     push    r17
 898     push    r16
 899
 900     ;; Counting in Words, we have to perform a 4 * 4 Multiplication
 901
 902     ;; 3 * 0  +  0 * 3
 903     mul  A7,B0  $             $  mov C7,r0
 904     mul  A0,B7  $             $  add C7,r0
 905     mul  A6,B1  $             $  add C7,r0
 906     mul  A6,B0  $  mov C6,r0  $  add C7,r1
 907     mul  B6,A1  $             $  add C7,r0
 908     mul  B6,A0  $  add C6,r0  $  adc C7,r1
 909
 910     ;; 1 * 2
 911     mul  A2,B4  $  add C6,r0  $  adc C7,r1
 912     mul  A3,B4  $             $  add C7,r0
 913     mul  A2,B5  $             $  add C7,r0
 914
 915     push    A5
 916     push    A4
 917     push    B1
 918     push    B0
 919     push    A3
 920     push    A2
 921
 922     ;; 0 * 0
 923     wmov    26, B0
 924     XCALL   __umulhisi3
 925     wmov    C0, 22
 926     wmov    C2, 24
 927
 928     ;; 0 * 2
 929     wmov    26, B4
 930     XCALL   __umulhisi3  $  wmov C4,22            $ add C6,24 $ adc C7,25
 931
 932     wmov    26, B2
 933     ;; 0 * 1
 934     XCALL   __muldi3_6
 935
 936     pop     A0
 937     pop     A1
 938     ;; 1 * 1
 939     wmov    26, B2
 940     XCALL   __umulhisi3  $  add C4,22 $ adc C5,23 $ adc C6,24 $ adc C7,25
 941
 942     pop     r26
 943     pop     r27
 944     ;; 1 * 0
 945     XCALL   __muldi3_6
 946
 947     pop     A0
 948     pop     A1
 949     ;; 2 * 0
 950     XCALL   __umulhisi3  $  add C4,22 $ adc C5,23 $ adc C6,24 $ adc C7,25
 951
 952     ;; 2 * 1
 953     wmov    26, B2
 954     XCALL   __umulhisi3  $            $           $ add C6,22 $ adc C7,23
 955
 956     ;; A[] = C[]
 957     wmov    A0, C0
 958     ;; A2 = C2 already
 959     wmov    A4, C4
 960     wmov    A6, C6
 961
 962     pop     r16
 963     pop     r17
 964     pop     r28
 965     pop     r29
 966     ret
 967 ENDF __muldi3
 968 #endif /* L_muldi3 */
 969
 970 #if defined (L_muldi3_6)
 971 ;; A helper for some 64-bit multiplications with MUL available
 972 DEFUN __muldi3_6
 973 __muldi3_6:
 974     XCALL   __umulhisi3
 975     add     C2, 22
 976     adc     C3, 23
 977     adc     C4, 24
 978     adc     C5, 25
 979     brcc    0f
 980     adiw    C6, 1
 981 0:  ret
 982 ENDF __muldi3_6
 983 #endif /* L_muldi3_6 */
 984
 985 #undef C7
 986 #undef C6
 987 #undef C5
 988 #undef C4
 989 #undef C3
 990 #undef C2
 991 #undef C1
 992 #undef C0
 993
 994 #else /* !HAVE_MUL */
 995
 996 #if defined (L_muldi3)
 997
 998 #define C0  26
 999 #define C1  C0+1
1000 #define C2  C0+2
1001 #define C3  C0+3
1002 #define C4  C0+4
1003 #define C5  C0+5
1004 #define C6  0
1005 #define C7  C6+1
1006
1007 #define Loop 9
1008
1009 ;; A[]     *= B[]
1010 ;; R25:R18 *= R17:R10
1011 ;; Ordinary ABI-Function
1012
1013 DEFUN __muldi3
1014     push    r29
1015     push    r28
1016     push    Loop
1017
1018     ldi     C0, 64
1019     mov     Loop, C0
1020
1021     ;; C[] = 0
1022     clr     __tmp_reg__
1023     wmov    C0, 0
1024     wmov    C2, 0
1025     wmov    C4, 0
1026
1027 0:  ;; Rotate B[] right by 1 and set Carry to the N-th Bit of B[]
1028     ;; where N = 64 - Loop.
1029     ;; Notice that B[] = B[] >>> 64 so after this Routine has finished,
1030     ;; B[] will have its initial Value again.
1031     LSR  B7     $  ror  B6     $  ror  B5     $  ror  B4
1032     ror  B3     $  ror  B2     $  ror  B1     $  ror  B0
1033
1034     ;; If the N-th Bit of B[] was set then...
1035     brcc    1f
1036     ;; ...finish Rotation...
1037     ori     B7, 1 << 7
1038
1039     ;; ...and add A[] * 2^N to the Result C[]
1040     ADD  C0,A0  $  adc  C1,A1  $  adc  C2,A2  $  adc  C3,A3
1041     adc  C4,A4  $  adc  C5,A5  $  adc  C6,A6  $  adc  C7,A7
1042
1043 1:  ;; Multiply A[] by 2
1044     LSL  A0     $  rol  A1     $  rol  A2     $  rol  A3
1045     rol  A4     $  rol  A5     $  rol  A6     $  rol  A7
1046
1047     dec     Loop
1048     brne    0b
1049
1050     ;; We expanded the Result in C[]
1051     ;; Copy Result to the Return Register A[]
1052     wmov    A0, C0
1053     wmov    A2, C2
1054     wmov    A4, C4
1055     wmov    A6, C6
1056
1057     clr     __zero_reg__
1058     pop     Loop
1059     pop     r28
1060     pop     r29
1061     ret
1062 ENDF __muldi3
1063
1064 #undef Loop
1065
1066 #undef C7
1067 #undef C6
1068 #undef C5
1069 #undef C4
1070 #undef C3
1071 #undef C2
1072 #undef C1
1073 #undef C0
1074
1075 #endif /* L_muldi3 */
1076 #endif /* HAVE_MUL */
1077 #endif /* if not __AVR_TINY__ */
1078
1079 #undef B7
1080 #undef B6
1081 #undef B5
1082 #undef B4
1083 #undef B3
1084 #undef B2
1085 #undef B1
1086 #undef B0
1087
1088 #undef A7
1089 #undef A6
1090 #undef A5
1091 #undef A4
1092 #undef A3
1093 #undef A2
1094 #undef A1
1095 #undef A0
1096
1097 /*******************************************************
1098    Widening Multiplication 64 = 32 x 32  with  MUL
1099 *******************************************************/
1100
1101 #if defined (__AVR_HAVE_MUL__)
1102 #define A0 r22
1103 #define A1 r23
1104 #define A2 r24
1105 #define A3 r25
1106
1107 #define B0 r18
1108 #define B1 r19
1109 #define B2 r20
1110 #define B3 r21
1111
1112 #define C0  18
1113 #define C1  C0+1
1114 #define C2  20
1115 #define C3  C2+1
1116 #define C4  28
1117 #define C5  C4+1
1118 #define C6  C4+2
1119 #define C7  C4+3
1120
1121 #if defined (L_umulsidi3)
1122
1123 ;; Unsigned widening 64 = 32 * 32 Multiplication with MUL
1124
1125 ;; R18[8] = R22[4] * R18[4]
1126 ;;
1127 ;; Ordinary ABI Function, but additionally sets
1128 ;; X = R20[2] = B2[2]
1129 ;; Z = R22[2] = A0[2]
1130 DEFUN __umulsidi3
1131     clt
1132     ;; FALLTHRU
1133 ENDF  __umulsidi3
1134     ;; T = sign (A)
1135 DEFUN __umulsidi3_helper
1136     push    29  $  push    28 ; Y
1137     wmov    30, A2
1138     ;; Counting in Words, we have to perform 4 Multiplications
1139     ;; 0 * 0
1140     wmov    26, A0
1141     XCALL __umulhisi3
1142     push    23  $  push    22 ; C0
1143     wmov    28, B0
1144     wmov    18, B2
1145     wmov    C2, 24
1146     push    27  $  push    26 ; A0
1147     push    19  $  push    18 ; B2
1148     ;;
1149     ;;  18  20  22  24  26  28  30  |  B2, B3, A0, A1, C0, C1, Y
1150     ;;  B2  C2  --  --  --  B0  A2
1151     ;; 1 * 1
1152     wmov    26, 30      ; A2
1153     XCALL __umulhisi3
1154     ;; Sign-extend A.  T holds the sign of A
1155     brtc    0f
1156     ;; Subtract B from the high part of the result
1157     sub     22, 28
1158     sbc     23, 29
1159     sbc     24, 18
1160     sbc     25, 19
1161 0:  wmov    18, 28      ;; B0
1162     wmov    C4, 22
1163     wmov    C6, 24
1164     ;;
1165     ;;  18  20  22  24  26  28  30  |  B2, B3, A0, A1, C0, C1, Y
1166     ;;  B0  C2  --  --  A2  C4  C6
1167     ;;
1168     ;; 1 * 0
1169     XCALL __muldi3_6
1170     ;; 0 * 1
1171     pop     26  $   pop 27  ;; B2
1172     pop     18  $   pop 19  ;; A0
1173     XCALL __muldi3_6
1174
1175     ;; Move result C into place and save A0 in Z
1176     wmov    22, C4
1177     wmov    24, C6
1178     wmov    30, 18 ; A0
1179     pop     C0  $   pop C1
1180
1181     ;; Epilogue
1182     pop     28  $   pop 29  ;; Y
1183     ret
1184 ENDF __umulsidi3_helper
1185 #endif /* L_umulsidi3 */
1186
1187
1188 #if defined (L_mulsidi3)
1189
1190 ;; Signed widening 64 = 32 * 32 Multiplication
1191 ;;
1192 ;; R18[8] = R22[4] * R18[4]
1193 ;; Ordinary ABI Function
1194 DEFUN __mulsidi3
1195     bst     A3, 7
1196     sbrs    B3, 7           ; Enhanced core has no skip bug
1197     XJMP __umulsidi3_helper
1198
1199     ;; B needs sign-extension
1200     push    A3
1201     push    A2
1202     XCALL __umulsidi3_helper
1203     ;; A0 survived in Z
1204     sub     r22, r30
1205     sbc     r23, r31
1206     pop     r26
1207     pop     r27
1208     sbc     r24, r26
1209     sbc     r25, r27
1210     ret
1211 ENDF __mulsidi3
1212 #endif /* L_mulsidi3 */
1213
1214 #undef A0
1215 #undef A1
1216 #undef A2
1217 #undef A3
1218 #undef B0
1219 #undef B1
1220 #undef B2
1221 #undef B3
1222 #undef C0
1223 #undef C1
1224 #undef C2
1225 #undef C3
1226 #undef C4
1227 #undef C5
1228 #undef C6
1229 #undef C7
1230 #endif /* HAVE_MUL */
1231
1232 /**********************************************************
1233     Widening Multiplication 64 = 32 x 32  without  MUL
1234 **********************************************************/
1235 #ifndef __AVR_TINY__ /* if not __AVR_TINY__ */
1236 #if defined (L_mulsidi3) && !defined (__AVR_HAVE_MUL__)
1237 #define A0 18
1238 #define A1 A0+1
1239 #define A2 A0+2
1240 #define A3 A0+3
1241 #define A4 A0+4
1242 #define A5 A0+5
1243 #define A6 A0+6
1244 #define A7 A0+7
1245
1246 #define B0 10
1247 #define B1 B0+1
1248 #define B2 B0+2
1249 #define B3 B0+3
1250 #define B4 B0+4
1251 #define B5 B0+5
1252 #define B6 B0+6
1253 #define B7 B0+7
1254
1255 #define AA0 22
1256 #define AA1 AA0+1
1257 #define AA2 AA0+2
1258 #define AA3 AA0+3
1259
1260 #define BB0 18
1261 #define BB1 BB0+1
1262 #define BB2 BB0+2
1263 #define BB3 BB0+3
1264
1265 #define Mask r30
1266
1267 ;; Signed / Unsigned widening 64 = 32 * 32 Multiplication without MUL
1268 ;;
1269 ;; R18[8] = R22[4] * R18[4]
1270 ;; Ordinary ABI Function
1271 DEFUN __mulsidi3
1272     set
1273     skip
1274     ;; FALLTHRU
1275 ENDF  __mulsidi3
1276
1277 DEFUN __umulsidi3
1278     clt     ; skipped
1279     ;; Save 10 Registers: R10..R17, R28, R29
1280     do_prologue_saves 10
1281     ldi     Mask, 0xff
1282     bld     Mask, 7
1283     ;; Move B into place...
1284     wmov    B0, BB0
1285     wmov    B2, BB2
1286     ;; ...and extend it
1287     and     BB3, Mask
1288     lsl     BB3
1289     sbc     B4, B4
1290     mov     B5, B4
1291     wmov    B6, B4
1292     ;; Move A into place...
1293     wmov    A0, AA0
1294     wmov    A2, AA2
1295     ;; ...and extend it
1296     and     AA3, Mask
1297     lsl     AA3
1298     sbc     A4, A4
1299     mov     A5, A4
1300     wmov    A6, A4
1301     XCALL   __muldi3
1302     do_epilogue_restores 10
1303 ENDF __umulsidi3
1304
1305 #undef A0
1306 #undef A1
1307 #undef A2
1308 #undef A3
1309 #undef A4
1310 #undef A5
1311 #undef A6
1312 #undef A7
1313 #undef B0
1314 #undef B1
1315 #undef B2
1316 #undef B3
1317 #undef B4
1318 #undef B5
1319 #undef B6
1320 #undef B7
1321 #undef AA0
1322 #undef AA1
1323 #undef AA2
1324 #undef AA3
1325 #undef BB0
1326 #undef BB1
1327 #undef BB2
1328 #undef BB3
1329 #undef Mask
1330 #endif /* L_mulsidi3 && !HAVE_MUL */
1331 #endif /* if not __AVR_TINY__ */
1332 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
1333
1334 \f
1335 .section .text.libgcc.div, "ax", @progbits
1336
1337 /*******************************************************
1338        Division 8 / 8 => (result + remainder)
1339 *******************************************************/
1340 #define r_rem   r25     /* remainder */
1341 #define r_arg1  r24     /* dividend, quotient */
1342 #define r_arg2  r22     /* divisor */
1343 #define r_cnt   r23     /* loop count */
1344
1345 #if defined (L_udivmodqi4)
1346 DEFUN __udivmodqi4
1347         clr     r_rem           ; clear remainder
1348         ldi     r_cnt,8         ; init loop counter
1349         lsl     r_arg1          ; shift dividend
1350 __udivmodqi4_loop:
1351         rol     r_rem           ; shift dividend into remainder
1352         cp      r_rem,r_arg2    ; compare remainder & divisor
1353         brcs    __udivmodqi4_ep ; remainder <= divisor
1354         sub     r_rem,r_arg2    ; restore remainder
1355 __udivmodqi4_ep:
1356         rol     r_arg1          ; shift dividend (with CARRY)
1357         dec     r_cnt           ; decrement loop counter
1358         brne    __udivmodqi4_loop
1359         com     r_arg1          ; complement result
1360                                 ; because C flag was complemented in loop
1361         ret
1362 ENDF __udivmodqi4
1363 #endif /* defined (L_udivmodqi4) */
1364
1365 #if defined (L_divmodqi4)
1366 DEFUN __divmodqi4
1367         bst     r_arg1,7        ; store sign of dividend
1368         mov     __tmp_reg__,r_arg1
1369         eor     __tmp_reg__,r_arg2; r0.7 is sign of result
1370         sbrc    r_arg1,7
1371         neg     r_arg1          ; dividend negative : negate
1372         sbrc    r_arg2,7
1373         neg     r_arg2          ; divisor negative : negate
1374         XCALL   __udivmodqi4    ; do the unsigned div/mod
1375         brtc    __divmodqi4_1
1376         neg     r_rem           ; correct remainder sign
1377 __divmodqi4_1:
1378         sbrc    __tmp_reg__,7
1379         neg     r_arg1          ; correct result sign
1380 __divmodqi4_exit:
1381         ret
1382 ENDF __divmodqi4
1383 #endif /* defined (L_divmodqi4) */
1384
1385 #undef r_rem
1386 #undef r_arg1
1387 #undef r_arg2
1388 #undef r_cnt
1389
1390
1391 /*******************************************************
1392        Division 16 / 16 => (result + remainder)
1393 *******************************************************/
1394 #define r_remL  r26     /* remainder Low */
1395 #define r_remH  r27     /* remainder High */
1396
1397 /* return: remainder */
1398 #define r_arg1L r24     /* dividend Low */
1399 #define r_arg1H r25     /* dividend High */
1400
1401 /* return: quotient */
1402 #define r_arg2L r22     /* divisor Low */
1403 #define r_arg2H r23     /* divisor High */
1404
1405 #define r_cnt   r21     /* loop count */
1406
1407 #if defined (L_udivmodhi4)
1408 DEFUN __udivmodhi4
1409         sub     r_remL,r_remL
1410         sub     r_remH,r_remH   ; clear remainder and carry
1411         ldi     r_cnt,17        ; init loop counter
1412         rjmp    __udivmodhi4_ep ; jump to entry point
1413 __udivmodhi4_loop:
1414         rol     r_remL          ; shift dividend into remainder
1415         rol     r_remH
1416         cp      r_remL,r_arg2L  ; compare remainder & divisor
1417         cpc     r_remH,r_arg2H
1418         brcs    __udivmodhi4_ep ; remainder < divisor
1419         sub     r_remL,r_arg2L  ; restore remainder
1420         sbc     r_remH,r_arg2H
1421 __udivmodhi4_ep:
1422         rol     r_arg1L         ; shift dividend (with CARRY)
1423         rol     r_arg1H
1424         dec     r_cnt           ; decrement loop counter
1425         brne    __udivmodhi4_loop
1426         com     r_arg1L
1427         com     r_arg1H
1428 ; div/mod results to return registers, as for the div() function
1429         mov_l   r_arg2L, r_arg1L        ; quotient
1430         mov_h   r_arg2H, r_arg1H
1431         mov_l   r_arg1L, r_remL         ; remainder
1432         mov_h   r_arg1H, r_remH
1433         ret
1434 ENDF __udivmodhi4
1435 #endif /* defined (L_udivmodhi4) */
1436
1437 #if defined (L_divmodhi4)
1438 DEFUN __divmodhi4
1439     .global _div
1440 _div:
1441     bst     r_arg1H,7           ; store sign of dividend
1442     mov     __tmp_reg__,r_arg2H
1443     brtc    0f
1444     com     __tmp_reg__         ; r0.7 is sign of result
1445     rcall   __divmodhi4_neg1    ; dividend negative: negate
1446 0:
1447     sbrc    r_arg2H,7
1448     rcall   __divmodhi4_neg2    ; divisor negative: negate
1449     XCALL   __udivmodhi4        ; do the unsigned div/mod
1450     sbrc    __tmp_reg__,7
1451     rcall   __divmodhi4_neg2    ; correct remainder sign
1452     brtc    __divmodhi4_exit
1453 __divmodhi4_neg1:
1454     ;; correct dividend/remainder sign
1455     com     r_arg1H
1456     neg     r_arg1L
1457     sbci    r_arg1H,0xff
1458     ret
1459 __divmodhi4_neg2:
1460     ;; correct divisor/result sign
1461     com     r_arg2H
1462     neg     r_arg2L
1463     sbci    r_arg2H,0xff
1464 __divmodhi4_exit:
1465     ret
1466 ENDF __divmodhi4
1467 #endif /* defined (L_divmodhi4) */
1468
1469 #undef r_remH
1470 #undef r_remL
1471
1472 #undef r_arg1H
1473 #undef r_arg1L
1474
1475 #undef r_arg2H
1476 #undef r_arg2L
1477
1478 #undef r_cnt
1479
1480 /*******************************************************
1481        Division 24 / 24 => (result + remainder)
1482 *******************************************************/
1483
1484 ;; A[0..2]: In: Dividend; Out: Quotient
1485 #define A0  22
1486 #define A1  A0+1
1487 #define A2  A0+2
1488
1489 ;; B[0..2]: In: Divisor;   Out: Remainder
1490 #define B0  18
1491 #define B1  B0+1
1492 #define B2  B0+2
1493
1494 ;; C[0..2]: Expand remainder
1495 #define C0  __zero_reg__
1496 #define C1  26
1497 #define C2  25
1498
1499 ;; Loop counter
1500 #define r_cnt   21
1501
1502 #if defined (L_udivmodpsi4)
1503 ;; R24:R22 = R24:R24  udiv  R20:R18
1504 ;; R20:R18 = R24:R22  umod  R20:R18
1505 ;; Clobbers: R21, R25, R26
1506
1507 DEFUN __udivmodpsi4
1508     ; init loop counter
1509     ldi     r_cnt, 24+1
1510     ; Clear remainder and carry.  C0 is already 0
1511     clr     C1
1512     sub     C2, C2
1513     ; jump to entry point
1514     rjmp    __udivmodpsi4_start
1515 __udivmodpsi4_loop:
1516     ; shift dividend into remainder
1517     rol     C0
1518     rol     C1
1519     rol     C2
1520     ; compare remainder & divisor
1521     cp      C0, B0
1522     cpc     C1, B1
1523     cpc     C2, B2
1524     brcs    __udivmodpsi4_start ; remainder <= divisor
1525     sub     C0, B0              ; restore remainder
1526     sbc     C1, B1
1527     sbc     C2, B2
1528 __udivmodpsi4_start:
1529     ; shift dividend (with CARRY)
1530     rol     A0
1531     rol     A1
1532     rol     A2
1533     ; decrement loop counter
1534     dec     r_cnt
1535     brne    __udivmodpsi4_loop
1536     com     A0
1537     com     A1
1538     com     A2
1539     ; div/mod results to return registers
1540     ; remainder
1541     mov     B0, C0
1542     mov     B1, C1
1543     mov     B2, C2
1544     clr     __zero_reg__ ; C0
1545     ret
1546 ENDF __udivmodpsi4
1547 #endif /* defined (L_udivmodpsi4) */
1548
1549 #if defined (L_divmodpsi4)
1550 ;; R24:R22 = R24:R22  div  R20:R18
1551 ;; R20:R18 = R24:R22  mod  R20:R18
1552 ;; Clobbers: T, __tmp_reg__, R21, R25, R26
1553
1554 DEFUN __divmodpsi4
1555     ; R0.7 will contain the sign of the result:
1556     ; R0.7 = A.sign ^ B.sign
1557     mov __tmp_reg__, B2
1558     ; T-flag = sign of dividend
1559     bst     A2, 7
1560     brtc    0f
1561     com     __tmp_reg__
1562     ; Adjust dividend's sign
1563     rcall   __divmodpsi4_negA
1564 0:
1565     ; Adjust divisor's sign
1566     sbrc    B2, 7
1567     rcall   __divmodpsi4_negB
1568
1569     ; Do the unsigned div/mod
1570     XCALL   __udivmodpsi4
1571
1572     ; Adjust quotient's sign
1573     sbrc    __tmp_reg__, 7
1574     rcall   __divmodpsi4_negA
1575
1576     ; Adjust remainder's sign
1577     brtc    __divmodpsi4_end
1578
1579 __divmodpsi4_negB:
1580     ; Correct divisor/remainder sign
1581     com     B2
1582     com     B1
1583     neg     B0
1584     sbci    B1, -1
1585     sbci    B2, -1
1586     ret
1587
1588     ; Correct dividend/quotient sign
1589 __divmodpsi4_negA:
1590     com     A2
1591     com     A1
1592     neg     A0
1593     sbci    A1, -1
1594     sbci    A2, -1
1595 __divmodpsi4_end:
1596     ret
1597
1598 ENDF __divmodpsi4
1599 #endif /* defined (L_divmodpsi4) */
1600
1601 #undef A0
1602 #undef A1
1603 #undef A2
1604
1605 #undef B0
1606 #undef B1
1607 #undef B2
1608
1609 #undef C0
1610 #undef C1
1611 #undef C2
1612
1613 #undef r_cnt
1614
1615 /*******************************************************
1616        Division 32 / 32 => (result + remainder)
1617 *******************************************************/
1618 #define r_remHH r31     /* remainder High */
1619 #define r_remHL r30
1620 #define r_remH  r27
1621 #define r_remL  r26     /* remainder Low */
1622
1623 /* return: remainder */
1624 #define r_arg1HH r25    /* dividend High */
1625 #define r_arg1HL r24
1626 #define r_arg1H  r23
1627 #define r_arg1L  r22    /* dividend Low */
1628
1629 /* return: quotient */
1630 #define r_arg2HH r21    /* divisor High */
1631 #define r_arg2HL r20
1632 #define r_arg2H  r19
1633 #define r_arg2L  r18    /* divisor Low */
1634
1635 #define r_cnt __zero_reg__  /* loop count (0 after the loop!) */
1636
1637 #if defined (L_udivmodsi4)
1638 DEFUN __udivmodsi4
1639         ldi     r_remL, 33      ; init loop counter
1640         mov     r_cnt, r_remL
1641         sub     r_remL,r_remL
1642         sub     r_remH,r_remH   ; clear remainder and carry
1643         mov_l   r_remHL, r_remL
1644         mov_h   r_remHH, r_remH
1645         rjmp    __udivmodsi4_ep ; jump to entry point
1646 __udivmodsi4_loop:
1647         rol     r_remL          ; shift dividend into remainder
1648         rol     r_remH
1649         rol     r_remHL
1650         rol     r_remHH
1651         cp      r_remL,r_arg2L  ; compare remainder & divisor
1652         cpc     r_remH,r_arg2H
1653         cpc     r_remHL,r_arg2HL
1654         cpc     r_remHH,r_arg2HH
1655         brcs    __udivmodsi4_ep ; remainder <= divisor
1656         sub     r_remL,r_arg2L  ; restore remainder
1657         sbc     r_remH,r_arg2H
1658         sbc     r_remHL,r_arg2HL
1659         sbc     r_remHH,r_arg2HH
1660 __udivmodsi4_ep:
1661         rol     r_arg1L         ; shift dividend (with CARRY)
1662         rol     r_arg1H
1663         rol     r_arg1HL
1664         rol     r_arg1HH
1665         dec     r_cnt           ; decrement loop counter
1666         brne    __udivmodsi4_loop
1667                                 ; __zero_reg__ now restored (r_cnt == 0)
1668         com     r_arg1L
1669         com     r_arg1H
1670         com     r_arg1HL
1671         com     r_arg1HH
1672 ; div/mod results to return registers, as for the ldiv() function
1673         mov_l   r_arg2L,  r_arg1L       ; quotient
1674         mov_h   r_arg2H,  r_arg1H
1675         mov_l   r_arg2HL, r_arg1HL
1676         mov_h   r_arg2HH, r_arg1HH
1677         mov_l   r_arg1L,  r_remL        ; remainder
1678         mov_h   r_arg1H,  r_remH
1679         mov_l   r_arg1HL, r_remHL
1680         mov_h   r_arg1HH, r_remHH
1681         ret
1682 ENDF __udivmodsi4
1683 #endif /* defined (L_udivmodsi4) */
1684
1685 #if defined (L_divmodsi4)
1686 DEFUN __divmodsi4
1687     mov     __tmp_reg__,r_arg2HH
1688     bst     r_arg1HH,7          ; store sign of dividend
1689     brtc    0f
1690     com     __tmp_reg__         ; r0.7 is sign of result
1691     XCALL   __negsi2            ; dividend negative: negate
1692 0:
1693     sbrc    r_arg2HH,7
1694     rcall   __divmodsi4_neg2    ; divisor negative: negate
1695     XCALL   __udivmodsi4        ; do the unsigned div/mod
1696     sbrc    __tmp_reg__, 7      ; correct quotient sign
1697     rcall   __divmodsi4_neg2
1698     brtc    __divmodsi4_exit    ; correct remainder sign
1699     XJMP    __negsi2
1700 __divmodsi4_neg2:
1701     ;; correct divisor/quotient sign
1702     com     r_arg2HH
1703     com     r_arg2HL
1704     com     r_arg2H
1705     neg     r_arg2L
1706     sbci    r_arg2H,0xff
1707     sbci    r_arg2HL,0xff
1708     sbci    r_arg2HH,0xff
1709 __divmodsi4_exit:
1710     ret
1711 ENDF __divmodsi4
1712 #endif /* defined (L_divmodsi4) */
1713
1714 #if defined (L_negsi2)
1715 ;; (set (reg:SI 22)
1716 ;;      (neg:SI (reg:SI 22)))
1717 ;; Sets the V flag for signed overflow tests
1718 DEFUN __negsi2
1719     NEG4    22
1720     ret
1721 ENDF __negsi2
1722 #endif /* L_negsi2 */
1723
1724 #undef r_remHH
1725 #undef r_remHL
1726 #undef r_remH
1727 #undef r_remL
1728 #undef r_arg1HH
1729 #undef r_arg1HL
1730 #undef r_arg1H
1731 #undef r_arg1L
1732 #undef r_arg2HH
1733 #undef r_arg2HL
1734 #undef r_arg2H
1735 #undef r_arg2L
1736 #undef r_cnt
1737
1738 /* *di routines use registers below R19 and won't work with tiny arch
1739    right now. */
1740
1741 #if !defined (__AVR_TINY__)
1742 /*******************************************************
1743        Division 64 / 64
1744        Modulo   64 % 64
1745 *******************************************************/
1746
1747 ;; Use Speed-optimized Version on "big" Devices, i.e. Devices with
1748 ;; at least 16k of Program Memory.  For smaller Devices, depend
1749 ;; on MOVW and SP Size.  There is a Connexion between SP Size and
1750 ;; Flash Size so that SP Size can be used to test for Flash Size.
1751
1752 #if defined (__AVR_HAVE_JMP_CALL__)
1753 #   define SPEED_DIV 8
1754 #elif defined (__AVR_HAVE_MOVW__) && defined (__AVR_HAVE_SPH__)
1755 #   define SPEED_DIV 16
1756 #else
1757 #   define SPEED_DIV 0
1758 #endif
1759
1760 ;; A[0..7]: In: Dividend;
1761 ;; Out: Quotient  (T = 0)
1762 ;; Out: Remainder (T = 1)
1763 #define A0  18
1764 #define A1  A0+1
1765 #define A2  A0+2
1766 #define A3  A0+3
1767 #define A4  A0+4
1768 #define A5  A0+5
1769 #define A6  A0+6
1770 #define A7  A0+7
1771
1772 ;; B[0..7]: In: Divisor;   Out: Clobber
1773 #define B0  10
1774 #define B1  B0+1
1775 #define B2  B0+2
1776 #define B3  B0+3
1777 #define B4  B0+4
1778 #define B5  B0+5
1779 #define B6  B0+6
1780 #define B7  B0+7
1781
1782 ;; C[0..7]: Expand remainder;  Out: Remainder (unused)
1783 #define C0  8
1784 #define C1  C0+1
1785 #define C2  30
1786 #define C3  C2+1
1787 #define C4  28
1788 #define C5  C4+1
1789 #define C6  26
1790 #define C7  C6+1
1791
1792 ;; Holds Signs during Division Routine
1793 #define SS      __tmp_reg__
1794
1795 ;; Bit-Counter in Division Routine
1796 #define R_cnt   __zero_reg__
1797
1798 ;; Scratch Register for Negation
1799 #define NN      r31
1800
1801 #if defined (L_udivdi3)
1802
1803 ;; R25:R18 = R24:R18  umod  R17:R10
1804 ;; Ordinary ABI-Function
1805
1806 DEFUN __umoddi3
1807     set
1808     rjmp __udivdi3_umoddi3
1809 ENDF __umoddi3
1810
1811 ;; R25:R18 = R24:R18  udiv  R17:R10
1812 ;; Ordinary ABI-Function
1813
1814 DEFUN __udivdi3
1815     clt
1816 ENDF __udivdi3
1817
1818 DEFUN __udivdi3_umoddi3
1819     push    C0
1820     push    C1
1821     push    C4
1822     push    C5
1823     XCALL   __udivmod64
1824     pop     C5
1825     pop     C4
1826     pop     C1
1827     pop     C0
1828     ret
1829 ENDF __udivdi3_umoddi3
1830 #endif /* L_udivdi3 */
1831
1832 #if defined (L_udivmod64)
1833
1834 ;; Worker Routine for 64-Bit unsigned Quotient and Remainder Computation
1835 ;; No Registers saved/restored; the Callers will take Care.
1836 ;; Preserves B[] and T-flag
1837 ;; T = 0: Compute Quotient  in A[]
1838 ;; T = 1: Compute Remainder in A[] and shift SS one Bit left
1839
1840 DEFUN __udivmod64
1841
1842     ;; Clear Remainder (C6, C7 will follow)
1843     clr     C0
1844     clr     C1
1845     wmov    C2, C0
1846     wmov    C4, C0
1847     ldi     C7, 64
1848
1849 #if SPEED_DIV == 0 || SPEED_DIV == 16
1850     ;; Initialize Loop-Counter
1851     mov     R_cnt, C7
1852     wmov    C6, C0
1853 #endif /* SPEED_DIV */
1854
1855 #if SPEED_DIV == 8
1856
1857     push    A7
1858     clr     C6
1859
1860 1:  ;; Compare shifted Devidend against Divisor
1861     ;; If -- even after Shifting -- it is smaller...
1862     CP  A7,B0  $  cpc C0,B1  $  cpc C1,B2  $  cpc C2,B3
1863     cpc C3,B4  $  cpc C4,B5  $  cpc C5,B6  $  cpc C6,B7
1864     brcc    2f
1865
1866     ;; ...then we can subtract it.  Thus, it is legal to shift left
1867                $  mov C6,C5  $  mov C5,C4  $  mov C4,C3
1868     mov C3,C2  $  mov C2,C1  $  mov C1,C0  $  mov C0,A7
1869     mov A7,A6  $  mov A6,A5  $  mov A5,A4  $  mov A4,A3
1870     mov A3,A2  $  mov A2,A1  $  mov A1,A0  $  clr A0
1871
1872     ;; 8 Bits are done
1873     subi    C7, 8
1874     brne    1b
1875
1876     ;; Shifted 64 Bits:  A7 has traveled to C7
1877     pop     C7
1878     ;; Divisor is greater than Dividend. We have:
1879     ;; A[] % B[] = A[]
1880     ;; A[] / B[] = 0
1881     ;; Thus, we can return immediately
1882     rjmp    5f
1883
1884 2:  ;; Initialze Bit-Counter with Number of Bits still to be performed
1885     mov     R_cnt, C7
1886
1887     ;; Push of A7 is not needed because C7 is still 0
1888     pop     C7
1889     clr     C7
1890
1891 #elif  SPEED_DIV == 16
1892
1893     ;; Compare shifted Dividend against Divisor
1894     cp      A7, B3
1895     cpc     C0, B4
1896     cpc     C1, B5
1897     cpc     C2, B6
1898     cpc     C3, B7
1899     brcc    2f
1900
1901     ;; Divisor is greater than shifted Dividen: We can shift the Dividend
1902     ;; and it is still smaller than the Divisor --> Shift one 32-Bit Chunk
1903     wmov  C2,A6  $  wmov C0,A4
1904     wmov  A6,A2  $  wmov A4,A0
1905     wmov  A2,C6  $  wmov A0,C4
1906
1907     ;; Set Bit Counter to 32
1908     lsr     R_cnt
1909 2:
1910 #elif SPEED_DIV
1911 #error SPEED_DIV = ?
1912 #endif /* SPEED_DIV */
1913
1914 ;; The very Division + Remainder Routine
1915
1916 3:  ;; Left-shift Dividend...
1917     lsl A0     $  rol A1     $  rol A2     $  rol A3
1918     rol A4     $  rol A5     $  rol A6     $  rol A7
1919
1920     ;; ...into Remainder
1921     rol C0     $  rol C1     $  rol C2     $  rol C3
1922     rol C4     $  rol C5     $  rol C6     $  rol C7
1923
1924     ;; Compare Remainder and Divisor
1925     CP  C0,B0  $  cpc C1,B1  $  cpc C2,B2  $  cpc C3,B3
1926     cpc C4,B4  $  cpc C5,B5  $  cpc C6,B6  $  cpc C7,B7
1927
1928     brcs 4f
1929
1930     ;; Divisor fits into Remainder:  Subtract it from Remainder...
1931     SUB C0,B0  $  sbc C1,B1  $  sbc C2,B2  $  sbc C3,B3
1932     sbc C4,B4  $  sbc C5,B5  $  sbc C6,B6  $  sbc C7,B7
1933
1934     ;; ...and set according Bit in the upcoming Quotient
1935     ;; The Bit will travel to its final Position
1936     ori A0, 1
1937
1938 4:  ;; This Bit is done
1939     dec     R_cnt
1940     brne    3b
1941     ;; __zero_reg__ is 0 again
1942
1943     ;; T = 0: We are fine with the Quotient in A[]
1944     ;; T = 1: Copy Remainder to A[]
1945 5:  brtc    6f
1946     wmov    A0, C0
1947     wmov    A2, C2
1948     wmov    A4, C4
1949     wmov    A6, C6
1950     ;; Move the Sign of the Result to SS.7
1951     lsl     SS
1952
1953 6:  ret
1954
1955 ENDF __udivmod64
1956 #endif /* L_udivmod64 */
1957
1958
1959 #if defined (L_divdi3)
1960
1961 ;; R25:R18 = R24:R18  mod  R17:R10
1962 ;; Ordinary ABI-Function
1963
1964 DEFUN __moddi3
1965     set
1966     rjmp    __divdi3_moddi3
1967 ENDF __moddi3
1968
1969 ;; R25:R18 = R24:R18  div  R17:R10
1970 ;; Ordinary ABI-Function
1971
1972 DEFUN __divdi3
1973     clt
1974 ENDF __divdi3
1975
1976 DEFUN  __divdi3_moddi3
1977 #if SPEED_DIV
1978     mov     r31, A7
1979     or      r31, B7
1980     brmi    0f
1981     ;; Both Signs are 0:  the following Complexitiy is not needed
1982     XJMP    __udivdi3_umoddi3
1983 #endif /* SPEED_DIV */
1984
1985 0:  ;; The Prologue
1986     ;; Save 12 Registers:  Y, 17...8
1987     ;; No Frame needed
1988     do_prologue_saves 12
1989
1990     ;; SS.7 will contain the Sign of the Quotient  (A.sign * B.sign)
1991     ;; SS.6 will contain the Sign of the Remainder (A.sign)
1992     mov     SS, A7
1993     asr     SS
1994     ;; Adjust Dividend's Sign as needed
1995 #if SPEED_DIV
1996     ;; Compiling for Speed we know that at least one Sign must be < 0
1997     ;; Thus, if A[] >= 0 then we know B[] < 0
1998     brpl    22f
1999 #else
2000     brpl    21f
2001 #endif /* SPEED_DIV */
2002
2003     XCALL   __negdi2
2004
2005     ;; Adjust Divisor's Sign and SS.7 as needed
2006 21: tst     B7
2007     brpl    3f
2008 22: ldi     NN, 1 << 7
2009     eor     SS, NN
2010
2011     ldi NN, -1
2012     com B4     $  com B5     $  com B6     $  com B7
2013                $  com B1     $  com B2     $  com B3
2014     NEG B0
2015                $  sbc B1,NN  $  sbc B2,NN  $  sbc B3,NN
2016     sbc B4,NN  $  sbc B5,NN  $  sbc B6,NN  $  sbc B7,NN
2017
2018 3:  ;; Do the unsigned 64-Bit Division/Modulo (depending on T-flag)
2019     XCALL   __udivmod64
2020
2021     ;; Adjust Result's Sign
2022 #ifdef __AVR_ERRATA_SKIP_JMP_CALL__
2023     tst     SS
2024     brpl    4f
2025 #else
2026     sbrc    SS, 7
2027 #endif /* __AVR_HAVE_JMP_CALL__ */
2028     XCALL   __negdi2
2029
2030 4:  ;; Epilogue: Restore 12 Registers and return
2031     do_epilogue_restores 12
2032
2033 ENDF __divdi3_moddi3
2034
2035 #endif /* L_divdi3 */
2036
2037 #undef R_cnt
2038 #undef SS
2039 #undef NN
2040
2041 .section .text.libgcc, "ax", @progbits
2042
2043 #define TT __tmp_reg__
2044
2045 #if defined (L_adddi3)
2046 ;; (set (reg:DI 18)
2047 ;;      (plus:DI (reg:DI 18)
2048 ;;               (reg:DI 10)))
2049 ;; Sets the V flag for signed overflow tests
2050 ;; Sets the C flag for unsigned overflow tests
2051 DEFUN __adddi3
2052     ADD A0,B0  $  adc A1,B1  $  adc A2,B2  $  adc A3,B3
2053     adc A4,B4  $  adc A5,B5  $  adc A6,B6  $  adc A7,B7
2054     ret
2055 ENDF __adddi3
2056 #endif /* L_adddi3 */
2057
2058 #if defined (L_adddi3_s8)
2059 ;; (set (reg:DI 18)
2060 ;;      (plus:DI (reg:DI 18)
2061 ;;               (sign_extend:SI (reg:QI 26))))
2062 ;; Sets the V flag for signed overflow tests
2063 ;; Sets the C flag for unsigned overflow tests provided 0 <= R26 < 128
2064 DEFUN __adddi3_s8
2065     clr     TT
2066     sbrc    r26, 7
2067     com     TT
2068     ADD A0,r26 $  adc A1,TT  $  adc A2,TT  $  adc A3,TT
2069     adc A4,TT  $  adc A5,TT  $  adc A6,TT  $  adc A7,TT
2070     ret
2071 ENDF __adddi3_s8
2072 #endif /* L_adddi3_s8 */
2073
2074 #if defined (L_subdi3)
2075 ;; (set (reg:DI 18)
2076 ;;      (minus:DI (reg:DI 18)
2077 ;;                (reg:DI 10)))
2078 ;; Sets the V flag for signed overflow tests
2079 ;; Sets the C flag for unsigned overflow tests
2080 DEFUN __subdi3
2081     SUB A0,B0  $  sbc A1,B1  $  sbc A2,B2  $  sbc A3,B3
2082     sbc A4,B4  $  sbc A5,B5  $  sbc A6,B6  $  sbc A7,B7
2083     ret
2084 ENDF __subdi3
2085 #endif /* L_subdi3 */
2086
2087 #if defined (L_cmpdi2)
2088 ;; (set (cc0)
2089 ;;      (compare (reg:DI 18)
2090 ;;               (reg:DI 10)))
2091 DEFUN __cmpdi2
2092     CP  A0,B0  $  cpc A1,B1  $  cpc A2,B2  $  cpc A3,B3
2093     cpc A4,B4  $  cpc A5,B5  $  cpc A6,B6  $  cpc A7,B7
2094     ret
2095 ENDF __cmpdi2
2096 #endif /* L_cmpdi2 */
2097
2098 #if defined (L_cmpdi2_s8)
2099 ;; (set (cc0)
2100 ;;      (compare (reg:DI 18)
2101 ;;               (sign_extend:SI (reg:QI 26))))
2102 DEFUN __cmpdi2_s8
2103     clr     TT
2104     sbrc    r26, 7
2105     com     TT
2106     CP  A0,r26 $  cpc A1,TT  $  cpc A2,TT  $  cpc A3,TT
2107     cpc A4,TT  $  cpc A5,TT  $  cpc A6,TT  $  cpc A7,TT
2108     ret
2109 ENDF __cmpdi2_s8
2110 #endif /* L_cmpdi2_s8 */
2111
2112 #if defined (L_negdi2)
2113 ;; (set (reg:DI 18)
2114 ;;      (neg:DI (reg:DI 18)))
2115 ;; Sets the V flag for signed overflow tests
2116 DEFUN __negdi2
2117
2118     com  A4    $  com  A5    $  com  A6    $  com  A7
2119                $  com  A1    $  com  A2    $  com  A3
2120     NEG  A0
2121                $  sbci A1,-1 $  sbci A2,-1 $  sbci A3,-1
2122     sbci A4,-1 $  sbci A5,-1 $  sbci A6,-1 $  sbci A7,-1
2123     ret
2124
2125 ENDF __negdi2
2126 #endif /* L_negdi2 */
2127
2128 #undef TT
2129
2130 #undef C7
2131 #undef C6
2132 #undef C5
2133 #undef C4
2134 #undef C3
2135 #undef C2
2136 #undef C1
2137 #undef C0
2138
2139 #undef B7
2140 #undef B6
2141 #undef B5
2142 #undef B4
2143 #undef B3
2144 #undef B2
2145 #undef B1
2146 #undef B0
2147
2148 #undef A7
2149 #undef A6
2150 #undef A5
2151 #undef A4
2152 #undef A3
2153 #undef A2
2154 #undef A1
2155 #undef A0
2156
2157 #endif /* !defined (__AVR_TINY__) */
2158
2159 \f
2160 .section .text.libgcc.prologue, "ax", @progbits
2161
2162 /**********************************
2163  * This is a prologue subroutine
2164  **********************************/
2165 #if !defined (__AVR_TINY__)
2166 #if defined (L_prologue)
2167
2168 ;; This function does not clobber T-flag; 64-bit division relies on it
2169 DEFUN __prologue_saves__
2170         push r2
2171         push r3
2172         push r4
2173         push r5
2174         push r6
2175         push r7
2176         push r8
2177         push r9
2178         push r10
2179         push r11
2180         push r12
2181         push r13
2182         push r14
2183         push r15
2184         push r16
2185         push r17
2186         push r28
2187         push r29
2188 #if !defined (__AVR_HAVE_SPH__)
2189         in      r28,__SP_L__
2190         sub     r28,r26
2191         out     __SP_L__,r28
2192         clr     r29
2193 #elif defined (__AVR_XMEGA__)
2194         in      r28,__SP_L__
2195         in      r29,__SP_H__
2196         sub     r28,r26
2197         sbc     r29,r27
2198         out     __SP_L__,r28
2199         out     __SP_H__,r29
2200 #else
2201         in      r28,__SP_L__
2202         in      r29,__SP_H__
2203         sub     r28,r26
2204         sbc     r29,r27
2205         in      __tmp_reg__,__SREG__
2206         cli
2207         out     __SP_H__,r29
2208         out     __SREG__,__tmp_reg__
2209         out     __SP_L__,r28
2210 #endif /* #SP = 8/16 */
2211
2212         XIJMP
2213
2214 ENDF __prologue_saves__
2215 #endif /* defined (L_prologue) */
2216
2217 /*
2218  * This is an epilogue subroutine
2219  */
2220 #if defined (L_epilogue)
2221
2222 DEFUN __epilogue_restores__
2223         ldd     r2,Y+18
2224         ldd     r3,Y+17
2225         ldd     r4,Y+16
2226         ldd     r5,Y+15
2227         ldd     r6,Y+14
2228         ldd     r7,Y+13
2229         ldd     r8,Y+12
2230         ldd     r9,Y+11
2231         ldd     r10,Y+10
2232         ldd     r11,Y+9
2233         ldd     r12,Y+8
2234         ldd     r13,Y+7
2235         ldd     r14,Y+6
2236         ldd     r15,Y+5
2237         ldd     r16,Y+4
2238         ldd     r17,Y+3
2239         ldd     r26,Y+2
2240 #if !defined (__AVR_HAVE_SPH__)
2241         ldd     r29,Y+1
2242         add     r28,r30
2243         out     __SP_L__,r28
2244         mov     r28, r26
2245 #elif defined (__AVR_XMEGA__)
2246         ldd  r27,Y+1
2247         add  r28,r30
2248         adc  r29,__zero_reg__
2249         out  __SP_L__,r28
2250         out  __SP_H__,r29
2251         wmov 28, 26
2252 #else
2253         ldd     r27,Y+1
2254         add     r28,r30
2255         adc     r29,__zero_reg__
2256         in      __tmp_reg__,__SREG__
2257         cli
2258         out     __SP_H__,r29
2259         out     __SREG__,__tmp_reg__
2260         out     __SP_L__,r28
2261         mov_l   r28, r26
2262         mov_h   r29, r27
2263 #endif /* #SP = 8/16 */
2264         ret
2265 ENDF __epilogue_restores__
2266 #endif /* defined (L_epilogue) */
2267 #endif /* !defined (__AVR_TINY__) */
2268
2269 #ifdef L_exit
2270         .section .fini9,"ax",@progbits
2271 DEFUN _exit
2272         .weak   exit
2273 exit:
2274 ENDF _exit
2275
2276         /* Code from .fini8 ... .fini1 sections inserted by ld script.  */
2277
2278         .section .fini0,"ax",@progbits
2279         cli
2280 __stop_program:
2281         rjmp    __stop_program
2282 #endif /* defined (L_exit) */
2283
2284 #ifdef L_cleanup
2285         .weak   _cleanup
2286         .func   _cleanup
2287 _cleanup:
2288         ret
2289 .endfunc
2290 #endif /* defined (L_cleanup) */
2291
2292 \f
2293 .section .text.libgcc, "ax", @progbits
2294
2295 #ifdef L_tablejump2
2296 DEFUN __tablejump2__
2297     lsl     r30
2298     rol     r31
2299 #if defined (__AVR_HAVE_EIJMP_EICALL__)
2300     ;; Word address of gs() jumptable entry in R24:Z
2301     rol     r24
2302     out     __RAMPZ__, r24
2303 #elif defined (__AVR_HAVE_ELPM__)
2304     ;; Word address of jumptable entry in Z
2305     clr     __tmp_reg__
2306     rol     __tmp_reg__
2307     out     __RAMPZ__, __tmp_reg__
2308 #endif
2309
2310     ;; Read word address from jumptable and jump
2311
2312 #if defined (__AVR_HAVE_ELPMX__)
2313     elpm    __tmp_reg__, Z+
2314     elpm    r31, Z
2315     mov     r30, __tmp_reg__
2316 #ifdef __AVR_HAVE_RAMPD__
2317     ;; Reset RAMPZ to 0 so that EBI devices don't read garbage from RAM
2318     out     __RAMPZ__, __zero_reg__
2319 #endif /* RAMPD */
2320     XIJMP
2321 #elif defined (__AVR_HAVE_ELPM__)
2322     elpm
2323     push    r0
2324     adiw    r30, 1
2325     elpm
2326     push    r0
2327     ret
2328 #elif defined (__AVR_HAVE_LPMX__)
2329     lpm     __tmp_reg__, Z+
2330     lpm     r31, Z
2331     mov     r30, __tmp_reg__
2332     ijmp
2333 #elif defined (__AVR_TINY__)
2334     wsubi 30, -(__AVR_TINY_PM_BASE_ADDRESS__) ; Add PM offset to Z
2335     ld __tmp_reg__, Z+
2336     ld r31, Z   ; Use ld instead of lpm to load Z
2337     mov r30, __tmp_reg__
2338     ijmp
2339 #else
2340     lpm
2341     push    r0
2342     adiw    r30, 1
2343     lpm
2344     push    r0
2345     ret
2346 #endif
2347 ENDF __tablejump2__
2348 #endif /* L_tablejump2 */
2349
2350 #if defined(__AVR_TINY__)
2351 #ifdef L_copy_data
2352         .section .init4,"ax",@progbits
2353         .global __do_copy_data
2354 __do_copy_data:
2355         ldi     r18, hi8(__data_end)
2356         ldi     r26, lo8(__data_start)
2357         ldi     r27, hi8(__data_start)
2358         ldi     r30, lo8(__data_load_start + __AVR_TINY_PM_BASE_ADDRESS__)
2359         ldi     r31, hi8(__data_load_start + __AVR_TINY_PM_BASE_ADDRESS__)
2360         rjmp    .L__do_copy_data_start
2361 .L__do_copy_data_loop:
2362         ld      r19, z+
2363         st      X+, r19
2364 .L__do_copy_data_start:
2365         cpi     r26, lo8(__data_end)
2366         cpc     r27, r18
2367         brne    .L__do_copy_data_loop
2368 #endif
2369 #else
2370 #ifdef L_copy_data
2371         .section .init4,"ax",@progbits
2372 DEFUN __do_copy_data
2373 #if defined(__AVR_HAVE_ELPMX__)
2374         ldi     r17, hi8(__data_end)
2375         ldi     r26, lo8(__data_start)
2376         ldi     r27, hi8(__data_start)
2377         ldi     r30, lo8(__data_load_start)
2378         ldi     r31, hi8(__data_load_start)
2379         ldi     r16, hh8(__data_load_start)
2380         out     __RAMPZ__, r16
2381         rjmp    .L__do_copy_data_start
2382 .L__do_copy_data_loop:
2383         elpm    r0, Z+
2384         st      X+, r0
2385 .L__do_copy_data_start:
2386         cpi     r26, lo8(__data_end)
2387         cpc     r27, r17
2388         brne    .L__do_copy_data_loop
2389 #elif  !defined(__AVR_HAVE_ELPMX__) && defined(__AVR_HAVE_ELPM__)
2390         ldi     r17, hi8(__data_end)
2391         ldi     r26, lo8(__data_start)
2392         ldi     r27, hi8(__data_start)
2393         ldi     r30, lo8(__data_load_start)
2394         ldi     r31, hi8(__data_load_start)
2395         ldi     r16, hh8(__data_load_start - 0x10000)
2396 .L__do_copy_data_carry:
2397         inc     r16
2398         out     __RAMPZ__, r16
2399         rjmp    .L__do_copy_data_start
2400 .L__do_copy_data_loop:
2401         elpm
2402         st      X+, r0
2403         adiw    r30, 1
2404         brcs    .L__do_copy_data_carry
2405 .L__do_copy_data_start:
2406         cpi     r26, lo8(__data_end)
2407         cpc     r27, r17
2408         brne    .L__do_copy_data_loop
2409 #elif !defined(__AVR_HAVE_ELPMX__) && !defined(__AVR_HAVE_ELPM__)
2410         ldi     r17, hi8(__data_end)
2411         ldi     r26, lo8(__data_start)
2412         ldi     r27, hi8(__data_start)
2413         ldi     r30, lo8(__data_load_start)
2414         ldi     r31, hi8(__data_load_start)
2415         rjmp    .L__do_copy_data_start
2416 .L__do_copy_data_loop:
2417 #if defined (__AVR_HAVE_LPMX__)
2418         lpm     r0, Z+
2419 #else
2420         lpm
2421         adiw    r30, 1
2422 #endif
2423         st      X+, r0
2424 .L__do_copy_data_start:
2425         cpi     r26, lo8(__data_end)
2426         cpc     r27, r17
2427         brne    .L__do_copy_data_loop
2428 #endif /* !defined(__AVR_HAVE_ELPMX__) && !defined(__AVR_HAVE_ELPM__) */
2429 #if defined (__AVR_HAVE_ELPM__) && defined (__AVR_HAVE_RAMPD__)
2430         ;; Reset RAMPZ to 0 so that EBI devices don't read garbage from RAM
2431         out     __RAMPZ__, __zero_reg__
2432 #endif /* ELPM && RAMPD */
2433 ENDF __do_copy_data
2434 #endif /* L_copy_data */
2435 #endif /* !defined (__AVR_TINY__) */
2436
2437 /* __do_clear_bss is only necessary if there is anything in .bss section.  */
2438
2439 #ifdef L_clear_bss
2440         .section .init4,"ax",@progbits
2441 DEFUN __do_clear_bss
2442         ldi     r18, hi8(__bss_end)
2443         ldi     r26, lo8(__bss_start)
2444         ldi     r27, hi8(__bss_start)
2445         rjmp    .do_clear_bss_start
2446 .do_clear_bss_loop:
2447         st      X+, __zero_reg__
2448 .do_clear_bss_start:
2449         cpi     r26, lo8(__bss_end)
2450         cpc     r27, r18
2451         brne    .do_clear_bss_loop
2452 ENDF __do_clear_bss
2453 #endif /* L_clear_bss */
2454
2455 /* __do_global_ctors and __do_global_dtors are only necessary
2456    if there are any constructors/destructors.  */
2457
2458 #if defined(__AVR_TINY__)
2459 #define cdtors_tst_reg r18
2460 #else
2461 #define cdtors_tst_reg r17
2462 #endif
2463
2464 #ifdef L_ctors
2465         .section .init6,"ax",@progbits
2466 DEFUN __do_global_ctors
2467     ldi     cdtors_tst_reg, pm_hi8(__ctors_start)
2468     ldi     r28, pm_lo8(__ctors_end)
2469     ldi     r29, pm_hi8(__ctors_end)
2470 #ifdef __AVR_HAVE_EIJMP_EICALL__
2471     ldi     r16, pm_hh8(__ctors_end)
2472 #endif /* HAVE_EIJMP */
2473     rjmp    .L__do_global_ctors_start
2474 .L__do_global_ctors_loop:
2475     wsubi   28, 1
2476 #ifdef __AVR_HAVE_EIJMP_EICALL__
2477     sbc     r16, __zero_reg__
2478     mov     r24, r16
2479 #endif /* HAVE_EIJMP */
2480     mov_h   r31, r29
2481     mov_l   r30, r28
2482     XCALL   __tablejump2__
2483 .L__do_global_ctors_start:
2484     cpi     r28, pm_lo8(__ctors_start)
2485     cpc     r29, cdtors_tst_reg
2486 #ifdef __AVR_HAVE_EIJMP_EICALL__
2487     ldi     r24, pm_hh8(__ctors_start)
2488     cpc     r16, r24
2489 #endif /* HAVE_EIJMP */
2490     brne    .L__do_global_ctors_loop
2491 ENDF __do_global_ctors
2492 #endif /* L_ctors */
2493
2494 #ifdef L_dtors
2495         .section .fini6,"ax",@progbits
2496 DEFUN __do_global_dtors
2497     ldi     cdtors_tst_reg, pm_hi8(__dtors_end)
2498     ldi     r28, pm_lo8(__dtors_start)
2499     ldi     r29, pm_hi8(__dtors_start)
2500 #ifdef __AVR_HAVE_EIJMP_EICALL__
2501     ldi     r16, pm_hh8(__dtors_start)
2502 #endif /* HAVE_EIJMP */
2503     rjmp    .L__do_global_dtors_start
2504 .L__do_global_dtors_loop:
2505 #ifdef __AVR_HAVE_EIJMP_EICALL__
2506     mov     r24, r16
2507 #endif /* HAVE_EIJMP */
2508     mov_h   r31, r29
2509     mov_l   r30, r28
2510     XCALL   __tablejump2__
2511     waddi   28, 1
2512 #ifdef __AVR_HAVE_EIJMP_EICALL__
2513     adc     r16, __zero_reg__
2514 #endif /* HAVE_EIJMP */
2515 .L__do_global_dtors_start:
2516     cpi     r28, pm_lo8(__dtors_end)
2517     cpc     r29, cdtors_tst_reg
2518 #ifdef __AVR_HAVE_EIJMP_EICALL__
2519     ldi     r24, pm_hh8(__dtors_end)
2520     cpc     r16, r24
2521 #endif /* HAVE_EIJMP */
2522     brne    .L__do_global_dtors_loop
2523 ENDF __do_global_dtors
2524 #endif /* L_dtors */
2525
2526 #undef cdtors_tst_reg
2527
2528 .section .text.libgcc, "ax", @progbits
2529
2530 #if !defined (__AVR_TINY__)
2531 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2532 ;; Loading n bytes from Flash; n = 3,4
2533 ;; R22... = Flash[Z]
2534 ;; Clobbers: __tmp_reg__
2535
2536 #if (defined (L_load_3)        \
2537      || defined (L_load_4))    \
2538     && !defined (__AVR_HAVE_LPMX__)
2539
2540 ;; Destination
2541 #define D0  22
2542 #define D1  D0+1
2543 #define D2  D0+2
2544 #define D3  D0+3
2545
2546 .macro  .load dest, n
2547     lpm
2548     mov     \dest, r0
2549 .if \dest != D0+\n-1
2550     adiw    r30, 1
2551 .else
2552     sbiw    r30, \n-1
2553 .endif
2554 .endm
2555
2556 #if defined (L_load_3)
2557 DEFUN __load_3
2558     push  D3
2559     XCALL __load_4
2560     pop   D3
2561     ret
2562 ENDF __load_3
2563 #endif /* L_load_3 */
2564
2565 #if defined (L_load_4)
2566 DEFUN __load_4
2567     .load D0, 4
2568     .load D1, 4
2569     .load D2, 4
2570     .load D3, 4
2571     ret
2572 ENDF __load_4
2573 #endif /* L_load_4 */
2574
2575 #endif /* L_load_3 || L_load_3 */
2576 #endif /* !defined (__AVR_TINY__) */
2577
2578 #if !defined (__AVR_TINY__)
2579 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2580 ;; Loading n bytes from Flash or RAM;  n = 1,2,3,4
2581 ;; R22... = Flash[R21:Z] or RAM[Z] depending on R21.7
2582 ;; Clobbers: __tmp_reg__, R21, R30, R31
2583
2584 #if (defined (L_xload_1)            \
2585      || defined (L_xload_2)         \
2586      || defined (L_xload_3)         \
2587      || defined (L_xload_4))
2588
2589 ;; Destination
2590 #define D0  22
2591 #define D1  D0+1
2592 #define D2  D0+2
2593 #define D3  D0+3
2594
2595 ;; Register containing bits 16+ of the address
2596
2597 #define HHI8  21
2598
2599 .macro  .xload dest, n
2600 #if defined (__AVR_HAVE_ELPMX__)
2601     elpm    \dest, Z+
2602 #elif defined (__AVR_HAVE_ELPM__)
2603     elpm
2604     mov     \dest, r0
2605 .if \dest != D0+\n-1
2606     adiw    r30, 1
2607     adc     HHI8, __zero_reg__
2608     out     __RAMPZ__, HHI8
2609 .endif
2610 #elif defined (__AVR_HAVE_LPMX__)
2611     lpm     \dest, Z+
2612 #else
2613     lpm
2614     mov     \dest, r0
2615 .if \dest != D0+\n-1
2616     adiw    r30, 1
2617 .endif
2618 #endif
2619 #if defined (__AVR_HAVE_ELPM__) && defined (__AVR_HAVE_RAMPD__)
2620 .if \dest == D0+\n-1
2621     ;; Reset RAMPZ to 0 so that EBI devices don't read garbage from RAM
2622     out     __RAMPZ__, __zero_reg__
2623 .endif
2624 #endif
2625 .endm ; .xload
2626
2627 #if defined (L_xload_1)
2628 DEFUN __xload_1
2629 #if defined (__AVR_HAVE_LPMX__) && !defined (__AVR_HAVE_ELPM__)
2630     sbrc    HHI8, 7
2631     ld      D0, Z
2632     sbrs    HHI8, 7
2633     lpm     D0, Z
2634     ret
2635 #else
2636     sbrc    HHI8, 7
2637     rjmp    1f
2638 #if defined (__AVR_HAVE_ELPM__)
2639     out     __RAMPZ__, HHI8
2640 #endif /* __AVR_HAVE_ELPM__ */
2641     .xload  D0, 1
2642     ret
2643 1:  ld      D0, Z
2644     ret
2645 #endif /* LPMx && ! ELPM */
2646 ENDF __xload_1
2647 #endif /* L_xload_1 */
2648
2649 #if defined (L_xload_2)
2650 DEFUN __xload_2
2651     sbrc    HHI8, 7
2652     rjmp    1f
2653 #if defined (__AVR_HAVE_ELPM__)
2654     out     __RAMPZ__, HHI8
2655 #endif /* __AVR_HAVE_ELPM__ */
2656     .xload  D0, 2
2657     .xload  D1, 2
2658     ret
2659 1:  ld      D0, Z+
2660     ld      D1, Z+
2661     ret
2662 ENDF __xload_2
2663 #endif /* L_xload_2 */
2664
2665 #if defined (L_xload_3)
2666 DEFUN __xload_3
2667     sbrc    HHI8, 7
2668     rjmp    1f
2669 #if defined (__AVR_HAVE_ELPM__)
2670     out     __RAMPZ__, HHI8
2671 #endif /* __AVR_HAVE_ELPM__ */
2672     .xload  D0, 3
2673     .xload  D1, 3
2674     .xload  D2, 3
2675     ret
2676 1:  ld      D0, Z+
2677     ld      D1, Z+
2678     ld      D2, Z+
2679     ret
2680 ENDF __xload_3
2681 #endif /* L_xload_3 */
2682
2683 #if defined (L_xload_4)
2684 DEFUN __xload_4
2685     sbrc    HHI8, 7
2686     rjmp    1f
2687 #if defined (__AVR_HAVE_ELPM__)
2688     out     __RAMPZ__, HHI8
2689 #endif /* __AVR_HAVE_ELPM__ */
2690     .xload  D0, 4
2691     .xload  D1, 4
2692     .xload  D2, 4
2693     .xload  D3, 4
2694     ret
2695 1:  ld      D0, Z+
2696     ld      D1, Z+
2697     ld      D2, Z+
2698     ld      D3, Z+
2699     ret
2700 ENDF __xload_4
2701 #endif /* L_xload_4 */
2702
2703 #endif /* L_xload_{1|2|3|4} */
2704 #endif /* if !defined (__AVR_TINY__) */
2705
2706 #if !defined (__AVR_TINY__)
2707 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
2708 ;; memcopy from Address Space __pgmx to RAM
2709 ;; R23:Z = Source Address
2710 ;; X     = Destination Address
2711 ;; Clobbers: __tmp_reg__, R23, R24, R25, X, Z
2712
2713 #if defined (L_movmemx)
2714
2715 #define HHI8  23
2716 #define LOOP  24
2717
2718 DEFUN __movmemx_qi
2719     ;; #Bytes to copy fity in 8 Bits (1..255)
2720     ;; Zero-extend Loop Counter
2721     clr     LOOP+1
2722     ;; FALLTHRU
2723 ENDF __movmemx_qi
2724
2725 DEFUN __movmemx_hi
2726
2727 ;; Read from where?
2728     sbrc    HHI8, 7
2729     rjmp    1f
2730
2731 ;; Read from Flash
2732
2733 #if defined (__AVR_HAVE_ELPM__)
2734     out     __RAMPZ__, HHI8
2735 #endif
2736
2737 0:  ;; Load 1 Byte from Flash...
2738
2739 #if defined (__AVR_HAVE_ELPMX__)
2740     elpm    r0, Z+
2741 #elif defined (__AVR_HAVE_ELPM__)
2742     elpm
2743     adiw    r30, 1
2744     adc     HHI8, __zero_reg__
2745     out     __RAMPZ__, HHI8
2746 #elif defined (__AVR_HAVE_LPMX__)
2747     lpm     r0, Z+
2748 #else
2749     lpm
2750     adiw    r30, 1
2751 #endif
2752
2753     ;; ...and store that Byte to RAM Destination
2754     st      X+, r0
2755     sbiw    LOOP, 1
2756     brne    0b
2757 #if defined (__AVR_HAVE_ELPM__) && defined (__AVR_HAVE_RAMPD__)
2758     ;; Reset RAMPZ to 0 so that EBI devices don't read garbage from RAM
2759     out __RAMPZ__, __zero_reg__
2760 #endif /* ELPM && RAMPD */
2761     ret
2762
2763 ;; Read from RAM
2764
2765 1:  ;; Read 1 Byte from RAM...
2766     ld      r0, Z+
2767     ;; and store that Byte to RAM Destination
2768     st      X+, r0
2769     sbiw    LOOP, 1
2770     brne    1b
2771     ret
2772 ENDF __movmemx_hi
2773
2774 #undef HHI8
2775 #undef LOOP
2776
2777 #endif /* L_movmemx */
2778 #endif /* !defined (__AVR_TINY__) */
2779
2780 \f
2781 .section .text.libgcc.builtins, "ax", @progbits
2782
2783 /**********************************
2784  * Find first set Bit (ffs)
2785  **********************************/
2786
2787 #if defined (L_ffssi2)
2788 ;; find first set bit
2789 ;; r25:r24 = ffs32 (r25:r22)
2790 ;; clobbers: r22, r26
2791 DEFUN __ffssi2
2792     clr  r26
2793     tst  r22
2794     brne 1f
2795     subi r26, -8
2796     or   r22, r23
2797     brne 1f
2798     subi r26, -8
2799     or   r22, r24
2800     brne 1f
2801     subi r26, -8
2802     or   r22, r25
2803     brne 1f
2804     ret
2805 1:  mov  r24, r22
2806     XJMP __loop_ffsqi2
2807 ENDF __ffssi2
2808 #endif /* defined (L_ffssi2) */
2809
2810 #if defined (L_ffshi2)
2811 ;; find first set bit
2812 ;; r25:r24 = ffs16 (r25:r24)
2813 ;; clobbers: r26
2814 DEFUN __ffshi2
2815     clr  r26
2816 #ifdef __AVR_ERRATA_SKIP_JMP_CALL__
2817     ;; Some cores have problem skipping 2-word instruction
2818     tst  r24
2819     breq 2f
2820 #else
2821     cpse r24, __zero_reg__
2822 #endif /* __AVR_HAVE_JMP_CALL__ */
2823 1:  XJMP __loop_ffsqi2
2824 2:  ldi  r26, 8
2825     or   r24, r25
2826     brne 1b
2827     ret
2828 ENDF __ffshi2
2829 #endif /* defined (L_ffshi2) */
2830
2831 #if defined (L_loop_ffsqi2)
2832 ;; Helper for ffshi2, ffssi2
2833 ;; r25:r24 = r26 + zero_extend16 (ffs8(r24))
2834 ;; r24 must be != 0
2835 ;; clobbers: r26
2836 DEFUN __loop_ffsqi2
2837     inc  r26
2838     lsr  r24
2839     brcc __loop_ffsqi2
2840     mov  r24, r26
2841     clr  r25
2842     ret
2843 ENDF __loop_ffsqi2
2844 #endif /* defined (L_loop_ffsqi2) */
2845
2846 \f
2847 /**********************************
2848  * Count trailing Zeros (ctz)
2849  **********************************/
2850
2851 #if defined (L_ctzsi2)
2852 ;; count trailing zeros
2853 ;; r25:r24 = ctz32 (r25:r22)
2854 ;; clobbers: r26, r22
2855 ;; ctz(0) = 255
2856 ;; Note that ctz(0) in undefined for GCC
2857 DEFUN __ctzsi2
2858     XCALL __ffssi2
2859     dec  r24
2860     ret
2861 ENDF __ctzsi2
2862 #endif /* defined (L_ctzsi2) */
2863
2864 #if defined (L_ctzhi2)
2865 ;; count trailing zeros
2866 ;; r25:r24 = ctz16 (r25:r24)
2867 ;; clobbers: r26
2868 ;; ctz(0) = 255
2869 ;; Note that ctz(0) in undefined for GCC
2870 DEFUN __ctzhi2
2871     XCALL __ffshi2
2872     dec  r24
2873     ret
2874 ENDF __ctzhi2
2875 #endif /* defined (L_ctzhi2) */
2876
2877 \f
2878 /**********************************
2879  * Count leading Zeros (clz)
2880  **********************************/
2881
2882 #if defined (L_clzdi2)
2883 ;; count leading zeros
2884 ;; r25:r24 = clz64 (r25:r18)
2885 ;; clobbers: r22, r23, r26
2886 DEFUN __clzdi2
2887     XCALL __clzsi2
2888     sbrs r24, 5
2889     ret
2890     mov_l r22, r18
2891     mov_h r23, r19
2892     mov_l r24, r20
2893     mov_h r25, r21
2894     XCALL __clzsi2
2895     subi r24, -32
2896     ret
2897 ENDF __clzdi2
2898 #endif /* defined (L_clzdi2) */
2899
2900 #if defined (L_clzsi2)
2901 ;; count leading zeros
2902 ;; r25:r24 = clz32 (r25:r22)
2903 ;; clobbers: r26
2904 DEFUN __clzsi2
2905     XCALL __clzhi2
2906     sbrs r24, 4
2907     ret
2908     mov_l r24, r22
2909     mov_h r25, r23
2910     XCALL __clzhi2
2911     subi r24, -16
2912     ret
2913 ENDF __clzsi2
2914 #endif /* defined (L_clzsi2) */
2915
2916 #if defined (L_clzhi2)
2917 ;; count leading zeros
2918 ;; r25:r24 = clz16 (r25:r24)
2919 ;; clobbers: r26
2920 DEFUN __clzhi2
2921     clr  r26
2922     tst  r25
2923     brne 1f
2924     or   r25, r24
2925     breq 0f
2926     subi r26, -8
2927 1:  cpi  r25, 16
2928     brsh 3f
2929     subi r26, -3
2930     swap r25
2931 2:  inc  r26
2932 3:  lsl  r25
2933     brcc 2b
2934     mov  r24, r26
2935     clr  r25
2936     ret
2937 0:  ldi  r24, 16
2938     ret
2939 ENDF __clzhi2
2940 #endif /* defined (L_clzhi2) */
2941
2942 \f
2943 /**********************************
2944  * Parity
2945  **********************************/
2946
2947 #if defined (L_paritydi2)
2948 ;; r25:r24 = parity64 (r25:r18)
2949 ;; clobbers: __tmp_reg__
2950 DEFUN __paritydi2
2951     eor  r24, r18
2952     eor  r24, r19
2953     eor  r24, r20
2954     eor  r24, r21
2955     XJMP __paritysi2
2956 ENDF __paritydi2
2957 #endif /* defined (L_paritydi2) */
2958
2959 #if defined (L_paritysi2)
2960 ;; r25:r24 = parity32 (r25:r22)
2961 ;; clobbers: __tmp_reg__
2962 DEFUN __paritysi2
2963     eor  r24, r22
2964     eor  r24, r23
2965     XJMP __parityhi2
2966 ENDF __paritysi2
2967 #endif /* defined (L_paritysi2) */
2968
2969 #if defined (L_parityhi2)
2970 ;; r25:r24 = parity16 (r25:r24)
2971 ;; clobbers: __tmp_reg__
2972 DEFUN __parityhi2
2973     eor  r24, r25
2974 ;; FALLTHRU
2975 ENDF __parityhi2
2976
2977 ;; r25:r24 = parity8 (r24)
2978 ;; clobbers: __tmp_reg__
2979 DEFUN __parityqi2
2980     ;; parity is in r24[0..7]
2981     mov  __tmp_reg__, r24
2982     swap __tmp_reg__
2983     eor  r24, __tmp_reg__
2984     ;; parity is in r24[0..3]
2985     subi r24, -4
2986     andi r24, -5
2987     subi r24, -6
2988     ;; parity is in r24[0,3]
2989     sbrc r24, 3
2990     inc  r24
2991     ;; parity is in r24[0]
2992     andi r24, 1
2993     clr  r25
2994     ret
2995 ENDF __parityqi2
2996 #endif /* defined (L_parityhi2) */
2997
2998 \f
2999 /**********************************
3000  * Population Count
3001  **********************************/
3002
3003 #if defined (L_popcounthi2)
3004 ;; population count
3005 ;; r25:r24 = popcount16 (r25:r24)
3006 ;; clobbers: __tmp_reg__
3007 DEFUN __popcounthi2
3008     XCALL __popcountqi2
3009     push r24
3010     mov  r24, r25
3011     XCALL __popcountqi2
3012     clr  r25
3013     ;; FALLTHRU
3014 ENDF __popcounthi2
3015
3016 DEFUN __popcounthi2_tail
3017     pop   __tmp_reg__
3018     add   r24, __tmp_reg__
3019     ret
3020 ENDF __popcounthi2_tail
3021 #endif /* defined (L_popcounthi2) */
3022
3023 #if defined (L_popcountsi2)
3024 ;; population count
3025 ;; r25:r24 = popcount32 (r25:r22)
3026 ;; clobbers: __tmp_reg__
3027 DEFUN __popcountsi2
3028     XCALL __popcounthi2
3029     push  r24
3030     mov_l r24, r22
3031     mov_h r25, r23
3032     XCALL __popcounthi2
3033     XJMP  __popcounthi2_tail
3034 ENDF __popcountsi2
3035 #endif /* defined (L_popcountsi2) */
3036
3037 #if defined (L_popcountdi2)
3038 ;; population count
3039 ;; r25:r24 = popcount64 (r25:r18)
3040 ;; clobbers: r22, r23, __tmp_reg__
3041 DEFUN __popcountdi2
3042     XCALL __popcountsi2
3043     push  r24
3044     mov_l r22, r18
3045     mov_h r23, r19
3046     mov_l r24, r20
3047     mov_h r25, r21
3048     XCALL __popcountsi2
3049     XJMP  __popcounthi2_tail
3050 ENDF __popcountdi2
3051 #endif /* defined (L_popcountdi2) */
3052
3053 #if defined (L_popcountqi2)
3054 ;; population count
3055 ;; r24 = popcount8 (r24)
3056 ;; clobbers: __tmp_reg__
3057 DEFUN __popcountqi2
3058     mov  __tmp_reg__, r24    ; oeoeoeoe
3059     andi r24, 0xAA           ; o0o0o0o0
3060     lsr  r24                 ; 0o0o0o0o
3061     ;; Four values 0, 1 or 2: # bits set o+e
3062     sub  __tmp_reg__, r24    ; 44332211
3063     mov  r24, __tmp_reg__    ; 44332211
3064     andi r24, 0x33           ; 00330011
3065     eor  __tmp_reg__, r24    ; 44002200
3066     lsr  __tmp_reg__         ; 04400220
3067     lsr  __tmp_reg__         ; 00440022
3068     add  r24, __tmp_reg__    ; 04210421
3069     mov  __tmp_reg__, r24    ; h421l421
3070     swap __tmp_reg__         ; l421h421
3071     add  r24, __tmp_reg__    ; 84218421
3072     andi r24, 0xf            ; 00008421 /17
3073     ret
3074 ENDF __popcountqi2
3075 #endif /* defined (L_popcountqi2) */
3076
3077 \f
3078 /**********************************
3079  * Swap bytes
3080  **********************************/
3081
3082 ;; swap two registers with different register number
3083 .macro bswap a, b
3084     eor \a, \b
3085     eor \b, \a
3086     eor \a, \b
3087 .endm
3088
3089 #if defined (L_bswapsi2)
3090 ;; swap bytes
3091 ;; r25:r22 = bswap32 (r25:r22)
3092 DEFUN __bswapsi2
3093     bswap r22, r25
3094     bswap r23, r24
3095     ret
3096 ENDF __bswapsi2
3097 #endif /* defined (L_bswapsi2) */
3098
3099 #if defined (L_bswapdi2)
3100 ;; swap bytes
3101 ;; r25:r18 = bswap64 (r25:r18)
3102 DEFUN __bswapdi2
3103     bswap r18, r25
3104     bswap r19, r24
3105     bswap r20, r23
3106     bswap r21, r22
3107     ret
3108 ENDF __bswapdi2
3109 #endif /* defined (L_bswapdi2) */
3110
3111 \f
3112 /**********************************
3113  * 64-bit shifts
3114  **********************************/
3115
3116 #if defined (L_ashrdi3)
3117
3118 #define SS __zero_reg__
3119
3120 ;; Arithmetic shift right
3121 ;; r25:r18 = ashr64 (r25:r18, r17:r16)
3122 DEFUN __ashrdi3
3123     sbrc    r25, 7
3124     com     SS
3125     ;; FALLTHRU
3126 ENDF  __ashrdi3
3127
3128 ;; Logic shift right
3129 ;; r25:r18 = lshr64 (r25:r18, r17:r16)
3130 DEFUN __lshrdi3
3131     ;; Signs are in SS (zero_reg)
3132     mov     __tmp_reg__, r16
3133 0:  cpi     r16, 8
3134     brlo 2f
3135     subi    r16, 8
3136     mov     r18, r19
3137     mov     r19, r20
3138     mov     r20, r21
3139     mov     r21, r22
3140     mov     r22, r23
3141     mov     r23, r24
3142     mov     r24, r25
3143     mov     r25, SS
3144     rjmp 0b
3145 1:  asr     SS
3146     ror     r25
3147     ror     r24
3148     ror     r23
3149     ror     r22
3150     ror     r21
3151     ror     r20
3152     ror     r19
3153     ror     r18
3154 2:  dec     r16
3155     brpl 1b
3156     clr     __zero_reg__
3157     mov     r16, __tmp_reg__
3158     ret
3159 ENDF __lshrdi3
3160
3161 #undef SS
3162
3163 #endif /* defined (L_ashrdi3) */
3164
3165 #if defined (L_ashldi3)
3166 ;; Shift left
3167 ;; r25:r18 = ashl64 (r25:r18, r17:r16)
3168 ;; This function does not clobber T.
3169 DEFUN __ashldi3
3170     mov     __tmp_reg__, r16
3171 0:  cpi     r16, 8
3172     brlo 2f
3173     mov     r25, r24
3174     mov     r24, r23
3175     mov     r23, r22
3176     mov     r22, r21
3177     mov     r21, r20
3178     mov     r20, r19
3179     mov     r19, r18
3180     clr     r18
3181     subi    r16, 8
3182     rjmp 0b
3183 1:  lsl     r18
3184     rol     r19
3185     rol     r20
3186     rol     r21
3187     rol     r22
3188     rol     r23
3189     rol     r24
3190     rol     r25
3191 2:  dec     r16
3192     brpl 1b
3193     mov     r16, __tmp_reg__
3194     ret
3195 ENDF __ashldi3
3196 #endif /* defined (L_ashldi3) */
3197
3198 #if defined (L_rotldi3)
3199 ;; Rotate left
3200 ;; r25:r18 = rotl64 (r25:r18, r17:r16)
3201 DEFUN __rotldi3
3202     push    r16
3203 0:  cpi     r16, 8
3204     brlo 2f
3205     subi    r16, 8
3206     mov     __tmp_reg__, r25
3207     mov     r25, r24
3208     mov     r24, r23
3209     mov     r23, r22
3210     mov     r22, r21
3211     mov     r21, r20
3212     mov     r20, r19
3213     mov     r19, r18
3214     mov     r18, __tmp_reg__
3215     rjmp 0b
3216 1:  lsl     r18
3217     rol     r19
3218     rol     r20
3219     rol     r21
3220     rol     r22
3221     rol     r23
3222     rol     r24
3223     rol     r25
3224     adc     r18, __zero_reg__
3225 2:  dec     r16
3226     brpl 1b
3227     pop     r16
3228     ret
3229 ENDF __rotldi3
3230 #endif /* defined (L_rotldi3) */
3231
3232 \f
3233 .section .text.libgcc.fmul, "ax", @progbits
3234
3235 /***********************************************************/
3236 ;;; Softmul versions of FMUL, FMULS and FMULSU to implement
3237 ;;; __builtin_avr_fmul* if !AVR_HAVE_MUL
3238 /***********************************************************/
3239
3240 #define A1 24
3241 #define B1 25
3242 #define C0 22
3243 #define C1 23
3244 #define A0 __tmp_reg__
3245
3246 #ifdef L_fmuls
3247 ;;; r23:r22 = fmuls (r24, r25) like in FMULS instruction
3248 ;;; Clobbers: r24, r25, __tmp_reg__
3249 DEFUN __fmuls
3250     ;; A0.7 = negate result?
3251     mov  A0, A1
3252     eor  A0, B1
3253     ;; B1 = |B1|
3254     sbrc B1, 7
3255     neg  B1
3256     XJMP __fmulsu_exit
3257 ENDF __fmuls
3258 #endif /* L_fmuls */
3259
3260 #ifdef L_fmulsu
3261 ;;; r23:r22 = fmulsu (r24, r25) like in FMULSU instruction
3262 ;;; Clobbers: r24, r25, __tmp_reg__
3263 DEFUN __fmulsu
3264     ;; A0.7 = negate result?
3265     mov  A0, A1
3266 ;; FALLTHRU
3267 ENDF __fmulsu
3268
3269 ;; Helper for __fmuls and __fmulsu
3270 DEFUN __fmulsu_exit
3271     ;; A1 = |A1|
3272     sbrc A1, 7
3273     neg  A1
3274 #ifdef __AVR_ERRATA_SKIP_JMP_CALL__
3275     ;; Some cores have problem skipping 2-word instruction
3276     tst  A0
3277     brmi 1f
3278 #else
3279     sbrs A0, 7
3280 #endif /* __AVR_HAVE_JMP_CALL__ */
3281     XJMP  __fmul
3282 1:  XCALL __fmul
3283     ;; C = -C iff A0.7 = 1
3284     NEG2 C0
3285     ret
3286 ENDF __fmulsu_exit
3287 #endif /* L_fmulsu */
3288
3289
3290 #ifdef L_fmul
3291 ;;; r22:r23 = fmul (r24, r25) like in FMUL instruction
3292 ;;; Clobbers: r24, r25, __tmp_reg__
3293 DEFUN __fmul
3294     ; clear result
3295     clr   C0
3296     clr   C1
3297     clr   A0
3298 1:  tst   B1
3299     ;; 1.0 = 0x80, so test for bit 7 of B to see if A must to be added to C.
3300 2:  brpl  3f
3301     ;; C += A
3302     add   C0, A0
3303     adc   C1, A1
3304 3:  ;; A >>= 1
3305     lsr   A1
3306     ror   A0
3307     ;; B <<= 1
3308     lsl   B1
3309     brne  2b
3310     ret
3311 ENDF __fmul
3312 #endif /* L_fmul */
3313
3314 #undef A0
3315 #undef A1
3316 #undef B1
3317 #undef C0
3318 #undef C1
3319
3320
3321 \f
3322 /**********************************
3323  * Floating-Point
3324  **********************************/
3325
3326 #if defined (L_powif)
3327 #ifndef __AVR_TINY__
3328
3329 ;; float output and arg #1
3330 #define A0      22
3331 #define A1      A0 + 1
3332 #define A2      A0 + 2
3333 #define A3      A0 + 3
3334
3335 ;; float arg #2
3336 #define B0      18
3337 #define B1      B0 + 1
3338 #define B2      B0 + 2
3339 #define B3      B0 + 3
3340
3341 ;; float X: input and iterated squares
3342 #define X0      10
3343 #define X1      X0 + 1
3344 #define X2      X0 + 2
3345 #define X3      X0 + 3
3346
3347 ;; float Y: expand result
3348 #define Y0      14
3349 #define Y1      Y0 + 1
3350 #define Y2      Y0 + 2
3351 #define Y3      Y0 + 3
3352
3353 ;; .7 = Sign of I.
3354 ;; .0 == 0  =>  Y = 1.0f implicitly.
3355 #define Flags       R9
3356 #define Y_set       0
3357
3358 ;;;  Integer exponent input.
3359 #define I0      28
3360 #define I1      I0+1
3361
3362 #define ONE     0x3f800000
3363
3364 DEFUN __powisf2
3365     ;; Save 11 Registers: R9...R17, R28, R29
3366     do_prologue_saves 11
3367
3368     ;; Fill local vars with input parameters.
3369     wmov    I0, 20
3370     mov4    X0, A0
3371     ;; Save sign of exponent for later.
3372     mov     Flags,  I1
3373     ;; I := abs (I)
3374     tst     I1
3375     brpl 1f
3376     NEG2    I0
3377 1:
3378     ;; Y := (I % 2) ? X : 1.0f
3379     ;; (When we come from below, this is like SET, i.e. Flags.Y_set := 1).
3380     bst     I0, 0
3381     ;; Flags.Y_set = false means that we have to assume Y = 1.0f below.
3382     bld     Flags,  Y_set
3383 2:  ;; We have A == X when we come from above.
3384     mov4    Y0, A0
3385
3386 .Loop:
3387     ;; while (I >>= 1)
3388     lsr     I1
3389     ror     I0
3390     sbiw    I0, 0
3391     breq .Loop_done
3392
3393     ;; X := X * X
3394     mov4    A0, X0
3395 #ifdef __WITH_AVRLIBC__
3396     XCALL   squaref
3397 #else
3398     mov4    B0, X0
3399     XCALL   __mulsf3
3400 #endif /* Have AVR-LibC? */
3401     mov4    X0, A0
3402
3403     ;; if (I % 2 == 1)  Y := Y * X
3404     bst     I0, 0
3405     brtc .Loop
3406     bst     Flags, Y_set
3407     ;; When Y is not set  =>  Y := Y * X = 1.0f * X (= A)
3408     ;; Plus, we have to set Y_set = 1 (= I0.0)
3409     brtc 1b
3410     ;; Y is already set: Y := X * Y (= A * Y)
3411     mov4    B0, Y0
3412     XCALL   __mulsf3
3413     rjmp 2b
3414
3415     ;; End while
3416 .Loop_done:
3417
3418     ;; A := 1.0f
3419     ldi     A3, hhi8(ONE)
3420     ldi     A2, hlo8(ONE)
3421     ldi     A1, hi8(ONE)
3422     ldi     A0, lo8(ONE)
3423
3424     ;; When Y is still not set, the result is 1.0f (= A).
3425     bst     Flags, Y_set
3426     brtc .Lret
3427
3428     ;; if (I was < 0) Y = 1.0f / Y
3429     tst     Flags
3430     brmi 1f
3431     ;; A := Y
3432     mov4    A0, Y0
3433     rjmp .Lret
3434 1:  ;; A := 1 / Y = A / Y
3435     mov4    B0, Y0
3436     XCALL   __divsf3
3437
3438 .Lret:
3439     do_epilogue_restores 11
3440 ENDF __powisf2
3441
3442 #undef A0
3443 #undef A1
3444 #undef A2
3445 #undef A3
3446
3447 #undef B0
3448 #undef B1
3449 #undef B2
3450 #undef B3
3451
3452 #undef X0
3453 #undef X1
3454 #undef X2
3455 #undef X3
3456
3457 #undef Y0
3458 #undef Y1
3459 #undef Y2
3460 #undef Y3
3461
3462 #undef I0
3463 #undef I1
3464 #undef ONE
3465
3466 #endif /* __AVR_TINY__ */
3467 #endif /* L_powif */
3468
3469 #include "lib1funcs-fixed.S"