![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lib1funcs.asm CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc / config / arm|
Return to lib1funcs.asm CVS log | Up to [GCC 2.x] / gcc / config / arm |
1.1 ! root 1: @ libgcc1 routines for ARM cpu. ! 2: @ Division and remainder, from Appendix E of the Sparc Version 8 ! 3: @ Architecture Manual, with fixes from Gordon Irlam. ! 4: @ Rewritten for the ARM by Richard Earnshaw ([email protected]) ! 5: ! 6: /* Copyright (C) 1995 Free Software Foundation, Inc. ! 7: ! 8: This file is free software; you can redistribute it and/or modify it ! 9: under the terms of the GNU General Public License as published by the ! 10: Free Software Foundation; either version 2, or (at your option) any ! 11: later version. ! 12: ! 13: In addition to the permissions in the GNU General Public License, the ! 14: Free Software Foundation gives you unlimited permission to link the ! 15: compiled version of this file with other programs, and to distribute ! 16: those programs without any restriction coming from the use of this ! 17: file. (The General Public License restrictions do apply in other ! 18: respects; for example, they cover modification of the file, and ! 19: distribution when not linked into another program.) ! 20: ! 21: This file is distributed in the hope that it will be useful, but ! 22: WITHOUT ANY WARRANTY; without even the implied warranty of ! 23: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ! 24: General Public License for more details. ! 25: ! 26: You should have received a copy of the GNU General Public License ! 27: along with this program; see the file COPYING. If not, write to ! 28: the Free Software Foundation, 59 Temple Place - Suite 330, ! 29: Boston, MA 02111-1307, USA. */ ! 30: ! 31: /* As a special exception, if you link this library with other files, ! 32: some of which are compiled with GCC, to produce an executable, ! 33: this library does not by itself cause the resulting executable ! 34: to be covered by the GNU General Public License. ! 35: This exception does not however invalidate any other reasons why ! 36: the executable file might be covered by the GNU General Public License. */ ! 37: ! 38: /* ! 39: * Input: dividend and divisor in r0 and r1 respectively. ! 40: * ! 41: * m4 parameters: ! 42: * NAME name of function to generate ! 43: * OP OP=div => r0 / r1; OP=mod => r0 % r1 ! 44: * S S=true => signed; S=false => unsigned ! 45: * ! 46: * Algorithm parameters: ! 47: * N how many bits per iteration we try to get (4) ! 48: * WORDSIZE total number of bits (32) ! 49: * ! 50: * Derived constants: ! 51: * TOPBITS number of bits in the top `decade' of a number ! 52: * ! 53: * Important variables: ! 54: * Q the partial quotient under development (initially 0) ! 55: * R the remainder so far, initially the dividend ! 56: * ITER number of main division loop iterations required; ! 57: * equal to ceil(log2(quotient) / N). Note that this ! 58: * is the log base (2^N) of the quotient. ! 59: * V the current comparand, initially divisor*2^(ITER*N-1) ! 60: * ! 61: * Cost: ! 62: * Current estimate for non-large dividend is ! 63: * ceil(log2(quotient) / N) * (10 + 7N/2) + C ! 64: * A large dividend is one greater than 2^(31-TOPBITS) and takes a ! 65: * different path, as the upper bits of the quotient must be developed ! 66: * one bit at a time. ! 67: */ ! 68: ! 69: /* ! 70: define(N, `4')dnl ! 71: define(WORDSIZE, `32')dnl ! 72: define(TOPBITS, eval(WORDSIZE - N*((WORDSIZE-1)/N)))dnl ! 73: dnl ! 74: define(dividend, `r0')dnl ! 75: define(divisor, `r1')dnl ! 76: define(Q, `r2')dnl ! 77: define(R, `r3')dnl ! 78: define(ITER, `ip')dnl ! 79: define(V, `lr')dnl ! 80: dnl ! 81: dnl m4 reminder: ifelse(a,b,c,d) => if a is b, then c, else d ! 82: define(T, `r4')dnl ! 83: define(SC, `r5')dnl ! 84: ifelse(S, `true', `define(SIGN, `r6')')dnl ! 85: define(REGLIST, `ifelse(S, `true', `{r4, r5, r6,', `{r4, r5,')')dnl ! 86: define(ret, `ldmia sp!, REGLIST pc}')dnl ! 87: dnl ! 88: dnl This is the recursive definition for developing quotient digits. ! 89: dnl ! 90: dnl Parameters: ! 91: dnl $1 the current depth, 1 <= $1 <= N ! 92: dnl $2 the current accumulation of quotient bits ! 93: dnl N max depth ! 94: dnl ! 95: dnl We add a new bit to $2 and either recurse or insert the bits in ! 96: dnl the quotient. R, Q, and V are inputs and outputs as defined above; ! 97: dnl the condition codes are expected to reflect the input R, and are ! 98: dnl modified to reflect the output R. ! 99: dnl ! 100: define(DEVELOP_QUOTIENT_BITS, ! 101: ` @ depth $1, accumulated bits $2 ! 102: mov V, V, lsr #1 ! 103: blt L.$1.eval(2^N+$2+999) ! 104: @ remainder is positive ! 105: subs R, R, V ! 106: ifelse($1, N, ! 107: ` ifelse(eval(2*$2+1<0), `0', ! 108: `add Q, Q, `#'eval($2*2+1)', ! 109: `sub Q, Q, `#'eval(-($2*2+1))') ! 110: ! 111: b 9f ! 112: ', ` DEVELOP_QUOTIENT_BITS(incr($1), `eval(2*$2+1)')') ! 113: L.$1.eval(2^N+$2+999): ! 114: @ remainder is negative ! 115: adds R, R, V ! 116: ifelse($1, N, ! 117: ` ifelse(eval(2*$2-1<0), `0', ! 118: `add Q, Q, `#'eval($2*2-1)', ! 119: `sub Q, Q, `#'eval(-($2*2-1))') ! 120: b 9f ! 121: ! 122: ', ` DEVELOP_QUOTIENT_BITS(incr($1), `eval(2*$2-1)')') ! 123: ifelse($1, 1, `9:')')dnl ! 124: ! 125: #include "trap.h" ! 126: ! 127: ip .req r12 ! 128: sp .req r13 ! 129: lr .req r14 ! 130: pc .req r15 ! 131: .text ! 132: .globl NAME ! 133: .align 0 ! 134: NAME: ! 135: stmdb sp!, REGLIST lr} ! 136: ifelse(S, `true', ! 137: ` @ compute sign of result; if neither is negative, no problem ! 138: ifelse(OP, `div', `eor SIGN, divisor, dividend @ compute sign', ! 139: `mov SIGN, dividend') ! 140: cmp divisor, #0 ! 141: rsbmi divisor, divisor, #0 ! 142: beq Ldiv_zero ! 143: mov V, divisor ! 144: movs R, dividend ! 145: rsbmi R, R, #0 @ make dividend nonnegative ! 146: ', ! 147: ` @ Ready to divide. Compute size of quotient; scale comparand. ! 148: movs V, divisor ! 149: mov R, dividend ! 150: beq Ldiv_zero ! 151: ') ! 152: ! 153: cmp R, V @ if divisor exceeds dividend, done ! 154: mov Q, #0 ! 155: bcc Lgot_result @ (and algorithm fails otherwise) ! 156: mov T, `#'(1 << (WORDSIZE - TOPBITS - 1)) ! 157: cmp R, T ! 158: mov ITER, #0 ! 159: bcc Lnot_really_big ! 160: ! 161: @ `Here the dividend is >= 2^(31-N) or so. We must be careful here, ! 162: @ as our usual N-at-a-shot divide step will cause overflow and havoc. ! 163: @ The number of bits in the result here is N*ITER+SC, where SC <= N. ! 164: @ Compute ITER in an unorthodox manner: know we need to shift V into ! 165: @ the top decade: so do not even bother to compare to R.' ! 166: mov SC, #1 ! 167: 1: ! 168: cmp V, T ! 169: bcs 3f ! 170: mov V, V, lsl `#'N ! 171: add ITER, ITER, #1 ! 172: b 1b ! 173: ! 174: @ Now compute SC. ! 175: 2: adds V, V, V ! 176: add SC, SC, #1 ! 177: bcc Lnot_too_big ! 178: ! 179: @ We get here if the divisor overflowed while shifting. ! 180: @ This means that R has the high-order bit set. ! 181: @ Restore V and subtract from R. ! 182: mov T, T, lsl `#'TOPBITS ! 183: mov V, V, lsr #1 ! 184: add V, T, V ! 185: sub SC, SC, #1 ! 186: b Ldo_single_div ! 187: ! 188: Lnot_too_big: ! 189: 3: cmp V, R ! 190: bcc 2b ! 191: @ beq Ldo_single_div ! 192: ! 193: /-* NB: these are commented out in the V8-Sparc manual as well *-/ ! 194: /-* (I do not understand this) *-/ ! 195: @ V > R: went too far: back up 1 step ! 196: @ srl V, 1, V ! 197: @ dec SC ! 198: @ do single-bit divide steps ! 199: @ ! 200: @ We have to be careful here. We know that R >= V, so we can do the ! 201: @ first divide step without thinking. BUT, the others are conditional, ! 202: @ and are only done if R >= 0. Because both R and V may have the high- ! 203: @ order bit set in the first step, just falling into the regular ! 204: @ division loop will mess up the first time around. ! 205: @ So we unroll slightly... ! 206: Ldo_single_div: ! 207: subs SC, SC, #1 ! 208: blt Lend_regular_divide ! 209: sub R, R, V ! 210: mov Q, #1 ! 211: b Lend_single_divloop ! 212: Lsingle_divloop: ! 213: cmp R, #0 ! 214: mov Q, Q, lsl #1 ! 215: mov V, V, lsr #1 ! 216: @ R >= 0 ! 217: subpl R, R, V ! 218: addpl Q, Q, #1 ! 219: @ R < 0 ! 220: addmi R, R, V ! 221: submi Q, Q, #1 ! 222: Lend_single_divloop: ! 223: subs SC, SC, #1 ! 224: bge Lsingle_divloop ! 225: b Lend_regular_divide ! 226: ! 227: 1: ! 228: add ITER, ITER, #1 ! 229: Lnot_really_big: ! 230: mov V, V, lsl `#'N ! 231: cmp V, R ! 232: bls 1b ! 233: @ ! 234: @ HOW CAN ITER EVER BE -1 HERE ????? ! 235: @ ! 236: cmn ITER, #1 ! 237: beq Lgot_result ! 238: ! 239: Ldivloop: ! 240: cmp R, #0 @ set up for initial iteration ! 241: mov Q, Q, lsl `#'N ! 242: DEVELOP_QUOTIENT_BITS(1, 0) ! 243: Lend_regular_divide: ! 244: subs ITER, ITER, #1 ! 245: bge Ldivloop ! 246: cmp R, #0 ! 247: @ non-restoring fixup here (one instruction only!) ! 248: ifelse(OP, `div', ! 249: ` sublt Q, Q, #1 ! 250: ', ` addlt R, divisor, R ! 251: ') ! 252: ! 253: Lgot_result: ! 254: ifelse(S, `true', ! 255: ` @ check to see if answer should be < 0 ! 256: cmp SIGN, #0 ! 257: ifelse(OP, `div', `rsbmi Q, Q, #0', `rsbmi R, R, #0') ! 258: ') ! 259: ifelse(OP, `div', `mov r0, Q', `mov r0, R') ! 260: ret ! 261: ! 262: Ldiv_zero: ! 263: @ Divide by zero trap. If it returns, return 0 (about as ! 264: @ wrong as possible, but that is what SunOS does...). ! 265: bl ___div0 ! 266: mov r0, #0 ! 267: ret ! 268: */ ! 269: ! 270: #ifdef L_udivsi3 ! 271: ! 272: ip .req r12 ! 273: sp .req r13 ! 274: lr .req r14 ! 275: pc .req r15 ! 276: .text ! 277: .globl ___udivsi3 ! 278: .align 0 ! 279: ___udivsi3: ! 280: stmdb sp!, {r4, r5, lr} ! 281: @ Ready to divide. Compute size of quotient; scale comparand. ! 282: movs lr, r1 ! 283: mov r3, r0 ! 284: beq Ldiv_zero ! 285: ! 286: ! 287: cmp r3, lr @ if r1 exceeds r0, done ! 288: mov r2, #0 ! 289: bcc Lgot_result @ (and algorithm fails otherwise) ! 290: mov r4, #(1 << (32 - 4 - 1)) ! 291: cmp r3, r4 ! 292: mov ip, #0 ! 293: bcc Lnot_really_big ! 294: ! 295: @ Here the dividend is >= 2^(31-N) or so. We must be careful here, ! 296: @ as our usual N-at-a-shot divide step will cause overflow and havoc. ! 297: @ The number of bits in the result here is N*ITER+SC, where SC <= N. ! 298: @ Compute ITER in an unorthodox manner: know we need to shift V into ! 299: @ the top decade: so do not even bother to compare to R. ! 300: mov r5, #1 ! 301: 1: ! 302: cmp lr, r4 ! 303: bcs 3f ! 304: mov lr, lr, lsl #4 ! 305: add ip, ip, #1 ! 306: b 1b ! 307: ! 308: @ Now compute r5. ! 309: 2: adds lr, lr, lr ! 310: add r5, r5, #1 ! 311: bcc Lnot_too_big ! 312: ! 313: @ We get here if the r1 overflowed while shifting. ! 314: @ This means that r3 has the high-order bit set. ! 315: @ Restore lr and subtract from r3. ! 316: mov r4, r4, lsl #4 ! 317: mov lr, lr, lsr #1 ! 318: add lr, r4, lr ! 319: sub r5, r5, #1 ! 320: b Ldo_single_div ! 321: ! 322: Lnot_too_big: ! 323: 3: cmp lr, r3 ! 324: bcc 2b ! 325: @ beq Ldo_single_div ! 326: ! 327: /* NB: these are commented out in the V8-Sparc manual as well */ ! 328: /* (I do not understand this) */ ! 329: @ lr > r3: went too far: back up 1 step ! 330: @ srl lr, 1, lr ! 331: @ dec r5 ! 332: @ do single-bit divide steps ! 333: @ ! 334: @ We have to be careful here. We know that r3 >= lr, so we can do the ! 335: @ first divide step without thinking. BUT, the others are conditional, ! 336: @ and are only done if r3 >= 0. Because both r3 and lr may have the high- ! 337: @ order bit set in the first step, just falling into the regular ! 338: @ division loop will mess up the first time around. ! 339: @ So we unroll slightly... ! 340: Ldo_single_div: ! 341: subs r5, r5, #1 ! 342: blt Lend_regular_divide ! 343: sub r3, r3, lr ! 344: mov r2, #1 ! 345: b Lend_single_divloop ! 346: Lsingle_divloop: ! 347: cmp r3, #0 ! 348: mov r2, r2, lsl #1 ! 349: mov lr, lr, lsr #1 ! 350: @ r3 >= 0 ! 351: subpl r3, r3, lr ! 352: addpl r2, r2, #1 ! 353: @ r3 < 0 ! 354: addmi r3, r3, lr ! 355: submi r2, r2, #1 ! 356: Lend_single_divloop: ! 357: subs r5, r5, #1 ! 358: bge Lsingle_divloop ! 359: b Lend_regular_divide ! 360: ! 361: 1: ! 362: add ip, ip, #1 ! 363: Lnot_really_big: ! 364: mov lr, lr, lsl #4 ! 365: cmp lr, r3 ! 366: bls 1b ! 367: @ ! 368: @ HOW CAN ip EVER BE -1 HERE ????? ! 369: @ ! 370: cmn ip, #1 ! 371: beq Lgot_result ! 372: ! 373: Ldivloop: ! 374: cmp r3, #0 @ set up for initial iteration ! 375: mov r2, r2, lsl #4 ! 376: @ depth 1, accumulated bits 0 ! 377: mov lr, lr, lsr #1 ! 378: blt L.1.1015 ! 379: @ remainder is positive ! 380: subs r3, r3, lr ! 381: @ depth 2, accumulated bits 1 ! 382: mov lr, lr, lsr #1 ! 383: blt L.2.1016 ! 384: @ remainder is positive ! 385: subs r3, r3, lr ! 386: @ depth 3, accumulated bits 3 ! 387: mov lr, lr, lsr #1 ! 388: blt L.3.1018 ! 389: @ remainder is positive ! 390: subs r3, r3, lr ! 391: @ depth 4, accumulated bits 7 ! 392: mov lr, lr, lsr #1 ! 393: blt L.4.1022 ! 394: @ remainder is positive ! 395: subs r3, r3, lr ! 396: add r2, r2, #15 ! 397: ! 398: b 9f ! 399: ! 400: L.4.1022: ! 401: @ remainder is negative ! 402: adds r3, r3, lr ! 403: add r2, r2, #13 ! 404: b 9f ! 405: ! 406: ! 407: ! 408: L.3.1018: ! 409: @ remainder is negative ! 410: adds r3, r3, lr ! 411: @ depth 4, accumulated bits 5 ! 412: mov lr, lr, lsr #1 ! 413: blt L.4.1020 ! 414: @ remainder is positive ! 415: subs r3, r3, lr ! 416: add r2, r2, #11 ! 417: ! 418: b 9f ! 419: ! 420: L.4.1020: ! 421: @ remainder is negative ! 422: adds r3, r3, lr ! 423: add r2, r2, #9 ! 424: b 9f ! 425: ! 426: ! 427: ! 428: ! 429: L.2.1016: ! 430: @ remainder is negative ! 431: adds r3, r3, lr ! 432: @ depth 3, accumulated bits 1 ! 433: mov lr, lr, lsr #1 ! 434: blt L.3.1016 ! 435: @ remainder is positive ! 436: subs r3, r3, lr ! 437: @ depth 4, accumulated bits 3 ! 438: mov lr, lr, lsr #1 ! 439: blt L.4.1018 ! 440: @ remainder is positive ! 441: subs r3, r3, lr ! 442: add r2, r2, #7 ! 443: ! 444: b 9f ! 445: ! 446: L.4.1018: ! 447: @ remainder is negative ! 448: adds r3, r3, lr ! 449: add r2, r2, #5 ! 450: b 9f ! 451: ! 452: ! 453: ! 454: L.3.1016: ! 455: @ remainder is negative ! 456: adds r3, r3, lr ! 457: @ depth 4, accumulated bits 1 ! 458: mov lr, lr, lsr #1 ! 459: blt L.4.1016 ! 460: @ remainder is positive ! 461: subs r3, r3, lr ! 462: add r2, r2, #3 ! 463: ! 464: b 9f ! 465: ! 466: L.4.1016: ! 467: @ remainder is negative ! 468: adds r3, r3, lr ! 469: add r2, r2, #1 ! 470: b 9f ! 471: ! 472: ! 473: ! 474: ! 475: ! 476: L.1.1015: ! 477: @ remainder is negative ! 478: adds r3, r3, lr ! 479: @ depth 2, accumulated bits -1 ! 480: mov lr, lr, lsr #1 ! 481: blt L.2.1014 ! 482: @ remainder is positive ! 483: subs r3, r3, lr ! 484: @ depth 3, accumulated bits -1 ! 485: mov lr, lr, lsr #1 ! 486: blt L.3.1014 ! 487: @ remainder is positive ! 488: subs r3, r3, lr ! 489: @ depth 4, accumulated bits -1 ! 490: mov lr, lr, lsr #1 ! 491: blt L.4.1014 ! 492: @ remainder is positive ! 493: subs r3, r3, lr ! 494: sub r2, r2, #1 ! 495: ! 496: b 9f ! 497: ! 498: L.4.1014: ! 499: @ remainder is negative ! 500: adds r3, r3, lr ! 501: sub r2, r2, #3 ! 502: b 9f ! 503: ! 504: ! 505: ! 506: L.3.1014: ! 507: @ remainder is negative ! 508: adds r3, r3, lr ! 509: @ depth 4, accumulated bits -3 ! 510: mov lr, lr, lsr #1 ! 511: blt L.4.1012 ! 512: @ remainder is positive ! 513: subs r3, r3, lr ! 514: sub r2, r2, #5 ! 515: ! 516: b 9f ! 517: ! 518: L.4.1012: ! 519: @ remainder is negative ! 520: adds r3, r3, lr ! 521: sub r2, r2, #7 ! 522: b 9f ! 523: ! 524: ! 525: ! 526: ! 527: L.2.1014: ! 528: @ remainder is negative ! 529: adds r3, r3, lr ! 530: @ depth 3, accumulated bits -3 ! 531: mov lr, lr, lsr #1 ! 532: blt L.3.1012 ! 533: @ remainder is positive ! 534: subs r3, r3, lr ! 535: @ depth 4, accumulated bits -5 ! 536: mov lr, lr, lsr #1 ! 537: blt L.4.1010 ! 538: @ remainder is positive ! 539: subs r3, r3, lr ! 540: sub r2, r2, #9 ! 541: ! 542: b 9f ! 543: ! 544: L.4.1010: ! 545: @ remainder is negative ! 546: adds r3, r3, lr ! 547: sub r2, r2, #11 ! 548: b 9f ! 549: ! 550: ! 551: ! 552: L.3.1012: ! 553: @ remainder is negative ! 554: adds r3, r3, lr ! 555: @ depth 4, accumulated bits -7 ! 556: mov lr, lr, lsr #1 ! 557: blt L.4.1008 ! 558: @ remainder is positive ! 559: subs r3, r3, lr ! 560: sub r2, r2, #13 ! 561: ! 562: b 9f ! 563: ! 564: L.4.1008: ! 565: @ remainder is negative ! 566: adds r3, r3, lr ! 567: sub r2, r2, #15 ! 568: b 9f ! 569: ! 570: ! 571: ! 572: ! 573: ! 574: 9: ! 575: Lend_regular_divide: ! 576: subs ip, ip, #1 ! 577: bge Ldivloop ! 578: cmp r3, #0 ! 579: @ non-restoring fixup here (one instruction only!) ! 580: sublt r2, r2, #1 ! 581: ! 582: ! 583: Lgot_result: ! 584: ! 585: mov r0, r2 ! 586: ldmia sp!, {r4, r5, pc} ! 587: ! 588: Ldiv_zero: ! 589: @ Divide by zero trap. If it returns, return 0 (about as ! 590: @ wrong as possible, but that is what SunOS does...). ! 591: bl ___div0 ! 592: mov r0, #0 ! 593: ldmia sp!, {r4, r5, pc} ! 594: ! 595: #endif /* L_udivsi3 */ ! 596: ! 597: #ifdef L_divsi3 ! 598: ! 599: ip .req r12 ! 600: sp .req r13 ! 601: lr .req r14 ! 602: pc .req r15 ! 603: .text ! 604: .globl ___divsi3 ! 605: .align 0 ! 606: ___divsi3: ! 607: stmdb sp!, {r4, r5, r6, lr} ! 608: @ compute sign of result; if neither is negative, no problem ! 609: eor r6, r1, r0 @ compute sign ! 610: cmp r1, #0 ! 611: rsbmi r1, r1, #0 ! 612: beq Ldiv_zero ! 613: mov lr, r1 ! 614: movs r3, r0 ! 615: rsbmi r3, r3, #0 @ make dividend nonnegative ! 616: ! 617: ! 618: cmp r3, lr @ if r1 exceeds r0, done ! 619: mov r2, #0 ! 620: bcc Lgot_result @ (and algorithm fails otherwise) ! 621: mov r4, #(1 << (32 - 4 - 1)) ! 622: cmp r3, r4 ! 623: mov ip, #0 ! 624: bcc Lnot_really_big ! 625: ! 626: @ Here the dividend is >= 2^(31-N) or so. We must be careful here, ! 627: @ as our usual N-at-a-shot divide step will cause overflow and havoc. ! 628: @ The number of bits in the result here is N*ITER+SC, where SC <= N. ! 629: @ Compute ITER in an unorthodox manner: know we need to shift V into ! 630: @ the top decade: so do not even bother to compare to R. ! 631: mov r5, #1 ! 632: 1: ! 633: cmp lr, r4 ! 634: bcs 3f ! 635: mov lr, lr, lsl #4 ! 636: add ip, ip, #1 ! 637: b 1b ! 638: ! 639: @ Now compute r5. ! 640: 2: adds lr, lr, lr ! 641: add r5, r5, #1 ! 642: bcc Lnot_too_big ! 643: ! 644: @ We get here if the r1 overflowed while shifting. ! 645: @ This means that r3 has the high-order bit set. ! 646: @ Restore lr and subtract from r3. ! 647: mov r4, r4, lsl #4 ! 648: mov lr, lr, lsr #1 ! 649: add lr, r4, lr ! 650: sub r5, r5, #1 ! 651: b Ldo_single_div ! 652: ! 653: Lnot_too_big: ! 654: 3: cmp lr, r3 ! 655: bcc 2b ! 656: @ beq Ldo_single_div ! 657: ! 658: /* NB: these are commented out in the V8-Sparc manual as well */ ! 659: /* (I do not understand this) */ ! 660: @ lr > r3: went too far: back up 1 step ! 661: @ srl lr, 1, lr ! 662: @ dec r5 ! 663: @ do single-bit divide steps ! 664: @ ! 665: @ We have to be careful here. We know that r3 >= lr, so we can do the ! 666: @ first divide step without thinking. BUT, the others are conditional, ! 667: @ and are only done if r3 >= 0. Because both r3 and lr may have the high- ! 668: @ order bit set in the first step, just falling into the regular ! 669: @ division loop will mess up the first time around. ! 670: @ So we unroll slightly... ! 671: Ldo_single_div: ! 672: subs r5, r5, #1 ! 673: blt Lend_regular_divide ! 674: sub r3, r3, lr ! 675: mov r2, #1 ! 676: b Lend_single_divloop ! 677: Lsingle_divloop: ! 678: cmp r3, #0 ! 679: mov r2, r2, lsl #1 ! 680: mov lr, lr, lsr #1 ! 681: @ r3 >= 0 ! 682: subpl r3, r3, lr ! 683: addpl r2, r2, #1 ! 684: @ r3 < 0 ! 685: addmi r3, r3, lr ! 686: submi r2, r2, #1 ! 687: Lend_single_divloop: ! 688: subs r5, r5, #1 ! 689: bge Lsingle_divloop ! 690: b Lend_regular_divide ! 691: ! 692: 1: ! 693: add ip, ip, #1 ! 694: Lnot_really_big: ! 695: mov lr, lr, lsl #4 ! 696: cmp lr, r3 ! 697: bls 1b ! 698: @ ! 699: @ HOW CAN ip EVER BE -1 HERE ????? ! 700: @ ! 701: cmn ip, #1 ! 702: beq Lgot_result ! 703: ! 704: Ldivloop: ! 705: cmp r3, #0 @ set up for initial iteration ! 706: mov r2, r2, lsl #4 ! 707: @ depth 1, accumulated bits 0 ! 708: mov lr, lr, lsr #1 ! 709: blt L.1.1015 ! 710: @ remainder is positive ! 711: subs r3, r3, lr ! 712: @ depth 2, accumulated bits 1 ! 713: mov lr, lr, lsr #1 ! 714: blt L.2.1016 ! 715: @ remainder is positive ! 716: subs r3, r3, lr ! 717: @ depth 3, accumulated bits 3 ! 718: mov lr, lr, lsr #1 ! 719: blt L.3.1018 ! 720: @ remainder is positive ! 721: subs r3, r3, lr ! 722: @ depth 4, accumulated bits 7 ! 723: mov lr, lr, lsr #1 ! 724: blt L.4.1022 ! 725: @ remainder is positive ! 726: subs r3, r3, lr ! 727: add r2, r2, #15 ! 728: ! 729: b 9f ! 730: ! 731: L.4.1022: ! 732: @ remainder is negative ! 733: adds r3, r3, lr ! 734: add r2, r2, #13 ! 735: b 9f ! 736: ! 737: ! 738: ! 739: L.3.1018: ! 740: @ remainder is negative ! 741: adds r3, r3, lr ! 742: @ depth 4, accumulated bits 5 ! 743: mov lr, lr, lsr #1 ! 744: blt L.4.1020 ! 745: @ remainder is positive ! 746: subs r3, r3, lr ! 747: add r2, r2, #11 ! 748: ! 749: b 9f ! 750: ! 751: L.4.1020: ! 752: @ remainder is negative ! 753: adds r3, r3, lr ! 754: add r2, r2, #9 ! 755: b 9f ! 756: ! 757: ! 758: ! 759: ! 760: L.2.1016: ! 761: @ remainder is negative ! 762: adds r3, r3, lr ! 763: @ depth 3, accumulated bits 1 ! 764: mov lr, lr, lsr #1 ! 765: blt L.3.1016 ! 766: @ remainder is positive ! 767: subs r3, r3, lr ! 768: @ depth 4, accumulated bits 3 ! 769: mov lr, lr, lsr #1 ! 770: blt L.4.1018 ! 771: @ remainder is positive ! 772: subs r3, r3, lr ! 773: add r2, r2, #7 ! 774: ! 775: b 9f ! 776: ! 777: L.4.1018: ! 778: @ remainder is negative ! 779: adds r3, r3, lr ! 780: add r2, r2, #5 ! 781: b 9f ! 782: ! 783: ! 784: ! 785: L.3.1016: ! 786: @ remainder is negative ! 787: adds r3, r3, lr ! 788: @ depth 4, accumulated bits 1 ! 789: mov lr, lr, lsr #1 ! 790: blt L.4.1016 ! 791: @ remainder is positive ! 792: subs r3, r3, lr ! 793: add r2, r2, #3 ! 794: ! 795: b 9f ! 796: ! 797: L.4.1016: ! 798: @ remainder is negative ! 799: adds r3, r3, lr ! 800: add r2, r2, #1 ! 801: b 9f ! 802: ! 803: ! 804: ! 805: ! 806: ! 807: L.1.1015: ! 808: @ remainder is negative ! 809: adds r3, r3, lr ! 810: @ depth 2, accumulated bits -1 ! 811: mov lr, lr, lsr #1 ! 812: blt L.2.1014 ! 813: @ remainder is positive ! 814: subs r3, r3, lr ! 815: @ depth 3, accumulated bits -1 ! 816: mov lr, lr, lsr #1 ! 817: blt L.3.1014 ! 818: @ remainder is positive ! 819: subs r3, r3, lr ! 820: @ depth 4, accumulated bits -1 ! 821: mov lr, lr, lsr #1 ! 822: blt L.4.1014 ! 823: @ remainder is positive ! 824: subs r3, r3, lr ! 825: sub r2, r2, #1 ! 826: ! 827: b 9f ! 828: ! 829: L.4.1014: ! 830: @ remainder is negative ! 831: adds r3, r3, lr ! 832: sub r2, r2, #3 ! 833: b 9f ! 834: ! 835: ! 836: ! 837: L.3.1014: ! 838: @ remainder is negative ! 839: adds r3, r3, lr ! 840: @ depth 4, accumulated bits -3 ! 841: mov lr, lr, lsr #1 ! 842: blt L.4.1012 ! 843: @ remainder is positive ! 844: subs r3, r3, lr ! 845: sub r2, r2, #5 ! 846: ! 847: b 9f ! 848: ! 849: L.4.1012: ! 850: @ remainder is negative ! 851: adds r3, r3, lr ! 852: sub r2, r2, #7 ! 853: b 9f ! 854: ! 855: ! 856: ! 857: ! 858: L.2.1014: ! 859: @ remainder is negative ! 860: adds r3, r3, lr ! 861: @ depth 3, accumulated bits -3 ! 862: mov lr, lr, lsr #1 ! 863: blt L.3.1012 ! 864: @ remainder is positive ! 865: subs r3, r3, lr ! 866: @ depth 4, accumulated bits -5 ! 867: mov lr, lr, lsr #1 ! 868: blt L.4.1010 ! 869: @ remainder is positive ! 870: subs r3, r3, lr ! 871: sub r2, r2, #9 ! 872: ! 873: b 9f ! 874: ! 875: L.4.1010: ! 876: @ remainder is negative ! 877: adds r3, r3, lr ! 878: sub r2, r2, #11 ! 879: b 9f ! 880: ! 881: ! 882: ! 883: L.3.1012: ! 884: @ remainder is negative ! 885: adds r3, r3, lr ! 886: @ depth 4, accumulated bits -7 ! 887: mov lr, lr, lsr #1 ! 888: blt L.4.1008 ! 889: @ remainder is positive ! 890: subs r3, r3, lr ! 891: sub r2, r2, #13 ! 892: ! 893: b 9f ! 894: ! 895: L.4.1008: ! 896: @ remainder is negative ! 897: adds r3, r3, lr ! 898: sub r2, r2, #15 ! 899: b 9f ! 900: ! 901: ! 902: ! 903: ! 904: ! 905: 9: ! 906: Lend_regular_divide: ! 907: subs ip, ip, #1 ! 908: bge Ldivloop ! 909: cmp r3, #0 ! 910: @ non-restoring fixup here (one instruction only!) ! 911: sublt r2, r2, #1 ! 912: ! 913: ! 914: Lgot_result: ! 915: @ check to see if answer should be < 0 ! 916: cmp r6, #0 ! 917: rsbmi r2, r2, #0 ! 918: ! 919: mov r0, r2 ! 920: ldmia sp!, {r4, r5, r6, pc} ! 921: ! 922: Ldiv_zero: ! 923: @ Divide by zero trap. If it returns, return 0 (about as ! 924: @ wrong as possible, but that is what SunOS does...). ! 925: bl ___div0 ! 926: mov r0, #0 ! 927: ldmia sp!, {r4, r5, r6, pc} ! 928: ! 929: #endif /* L_divsi3 */ ! 930: ! 931: #ifdef L_umodsi3 ! 932: ! 933: ip .req r12 ! 934: sp .req r13 ! 935: lr .req r14 ! 936: pc .req r15 ! 937: .text ! 938: .globl ___umodsi3 ! 939: .align 0 ! 940: ___umodsi3: ! 941: stmdb sp!, {r4, r5, lr} ! 942: @ Ready to divide. Compute size of quotient; scale comparand. ! 943: movs lr, r1 ! 944: mov r3, r0 ! 945: beq Ldiv_zero ! 946: ! 947: ! 948: cmp r3, lr @ if r1 exceeds r0, done ! 949: mov r2, #0 ! 950: bcc Lgot_result @ (and algorithm fails otherwise) ! 951: mov r4, #(1 << (32 - 4 - 1)) ! 952: cmp r3, r4 ! 953: mov ip, #0 ! 954: bcc Lnot_really_big ! 955: ! 956: @ Here the dividend is >= 2^(31-N) or so. We must be careful here, ! 957: @ as our usual N-at-a-shot divide step will cause overflow and havoc. ! 958: @ The number of bits in the result here is N*ITER+SC, where SC <= N. ! 959: @ Compute ITER in an unorthodox manner: know we need to shift V into ! 960: @ the top decade: so do not even bother to compare to R. ! 961: mov r5, #1 ! 962: 1: ! 963: cmp lr, r4 ! 964: bcs 3f ! 965: mov lr, lr, lsl #4 ! 966: add ip, ip, #1 ! 967: b 1b ! 968: ! 969: @ Now compute r5. ! 970: 2: adds lr, lr, lr ! 971: add r5, r5, #1 ! 972: bcc Lnot_too_big ! 973: ! 974: @ We get here if the r1 overflowed while shifting. ! 975: @ This means that r3 has the high-order bit set. ! 976: @ Restore lr and subtract from r3. ! 977: mov r4, r4, lsl #4 ! 978: mov lr, lr, lsr #1 ! 979: add lr, r4, lr ! 980: sub r5, r5, #1 ! 981: b Ldo_single_div ! 982: ! 983: Lnot_too_big: ! 984: 3: cmp lr, r3 ! 985: bcc 2b ! 986: @ beq Ldo_single_div ! 987: ! 988: /* NB: these are commented out in the V8-Sparc manual as well */ ! 989: /* (I do not understand this) */ ! 990: @ lr > r3: went too far: back up 1 step ! 991: @ srl lr, 1, lr ! 992: @ dec r5 ! 993: @ do single-bit divide steps ! 994: @ ! 995: @ We have to be careful here. We know that r3 >= lr, so we can do the ! 996: @ first divide step without thinking. BUT, the others are conditional, ! 997: @ and are only done if r3 >= 0. Because both r3 and lr may have the high- ! 998: @ order bit set in the first step, just falling into the regular ! 999: @ division loop will mess up the first time around. ! 1000: @ So we unroll slightly... ! 1001: Ldo_single_div: ! 1002: subs r5, r5, #1 ! 1003: blt Lend_regular_divide ! 1004: sub r3, r3, lr ! 1005: mov r2, #1 ! 1006: b Lend_single_divloop ! 1007: Lsingle_divloop: ! 1008: cmp r3, #0 ! 1009: mov r2, r2, lsl #1 ! 1010: mov lr, lr, lsr #1 ! 1011: @ r3 >= 0 ! 1012: subpl r3, r3, lr ! 1013: addpl r2, r2, #1 ! 1014: @ r3 < 0 ! 1015: addmi r3, r3, lr ! 1016: submi r2, r2, #1 ! 1017: Lend_single_divloop: ! 1018: subs r5, r5, #1 ! 1019: bge Lsingle_divloop ! 1020: b Lend_regular_divide ! 1021: ! 1022: 1: ! 1023: add ip, ip, #1 ! 1024: Lnot_really_big: ! 1025: mov lr, lr, lsl #4 ! 1026: cmp lr, r3 ! 1027: bls 1b ! 1028: @ ! 1029: @ HOW CAN ip EVER BE -1 HERE ????? ! 1030: @ ! 1031: cmn ip, #1 ! 1032: beq Lgot_result ! 1033: ! 1034: Ldivloop: ! 1035: cmp r3, #0 @ set up for initial iteration ! 1036: mov r2, r2, lsl #4 ! 1037: @ depth 1, accumulated bits 0 ! 1038: mov lr, lr, lsr #1 ! 1039: blt L.1.1015 ! 1040: @ remainder is positive ! 1041: subs r3, r3, lr ! 1042: @ depth 2, accumulated bits 1 ! 1043: mov lr, lr, lsr #1 ! 1044: blt L.2.1016 ! 1045: @ remainder is positive ! 1046: subs r3, r3, lr ! 1047: @ depth 3, accumulated bits 3 ! 1048: mov lr, lr, lsr #1 ! 1049: blt L.3.1018 ! 1050: @ remainder is positive ! 1051: subs r3, r3, lr ! 1052: @ depth 4, accumulated bits 7 ! 1053: mov lr, lr, lsr #1 ! 1054: blt L.4.1022 ! 1055: @ remainder is positive ! 1056: subs r3, r3, lr ! 1057: add r2, r2, #15 ! 1058: ! 1059: b 9f ! 1060: ! 1061: L.4.1022: ! 1062: @ remainder is negative ! 1063: adds r3, r3, lr ! 1064: add r2, r2, #13 ! 1065: b 9f ! 1066: ! 1067: ! 1068: ! 1069: L.3.1018: ! 1070: @ remainder is negative ! 1071: adds r3, r3, lr ! 1072: @ depth 4, accumulated bits 5 ! 1073: mov lr, lr, lsr #1 ! 1074: blt L.4.1020 ! 1075: @ remainder is positive ! 1076: subs r3, r3, lr ! 1077: add r2, r2, #11 ! 1078: ! 1079: b 9f ! 1080: ! 1081: L.4.1020: ! 1082: @ remainder is negative ! 1083: adds r3, r3, lr ! 1084: add r2, r2, #9 ! 1085: b 9f ! 1086: ! 1087: ! 1088: ! 1089: ! 1090: L.2.1016: ! 1091: @ remainder is negative ! 1092: adds r3, r3, lr ! 1093: @ depth 3, accumulated bits 1 ! 1094: mov lr, lr, lsr #1 ! 1095: blt L.3.1016 ! 1096: @ remainder is positive ! 1097: subs r3, r3, lr ! 1098: @ depth 4, accumulated bits 3 ! 1099: mov lr, lr, lsr #1 ! 1100: blt L.4.1018 ! 1101: @ remainder is positive ! 1102: subs r3, r3, lr ! 1103: add r2, r2, #7 ! 1104: ! 1105: b 9f ! 1106: ! 1107: L.4.1018: ! 1108: @ remainder is negative ! 1109: adds r3, r3, lr ! 1110: add r2, r2, #5 ! 1111: b 9f ! 1112: ! 1113: ! 1114: ! 1115: L.3.1016: ! 1116: @ remainder is negative ! 1117: adds r3, r3, lr ! 1118: @ depth 4, accumulated bits 1 ! 1119: mov lr, lr, lsr #1 ! 1120: blt L.4.1016 ! 1121: @ remainder is positive ! 1122: subs r3, r3, lr ! 1123: add r2, r2, #3 ! 1124: ! 1125: b 9f ! 1126: ! 1127: L.4.1016: ! 1128: @ remainder is negative ! 1129: adds r3, r3, lr ! 1130: add r2, r2, #1 ! 1131: b 9f ! 1132: ! 1133: ! 1134: ! 1135: ! 1136: ! 1137: L.1.1015: ! 1138: @ remainder is negative ! 1139: adds r3, r3, lr ! 1140: @ depth 2, accumulated bits -1 ! 1141: mov lr, lr, lsr #1 ! 1142: blt L.2.1014 ! 1143: @ remainder is positive ! 1144: subs r3, r3, lr ! 1145: @ depth 3, accumulated bits -1 ! 1146: mov lr, lr, lsr #1 ! 1147: blt L.3.1014 ! 1148: @ remainder is positive ! 1149: subs r3, r3, lr ! 1150: @ depth 4, accumulated bits -1 ! 1151: mov lr, lr, lsr #1 ! 1152: blt L.4.1014 ! 1153: @ remainder is positive ! 1154: subs r3, r3, lr ! 1155: sub r2, r2, #1 ! 1156: ! 1157: b 9f ! 1158: ! 1159: L.4.1014: ! 1160: @ remainder is negative ! 1161: adds r3, r3, lr ! 1162: sub r2, r2, #3 ! 1163: b 9f ! 1164: ! 1165: ! 1166: ! 1167: L.3.1014: ! 1168: @ remainder is negative ! 1169: adds r3, r3, lr ! 1170: @ depth 4, accumulated bits -3 ! 1171: mov lr, lr, lsr #1 ! 1172: blt L.4.1012 ! 1173: @ remainder is positive ! 1174: subs r3, r3, lr ! 1175: sub r2, r2, #5 ! 1176: ! 1177: b 9f ! 1178: ! 1179: L.4.1012: ! 1180: @ remainder is negative ! 1181: adds r3, r3, lr ! 1182: sub r2, r2, #7 ! 1183: b 9f ! 1184: ! 1185: ! 1186: ! 1187: ! 1188: L.2.1014: ! 1189: @ remainder is negative ! 1190: adds r3, r3, lr ! 1191: @ depth 3, accumulated bits -3 ! 1192: mov lr, lr, lsr #1 ! 1193: blt L.3.1012 ! 1194: @ remainder is positive ! 1195: subs r3, r3, lr ! 1196: @ depth 4, accumulated bits -5 ! 1197: mov lr, lr, lsr #1 ! 1198: blt L.4.1010 ! 1199: @ remainder is positive ! 1200: subs r3, r3, lr ! 1201: sub r2, r2, #9 ! 1202: ! 1203: b 9f ! 1204: ! 1205: L.4.1010: ! 1206: @ remainder is negative ! 1207: adds r3, r3, lr ! 1208: sub r2, r2, #11 ! 1209: b 9f ! 1210: ! 1211: ! 1212: ! 1213: L.3.1012: ! 1214: @ remainder is negative ! 1215: adds r3, r3, lr ! 1216: @ depth 4, accumulated bits -7 ! 1217: mov lr, lr, lsr #1 ! 1218: blt L.4.1008 ! 1219: @ remainder is positive ! 1220: subs r3, r3, lr ! 1221: sub r2, r2, #13 ! 1222: ! 1223: b 9f ! 1224: ! 1225: L.4.1008: ! 1226: @ remainder is negative ! 1227: adds r3, r3, lr ! 1228: sub r2, r2, #15 ! 1229: b 9f ! 1230: ! 1231: ! 1232: ! 1233: ! 1234: ! 1235: 9: ! 1236: Lend_regular_divide: ! 1237: subs ip, ip, #1 ! 1238: bge Ldivloop ! 1239: cmp r3, #0 ! 1240: @ non-restoring fixup here (one instruction only!) ! 1241: addlt r3, r1, r3 ! 1242: ! 1243: ! 1244: Lgot_result: ! 1245: ! 1246: mov r0, r3 ! 1247: ldmia sp!, {r4, r5, pc} ! 1248: ! 1249: Ldiv_zero: ! 1250: @ Divide by zero trap. If it returns, return 0 (about as ! 1251: @ wrong as possible, but that is what SunOS does...). ! 1252: bl ___div0 ! 1253: mov r0, #0 ! 1254: ldmia sp!, {r4, r5, pc} ! 1255: ! 1256: #endif /* L_umodsi3 */ ! 1257: ! 1258: #ifdef L_modsi3 ! 1259: ! 1260: ip .req r12 ! 1261: sp .req r13 ! 1262: lr .req r14 ! 1263: pc .req r15 ! 1264: .text ! 1265: .globl ___modsi3 ! 1266: .align 0 ! 1267: ___modsi3: ! 1268: stmdb sp!, {r4, r5, r6, lr} ! 1269: @ compute sign of result; if neither is negative, no problem ! 1270: mov r6, r0 ! 1271: cmp r1, #0 ! 1272: rsbmi r1, r1, #0 ! 1273: beq Ldiv_zero ! 1274: mov lr, r1 ! 1275: movs r3, r0 ! 1276: rsbmi r3, r3, #0 @ make dividend nonnegative ! 1277: ! 1278: ! 1279: cmp r3, lr @ if r1 exceeds r0, done ! 1280: mov r2, #0 ! 1281: bcc Lgot_result @ (and algorithm fails otherwise) ! 1282: mov r4, #(1 << (32 - 4 - 1)) ! 1283: cmp r3, r4 ! 1284: mov ip, #0 ! 1285: bcc Lnot_really_big ! 1286: ! 1287: @ Here the dividend is >= 2^(31-N) or so. We must be careful here, ! 1288: @ as our usual N-at-a-shot divide step will cause overflow and havoc. ! 1289: @ The number of bits in the result here is N*ITER+SC, where SC <= N. ! 1290: @ Compute ITER in an unorthodox manner: know we need to shift V into ! 1291: @ the top decade: so do not even bother to compare to R. ! 1292: mov r5, #1 ! 1293: 1: ! 1294: cmp lr, r4 ! 1295: bcs 3f ! 1296: mov lr, lr, lsl #4 ! 1297: add ip, ip, #1 ! 1298: b 1b ! 1299: ! 1300: @ Now compute r5. ! 1301: 2: adds lr, lr, lr ! 1302: add r5, r5, #1 ! 1303: bcc Lnot_too_big ! 1304: ! 1305: @ We get here if the r1 overflowed while shifting. ! 1306: @ This means that r3 has the high-order bit set. ! 1307: @ Restore lr and subtract from r3. ! 1308: mov r4, r4, lsl #4 ! 1309: mov lr, lr, lsr #1 ! 1310: add lr, r4, lr ! 1311: sub r5, r5, #1 ! 1312: b Ldo_single_div ! 1313: ! 1314: Lnot_too_big: ! 1315: 3: cmp lr, r3 ! 1316: bcc 2b ! 1317: @ beq Ldo_single_div ! 1318: ! 1319: /* NB: these are commented out in the V8-Sparc manual as well */ ! 1320: /* (I do not understand this) */ ! 1321: @ lr > r3: went too far: back up 1 step ! 1322: @ srl lr, 1, lr ! 1323: @ dec r5 ! 1324: @ do single-bit divide steps ! 1325: @ ! 1326: @ We have to be careful here. We know that r3 >= lr, so we can do the ! 1327: @ first divide step without thinking. BUT, the others are conditional, ! 1328: @ and are only done if r3 >= 0. Because both r3 and lr may have the high- ! 1329: @ order bit set in the first step, just falling into the regular ! 1330: @ division loop will mess up the first time around. ! 1331: @ So we unroll slightly... ! 1332: Ldo_single_div: ! 1333: subs r5, r5, #1 ! 1334: blt Lend_regular_divide ! 1335: sub r3, r3, lr ! 1336: mov r2, #1 ! 1337: b Lend_single_divloop ! 1338: Lsingle_divloop: ! 1339: cmp r3, #0 ! 1340: mov r2, r2, lsl #1 ! 1341: mov lr, lr, lsr #1 ! 1342: @ r3 >= 0 ! 1343: subpl r3, r3, lr ! 1344: addpl r2, r2, #1 ! 1345: @ r3 < 0 ! 1346: addmi r3, r3, lr ! 1347: submi r2, r2, #1 ! 1348: Lend_single_divloop: ! 1349: subs r5, r5, #1 ! 1350: bge Lsingle_divloop ! 1351: b Lend_regular_divide ! 1352: ! 1353: 1: ! 1354: add ip, ip, #1 ! 1355: Lnot_really_big: ! 1356: mov lr, lr, lsl #4 ! 1357: cmp lr, r3 ! 1358: bls 1b ! 1359: @ ! 1360: @ HOW CAN ip EVER BE -1 HERE ????? ! 1361: @ ! 1362: cmn ip, #1 ! 1363: beq Lgot_result ! 1364: ! 1365: Ldivloop: ! 1366: cmp r3, #0 @ set up for initial iteration ! 1367: mov r2, r2, lsl #4 ! 1368: @ depth 1, accumulated bits 0 ! 1369: mov lr, lr, lsr #1 ! 1370: blt L.1.1015 ! 1371: @ remainder is positive ! 1372: subs r3, r3, lr ! 1373: @ depth 2, accumulated bits 1 ! 1374: mov lr, lr, lsr #1 ! 1375: blt L.2.1016 ! 1376: @ remainder is positive ! 1377: subs r3, r3, lr ! 1378: @ depth 3, accumulated bits 3 ! 1379: mov lr, lr, lsr #1 ! 1380: blt L.3.1018 ! 1381: @ remainder is positive ! 1382: subs r3, r3, lr ! 1383: @ depth 4, accumulated bits 7 ! 1384: mov lr, lr, lsr #1 ! 1385: blt L.4.1022 ! 1386: @ remainder is positive ! 1387: subs r3, r3, lr ! 1388: add r2, r2, #15 ! 1389: ! 1390: b 9f ! 1391: ! 1392: L.4.1022: ! 1393: @ remainder is negative ! 1394: adds r3, r3, lr ! 1395: add r2, r2, #13 ! 1396: b 9f ! 1397: ! 1398: ! 1399: ! 1400: L.3.1018: ! 1401: @ remainder is negative ! 1402: adds r3, r3, lr ! 1403: @ depth 4, accumulated bits 5 ! 1404: mov lr, lr, lsr #1 ! 1405: blt L.4.1020 ! 1406: @ remainder is positive ! 1407: subs r3, r3, lr ! 1408: add r2, r2, #11 ! 1409: ! 1410: b 9f ! 1411: ! 1412: L.4.1020: ! 1413: @ remainder is negative ! 1414: adds r3, r3, lr ! 1415: add r2, r2, #9 ! 1416: b 9f ! 1417: ! 1418: ! 1419: ! 1420: ! 1421: L.2.1016: ! 1422: @ remainder is negative ! 1423: adds r3, r3, lr ! 1424: @ depth 3, accumulated bits 1 ! 1425: mov lr, lr, lsr #1 ! 1426: blt L.3.1016 ! 1427: @ remainder is positive ! 1428: subs r3, r3, lr ! 1429: @ depth 4, accumulated bits 3 ! 1430: mov lr, lr, lsr #1 ! 1431: blt L.4.1018 ! 1432: @ remainder is positive ! 1433: subs r3, r3, lr ! 1434: add r2, r2, #7 ! 1435: ! 1436: b 9f ! 1437: ! 1438: L.4.1018: ! 1439: @ remainder is negative ! 1440: adds r3, r3, lr ! 1441: add r2, r2, #5 ! 1442: b 9f ! 1443: ! 1444: ! 1445: ! 1446: L.3.1016: ! 1447: @ remainder is negative ! 1448: adds r3, r3, lr ! 1449: @ depth 4, accumulated bits 1 ! 1450: mov lr, lr, lsr #1 ! 1451: blt L.4.1016 ! 1452: @ remainder is positive ! 1453: subs r3, r3, lr ! 1454: add r2, r2, #3 ! 1455: ! 1456: b 9f ! 1457: ! 1458: L.4.1016: ! 1459: @ remainder is negative ! 1460: adds r3, r3, lr ! 1461: add r2, r2, #1 ! 1462: b 9f ! 1463: ! 1464: ! 1465: ! 1466: ! 1467: ! 1468: L.1.1015: ! 1469: @ remainder is negative ! 1470: adds r3, r3, lr ! 1471: @ depth 2, accumulated bits -1 ! 1472: mov lr, lr, lsr #1 ! 1473: blt L.2.1014 ! 1474: @ remainder is positive ! 1475: subs r3, r3, lr ! 1476: @ depth 3, accumulated bits -1 ! 1477: mov lr, lr, lsr #1 ! 1478: blt L.3.1014 ! 1479: @ remainder is positive ! 1480: subs r3, r3, lr ! 1481: @ depth 4, accumulated bits -1 ! 1482: mov lr, lr, lsr #1 ! 1483: blt L.4.1014 ! 1484: @ remainder is positive ! 1485: subs r3, r3, lr ! 1486: sub r2, r2, #1 ! 1487: ! 1488: b 9f ! 1489: ! 1490: L.4.1014: ! 1491: @ remainder is negative ! 1492: adds r3, r3, lr ! 1493: sub r2, r2, #3 ! 1494: b 9f ! 1495: ! 1496: ! 1497: ! 1498: L.3.1014: ! 1499: @ remainder is negative ! 1500: adds r3, r3, lr ! 1501: @ depth 4, accumulated bits -3 ! 1502: mov lr, lr, lsr #1 ! 1503: blt L.4.1012 ! 1504: @ remainder is positive ! 1505: subs r3, r3, lr ! 1506: sub r2, r2, #5 ! 1507: ! 1508: b 9f ! 1509: ! 1510: L.4.1012: ! 1511: @ remainder is negative ! 1512: adds r3, r3, lr ! 1513: sub r2, r2, #7 ! 1514: b 9f ! 1515: ! 1516: ! 1517: ! 1518: ! 1519: L.2.1014: ! 1520: @ remainder is negative ! 1521: adds r3, r3, lr ! 1522: @ depth 3, accumulated bits -3 ! 1523: mov lr, lr, lsr #1 ! 1524: blt L.3.1012 ! 1525: @ remainder is positive ! 1526: subs r3, r3, lr ! 1527: @ depth 4, accumulated bits -5 ! 1528: mov lr, lr, lsr #1 ! 1529: blt L.4.1010 ! 1530: @ remainder is positive ! 1531: subs r3, r3, lr ! 1532: sub r2, r2, #9 ! 1533: ! 1534: b 9f ! 1535: ! 1536: L.4.1010: ! 1537: @ remainder is negative ! 1538: adds r3, r3, lr ! 1539: sub r2, r2, #11 ! 1540: b 9f ! 1541: ! 1542: ! 1543: ! 1544: L.3.1012: ! 1545: @ remainder is negative ! 1546: adds r3, r3, lr ! 1547: @ depth 4, accumulated bits -7 ! 1548: mov lr, lr, lsr #1 ! 1549: blt L.4.1008 ! 1550: @ remainder is positive ! 1551: subs r3, r3, lr ! 1552: sub r2, r2, #13 ! 1553: ! 1554: b 9f ! 1555: ! 1556: L.4.1008: ! 1557: @ remainder is negative ! 1558: adds r3, r3, lr ! 1559: sub r2, r2, #15 ! 1560: b 9f ! 1561: ! 1562: ! 1563: ! 1564: ! 1565: ! 1566: 9: ! 1567: Lend_regular_divide: ! 1568: subs ip, ip, #1 ! 1569: bge Ldivloop ! 1570: cmp r3, #0 ! 1571: @ non-restoring fixup here (one instruction only!) ! 1572: addlt r3, r1, r3 ! 1573: ! 1574: ! 1575: Lgot_result: ! 1576: @ check to see if answer should be < 0 ! 1577: cmp r6, #0 ! 1578: rsbmi r3, r3, #0 ! 1579: ! 1580: mov r0, r3 ! 1581: ldmia sp!, {r4, r5, r6, pc} ! 1582: ! 1583: Ldiv_zero: ! 1584: @ Divide by zero trap. If it returns, return 0 (about as ! 1585: @ wrong as possible, but that is what SunOS does...). ! 1586: bl ___div0 ! 1587: mov r0, #0 ! 1588: ldmia sp!, {r4, r5, r6, pc} ! 1589: ! 1590: #endif /* L_modsi3 */ ! 1591: ! 1592: #ifdef L_dvmd_tls ! 1593: ! 1594: .globl ___div0 ! 1595: .align 0 ! 1596: ___div0: ! 1597: mov pc, lr ! 1598: ! 1599: #endif /* L_divmodsi_tools */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.