Esempio n. 1
0
main()
{
	union { long long q; unsigned long v[2]; } a, b, q, r;
	char buf[300];
	extern long long __qdivrem(unsigned long long, unsigned long long,
	    unsigned long long *);

	for (;;) {
		printf("> ");
		if (fgets(buf, sizeof buf, stdin) == NULL)
			break;
		if (sscanf(buf, "%lu:%lu %lu:%lu",
			    &a.v[0], &a.v[1], &b.v[0], &b.v[1]) != 4 &&
		    sscanf(buf, "0x%lx:%lx 0x%lx:%lx",
			    &a.v[0], &a.v[1], &b.v[0], &b.v[1]) != 4) {
			printf("eh?\n");
			continue;
		}
		q.q = __qdivrem(a.q, b.q, &r.q);
		printf("%lx:%lx /%% %lx:%lx => q=%lx:%lx r=%lx:%lx\n",
		    a.v[0], a.v[1], b.v[0], b.v[1],
		    q.v[0], q.v[1], r.v[0], r.v[1]);
		printf("  = %lX%08lX / %lX%08lX => %lX%08lX\n\
  = %lX%08lX %% %lX%08lX => %lX%08lX\n",
		    a.v[0], a.v[1], b.v[0], b.v[1], q.v[0], q.v[1],
		    a.v[0], a.v[1], b.v[0], b.v[1], r.v[0], r.v[1]);
	}
	exit(0);
}
Esempio n. 2
0
/*
 * Divide two signed quads.
 * ??? if -1/2 should produce -1 on this machine, this code is wrong
 */
quad_t __divdi3(quad_t a, quad_t b)
{
    u_quad_t ua, ub, uq;
    int neg = 0;

    ua = a;
    ub = b;

    if (a < 0) {
        ua = -ua;
        neg = !neg;
    }

    if (b < 0) {
        ub = -ub;
        neg = !neg;
    }

    uq = __qdivrem(ua, ub, NULL);

    if (neg) {
        uq = -uq;
    }

    return uq;
}
Esempio n. 3
0
static int
eclock_gettime(struct todr_chip_handle *todr, struct timeval *tv)
{
    struct eclock_softc *sc = todr->cookie;
    struct _Tc *tc = sc->sc_dp;
    uint64_t free;
    int s;

    /*
     * 32bit processor, guard against interrupts in the middle of
     * reading this 64bit entity
     */
    /* BUGBUG Should read it "twice" to guard against rollover too. */
    s = splhigh();
    free = tc->FreeRunning;
    splx(s);

    /*
     * Big fight with the compiler here, it gets very confused by 64bits.
     */
#if 1
    /*
     * This is in C:
     */
    {
        uint64_t freeS, freeU;
        freeS = free / 10000000UL;
        freeU = free % 10000000UL;
        tv->tv_sec  = freeS;
        tv->tv_usec = freeU / 10;
#if 0
        printf("egt: s x%" PRIx64 " u x%lx (fs %" PRId64
               " fu %" PRId64 " f %" PRId64 ")\n",
               tv->tv_sec, tv->tv_usec, freeS, freeU, free);
#endif
    }
#else
    /*
     * And this is in assembly :-)
     */
    {
        u_quad_t r;
        u_quad_t d = __qdivrem(free,(u_quad_t)10000000,&r);
        uint32_t su, uu;
        su = (uint32_t)d;
        uu = (uint32_t)r;
        uu = uu / 10;	/* in usecs */
        tv->tv_sec  = su;
        tv->tv_usec = uu;
#if 0
        printf("egt: s x%" PRIx64 " u x%lx (fs %" PRId64
               " fu %" PRId64 " f %" PRId64 ")\n",
               tv->tv_sec, tv->tv_usec, d, r, free);
#endif
    }
#endif

    return 0;
}
Esempio n. 4
0
/*
 * Return remainder after dividing two unsigned quads.
 */
uint64 __umoddi3(uint64 a, uint64 b)
{
  MONA_ASSERT(sizeof(uint64) == 8);
  uint64 r;

  (void)__qdivrem(a, b, &r);
  return (r);
}
Esempio n. 5
0
/*
 * Return remainder after dividing two unsigned quads.
 */
u_quad_t
__umoddi3(u_quad_t a, u_quad_t b)
{
	u_quad_t r;

	(void)__qdivrem(a, b, &r);
	return (r);
}
Esempio n. 6
0
/*
 * Divide two signed quads.
 * ??? if -1/2 should produce -1 on this machine, this code is wrong
 */
quad_t
__divdi3(quad_t a, quad_t b)
{
	u_quad_t ua, ub, uq;
	int neg;

	if (a < 0)
		ua = -(u_quad_t)a, neg = 1;
	else
		ua = a, neg = 0;
	if (b < 0)
		ub = -(u_quad_t)b, neg ^= 1;
	else
		ub = b;
	uq = __qdivrem(ua, ub, (u_quad_t *)0);
	return (neg ? -uq : uq);
}
Esempio n. 7
0
/*
 * Return remainder after dividing two signed quads.
 *
 * XXX
 * If -1/2 should produce -1 on this machine, this code is wrong.
 */
quad_t
__moddi3(quad_t a, quad_t b)
{
	u_quad_t ua, ub, ur;
	int neg;

	if (a < 0)
		ua = -(u_quad_t)a, neg = 1;
	else
		ua = a, neg = 0;
	if (b < 0)
		ub = -(u_quad_t)b;
	else
		ub = b;
	(void)__qdivrem(ua, ub, &ur);
	return (neg ? -ur : ur);
}
Esempio n. 8
0
/*
 * Return remainder after dividing two signed quads.
 *
 * XXX	we assume a % b < 0 iff a < 0, but this is actually machine-dependent.
 */
quad_t
__moddi3(quad_t a, quad_t b)
{
	u_quad_t ua, ub, ur;
	int neg = 0;

	ua = a;
	ub = b;

	if (a < 0)
		ua = -ua, neg ^= 1;
	if (b < 0)
		ub = -ub;
	(void)__qdivrem(ua, ub, &ur);
	if (neg)
		ur = -ur;
	return (ur);
}
Esempio n. 9
0
/*
 * Return remainder after dividing two signed long longs.
 *
 * XXX	we assume a % b < 0 iff a < 0, but this is actually machine-dependent.
 */
long long
__moddi3(long long a, long long b)
{
	unsigned long long ua, ub, ur;
	int neg = 0;

	ua = a;
	ub = b;

	if (a < 0)
		ua = -ua, neg ^= 1;
	if (b < 0)
		ub = -ub;
	(void)__qdivrem(ua, ub, &ur);
	if (neg)
		ur = -ur;
	return (ur);
}
Esempio n. 10
0
/*
 * Divide two signed quads.
 * ??? if -1/2 should produce -1 on this machine, this code is wrong
 */
quad_t
__divdi3(quad_t a, quad_t b)
{
	u_quad_t ua, ub, uq;
	int neg = 0;

	ua = a;
	ub = b;

	if (a < 0)
		ua = -ua, neg ^= 1;
	if (b < 0)
		ub = -ub, neg ^= 1;

	uq = __qdivrem(ua, ub, (u_quad_t *)0);
	if (neg)
		uq = - uq;
	return uq;
}
Esempio n. 11
0
/*
 * Divide two unsigned quads.
 */
u_quad_t
__udivdi3(u_quad_t a, u_quad_t b)
{

	return (__qdivrem(a, b, (u_quad_t *)0));
}