@ libgcc1 routines for ARM cpu. | |

@ Division routines, written by Richard Earnshaw, (rearnsha@armltd.co.uk) | |

/* Copyright (C) 1995, 1996 Free Software Foundation, Inc. | |

This file is free software; you can redistribute it and/or modify it | |

under the terms of the GNU General Public License as published by the | |

Free Software Foundation; either version 2, or (at your option) any | |

later version. | |

In addition to the permissions in the GNU General Public License, the | |

Free Software Foundation gives you unlimited permission to link the | |

compiled version of this file with other programs, and to distribute | |

those programs without any restriction coming from the use of this | |

file. (The General Public License restrictions do apply in other | |

respects; for example, they cover modification of the file, and | |

distribution when not linked into another program.) | |

This file is distributed in the hope that it will be useful, but | |

WITHOUT ANY WARRANTY; without even the implied warranty of | |

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |

General Public License for more details. | |

You should have received a copy of the GNU General Public License | |

along with this program; see the file COPYING. If not, write to | |

the Free Software Foundation, 59 Temple Place - Suite 330, | |

Boston, MA 02111-1307, USA. */ | |

/* As a special exception, if you link this library with other files, | |

some of which are compiled with GCC, to produce an executable, | |

this library does not by itself cause the resulting executable | |

to be covered by the GNU General Public License. | |

This exception does not however invalidate any other reasons why | |

the executable file might be covered by the GNU General Public License. */ | |

#ifdef __APCS_26__ | |

#define RET movs | |

#define RETc(x) mov##x##s | |

#define RETCOND ^ | |

#else | |

#define RET mov | |

#define RETc(x) mov##x | |

#define RETCOND | |

#endif | |

#ifndef __USER_LABEL_PREFIX__ | |

#define __USER_LABEL_PREFIX__ _ | |

#endif | |

/* ANSI concatenation macros. */ | |

#define CONCAT1(a, b) CONCAT2(a, b) | |

#define CONCAT2(a, b) a ## b | |

/* Use the right prefix for global labels. */ | |

#define SYM(x) CONCAT1 (__USER_LABEL_PREFIX__, x) | |

#ifdef L_udivsi3 | |

dividend .req r0 | |

divisor .req r1 | |

result .req r2 | |

curbit .req r3 | |

ip .req r12 | |

sp .req r13 | |

lr .req r14 | |

pc .req r15 | |

.text | |

.globl SYM (__udivsi3) | |

.align 0 | |

SYM (__udivsi3): | |

cmp divisor, #0 | |

beq Ldiv0 | |

mov curbit, #1 | |

mov result, #0 | |

cmp dividend, divisor | |

bcc Lgot_result | |

Loop1: | |

@ Unless the divisor is very big, shift it up in multiples of | |

@ four bits, since this is the amount of unwinding in the main | |

@ division loop. Continue shifting until the divisor is | |

@ larger than the dividend. | |

cmp divisor, #0x10000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #4 | |

movcc curbit, curbit, lsl #4 | |

bcc Loop1 | |

Lbignum: | |

@ For very big divisors, we must shift it a bit at a time, or | |

@ we will be in danger of overflowing. | |

cmp divisor, #0x80000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #1 | |

movcc curbit, curbit, lsl #1 | |

bcc Lbignum | |

Loop3: | |

@ Test for possible subtractions, and note which bits | |

@ are done in the result. On the final pass, this may subtract | |

@ too much from the dividend, but the result will be ok, since the | |

@ "bit" will have been shifted out at the bottom. | |

cmp dividend, divisor | |

subcs dividend, dividend, divisor | |

orrcs result, result, curbit | |

cmp dividend, divisor, lsr #1 | |

subcs dividend, dividend, divisor, lsr #1 | |

orrcs result, result, curbit, lsr #1 | |

cmp dividend, divisor, lsr #2 | |

subcs dividend, dividend, divisor, lsr #2 | |

orrcs result, result, curbit, lsr #2 | |

cmp dividend, divisor, lsr #3 | |

subcs dividend, dividend, divisor, lsr #3 | |

orrcs result, result, curbit, lsr #3 | |

cmp dividend, #0 @ Early termination? | |

movnes curbit, curbit, lsr #4 @ No, any more bits to do? | |

movne divisor, divisor, lsr #4 | |

bne Loop3 | |

Lgot_result: | |

mov r0, result | |

RET pc, lr | |

Ldiv0: | |

str lr, [sp, #-4]! | |

bl SYM (__div0) | |

mov r0, #0 @ about as wrong as it could be | |

ldmia sp!, {pc}RETCOND | |

#endif /* L_udivsi3 */ | |

#ifdef L_umodsi3 | |

dividend .req r0 | |

divisor .req r1 | |

overdone .req r2 | |

curbit .req r3 | |

ip .req r12 | |

sp .req r13 | |

lr .req r14 | |

pc .req r15 | |

.text | |

.globl SYM (__umodsi3) | |

.align 0 | |

SYM (__umodsi3): | |

cmp divisor, #0 | |

beq Ldiv0 | |

mov curbit, #1 | |

cmp dividend, divisor | |

RETc(cc) pc, lr | |

Loop1: | |

@ Unless the divisor is very big, shift it up in multiples of | |

@ four bits, since this is the amount of unwinding in the main | |

@ division loop. Continue shifting until the divisor is | |

@ larger than the dividend. | |

cmp divisor, #0x10000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #4 | |

movcc curbit, curbit, lsl #4 | |

bcc Loop1 | |

Lbignum: | |

@ For very big divisors, we must shift it a bit at a time, or | |

@ we will be in danger of overflowing. | |

cmp divisor, #0x80000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #1 | |

movcc curbit, curbit, lsl #1 | |

bcc Lbignum | |

Loop3: | |

@ Test for possible subtractions. On the final pass, this may | |

@ subtract too much from the dividend, so keep track of which | |

@ subtractions are done, we can fix them up afterwards... | |

mov overdone, #0 | |

cmp dividend, divisor | |

subcs dividend, dividend, divisor | |

cmp dividend, divisor, lsr #1 | |

subcs dividend, dividend, divisor, lsr #1 | |

orrcs overdone, overdone, curbit, ror #1 | |

cmp dividend, divisor, lsr #2 | |

subcs dividend, dividend, divisor, lsr #2 | |

orrcs overdone, overdone, curbit, ror #2 | |

cmp dividend, divisor, lsr #3 | |

subcs dividend, dividend, divisor, lsr #3 | |

orrcs overdone, overdone, curbit, ror #3 | |

mov ip, curbit | |

cmp dividend, #0 @ Early termination? | |

movnes curbit, curbit, lsr #4 @ No, any more bits to do? | |

movne divisor, divisor, lsr #4 | |

bne Loop3 | |

@ Any subtractions that we should not have done will be recorded in | |

@ the top three bits of "overdone". Exactly which were not needed | |

@ are governed by the position of the bit, stored in ip. | |

@ If we terminated early, because dividend became zero, | |

@ then none of the below will match, since the bit in ip will not be | |

@ in the bottom nibble. | |

ands overdone, overdone, #0xe0000000 | |

RETc(eq) pc, lr @ No fixups needed | |

tst overdone, ip, ror #3 | |

addne dividend, dividend, divisor, lsr #3 | |

tst overdone, ip, ror #2 | |

addne dividend, dividend, divisor, lsr #2 | |

tst overdone, ip, ror #1 | |

addne dividend, dividend, divisor, lsr #1 | |

RET pc, lr | |

Ldiv0: | |

str lr, [sp, #-4]! | |

bl SYM (__div0) | |

mov r0, #0 @ about as wrong as it could be | |

ldmia sp!, {pc}RETCOND | |

#endif /* L_umodsi3 */ | |

#ifdef L_divsi3 | |

dividend .req r0 | |

divisor .req r1 | |

result .req r2 | |

curbit .req r3 | |

ip .req r12 | |

sp .req r13 | |

lr .req r14 | |

pc .req r15 | |

.text | |

.globl SYM (__divsi3) | |

.align 0 | |

SYM (__divsi3): | |

eor ip, dividend, divisor @ Save the sign of the result. | |

mov curbit, #1 | |

mov result, #0 | |

cmp divisor, #0 | |

rsbmi divisor, divisor, #0 @ Loops below use unsigned. | |

beq Ldiv0 | |

cmp dividend, #0 | |

rsbmi dividend, dividend, #0 | |

cmp dividend, divisor | |

bcc Lgot_result | |

Loop1: | |

@ Unless the divisor is very big, shift it up in multiples of | |

@ four bits, since this is the amount of unwinding in the main | |

@ division loop. Continue shifting until the divisor is | |

@ larger than the dividend. | |

cmp divisor, #0x10000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #4 | |

movcc curbit, curbit, lsl #4 | |

bcc Loop1 | |

Lbignum: | |

@ For very big divisors, we must shift it a bit at a time, or | |

@ we will be in danger of overflowing. | |

cmp divisor, #0x80000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #1 | |

movcc curbit, curbit, lsl #1 | |

bcc Lbignum | |

Loop3: | |

@ Test for possible subtractions, and note which bits | |

@ are done in the result. On the final pass, this may subtract | |

@ too much from the dividend, but the result will be ok, since the | |

@ "bit" will have been shifted out at the bottom. | |

cmp dividend, divisor | |

subcs dividend, dividend, divisor | |

orrcs result, result, curbit | |

cmp dividend, divisor, lsr #1 | |

subcs dividend, dividend, divisor, lsr #1 | |

orrcs result, result, curbit, lsr #1 | |

cmp dividend, divisor, lsr #2 | |

subcs dividend, dividend, divisor, lsr #2 | |

orrcs result, result, curbit, lsr #2 | |

cmp dividend, divisor, lsr #3 | |

subcs dividend, dividend, divisor, lsr #3 | |

orrcs result, result, curbit, lsr #3 | |

cmp dividend, #0 @ Early termination? | |

movnes curbit, curbit, lsr #4 @ No, any more bits to do? | |

movne divisor, divisor, lsr #4 | |

bne Loop3 | |

Lgot_result: | |

mov r0, result | |

cmp ip, #0 | |

rsbmi r0, r0, #0 | |

RET pc, lr | |

Ldiv0: | |

str lr, [sp, #-4]! | |

bl SYM (__div0) | |

mov r0, #0 @ about as wrong as it could be | |

ldmia sp!, {pc}RETCOND | |

#endif /* L_divsi3 */ | |

#ifdef L_modsi3 | |

dividend .req r0 | |

divisor .req r1 | |

overdone .req r2 | |

curbit .req r3 | |

ip .req r12 | |

sp .req r13 | |

lr .req r14 | |

pc .req r15 | |

.text | |

.globl SYM (__modsi3) | |

.align 0 | |

SYM (__modsi3): | |

mov curbit, #1 | |

cmp divisor, #0 | |

rsbmi divisor, divisor, #0 @ Loops below use unsigned. | |

beq Ldiv0 | |

@ Need to save the sign of the dividend, unfortunately, we need | |

@ ip later on; this is faster than pushing lr and using that. | |

str dividend, [sp, #-4]! | |

cmp dividend, #0 | |

rsbmi dividend, dividend, #0 | |

cmp dividend, divisor | |

bcc Lgot_result | |

Loop1: | |

@ Unless the divisor is very big, shift it up in multiples of | |

@ four bits, since this is the amount of unwinding in the main | |

@ division loop. Continue shifting until the divisor is | |

@ larger than the dividend. | |

cmp divisor, #0x10000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #4 | |

movcc curbit, curbit, lsl #4 | |

bcc Loop1 | |

Lbignum: | |

@ For very big divisors, we must shift it a bit at a time, or | |

@ we will be in danger of overflowing. | |

cmp divisor, #0x80000000 | |

cmpcc divisor, dividend | |

movcc divisor, divisor, lsl #1 | |

movcc curbit, curbit, lsl #1 | |

bcc Lbignum | |

Loop3: | |

@ Test for possible subtractions. On the final pass, this may | |

@ subtract too much from the dividend, so keep track of which | |

@ subtractions are done, we can fix them up afterwards... | |

mov overdone, #0 | |

cmp dividend, divisor | |

subcs dividend, dividend, divisor | |

cmp dividend, divisor, lsr #1 | |

subcs dividend, dividend, divisor, lsr #1 | |

orrcs overdone, overdone, curbit, ror #1 | |

cmp dividend, divisor, lsr #2 | |

subcs dividend, dividend, divisor, lsr #2 | |

orrcs overdone, overdone, curbit, ror #2 | |

cmp dividend, divisor, lsr #3 | |

subcs dividend, dividend, divisor, lsr #3 | |

orrcs overdone, overdone, curbit, ror #3 | |

mov ip, curbit | |

cmp dividend, #0 @ Early termination? | |

movnes curbit, curbit, lsr #4 @ No, any more bits to do? | |

movne divisor, divisor, lsr #4 | |

bne Loop3 | |

@ Any subtractions that we should not have done will be recorded in | |

@ the top three bits of "overdone". Exactly which were not needed | |

@ are governed by the position of the bit, stored in ip. | |

@ If we terminated early, because dividend became zero, | |

@ then none of the below will match, since the bit in ip will not be | |

@ in the bottom nibble. | |

ands overdone, overdone, #0xe0000000 | |

beq Lgot_result | |

tst overdone, ip, ror #3 | |

addne dividend, dividend, divisor, lsr #3 | |

tst overdone, ip, ror #2 | |

addne dividend, dividend, divisor, lsr #2 | |

tst overdone, ip, ror #1 | |

addne dividend, dividend, divisor, lsr #1 | |

Lgot_result: | |

ldr ip, [sp], #4 | |

cmp ip, #0 | |

rsbmi dividend, dividend, #0 | |

RET pc, lr | |

Ldiv0: | |

str lr, [sp, #-4]! | |

bl SYM (__div0) | |

mov r0, #0 @ about as wrong as it could be | |

ldmia sp!, {pc}RETCOND | |

#endif /* L_modsi3 */ | |

#ifdef L_dvmd_tls | |

.globl SYM (__div0) | |

.align 0 | |

SYM (__div0): | |

RET pc, lr | |

#endif /* L_divmodsi_tools */ |