/* Generic unsigned 32 bit division implementation. | |

Copyright (C) 2009-2022 Free Software Foundation, Inc. | |

Contributed by Embecosm on behalf of Adapteva, Inc. | |

This file is part of GCC. | |

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 3, or (at your option) any | |

later version. | |

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. | |

Under Section 7 of GPL version 3, you are granted additional | |

permissions described in the GCC Runtime Library Exception, version | |

3.1, as published by the Free Software Foundation. | |

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

a copy of the GCC Runtime Library Exception along with this program; | |

see the files COPYING3 and COPYING.RUNTIME respectively. If not, see | |

<http://www.gnu.org/licenses/>. */ | |

typedef union { unsigned int i; float f; } fu; | |

unsigned int __udivsi3 (unsigned int a, unsigned int b); | |

unsigned int | |

__udivsi3 (unsigned int a, unsigned int b) | |

{ | |

unsigned int d, t, s0, s1, s2, r0, r1; | |

fu u0, u1, u2, u1b, u2b; | |

if (b > a) | |

return 0; | |

if ((int) b < 0) | |

return 1; | |

/* Assuming B is nonzero, compute S0 such that 0 <= S0, | |

(B << S0+1) does not overflow, | |

A < 4.01 * (B << S0), with S0 chosen as small as possible | |

without taking to much time calculating. */ | |

#ifdef CONVERT_UNSIGNED | |

u0.f = a; | |

u1.f = b; | |

#else /* !CONVERT_UNSIGNED */ | |

u0.f = (int) a; | |

u1.f = (int) b; | |

#ifdef CONCISE | |

if ((int) a < 0) | |

u0.i = (a >> 8) - 0x00800000 + 0x3f800000 + (31 << 23); | |

#else /* To use flag setting / cmove, this can be written as: */ | |

{ | |

unsigned c = 0xff800000 - 0x4f000000; | |

t = (int)a >> 8; | |

if (t >= c) | |

u0.i = (t - c); | |

} | |

#endif | |

#endif /* !CONVERT_UNSIGNED */ | |

s0 = u0.i + 1 /* Compensate for rounding errors. */ | |

- 0x00800000 /* adjust by one */ ; | |

s0 = s0 - u1.i; | |

s0 = (int)s0 >= 0 ? s0 : 0; | |

s0 >>= 23; | |

b <<= s0; | |

r1 = 0; | |

r0 = 1 << s0; | |

a = ((t=a) - b); | |

if (a <= t) | |

{ | |

r1 += r0; | |

a = ((t=a) - b); | |

if (a <= t) | |

do { | |

r1 += r0; | |

a = ((t=a) - b); | |

} while (a <= t); | |

} | |

a += b; | |

d = b - 1; | |

#define STEP(n) case n: a += a; t = a - d; if (t <= a) a = t; | |

switch (s0) | |

{ | |

STEP (31) | |

STEP (30) | |

STEP (29) | |

STEP (28) | |

STEP (27) | |

STEP (26) | |

STEP (25) | |

STEP (24) | |

STEP (23) | |

STEP (22) | |

STEP (21) | |

STEP (20) | |

STEP (19) | |

STEP (18) | |

STEP (17) | |

STEP (16) | |

STEP (15) | |

STEP (14) | |

STEP (13) | |

STEP (12) | |

STEP (11) | |

STEP (10) | |

STEP (9) | |

STEP (8) | |

STEP (7) | |

STEP (6) | |

STEP (5) | |

STEP (4) | |

STEP (3) | |

STEP (2) | |

STEP (1) | |

case 0: ; | |

} | |

r0 = r1 | (r0-1 & a); | |

return r0; | |

} |