int test__aeabi_drsub(double a, double b, double expected) { double actual = __aeabi_drsub(a, b); if (actual != expected) printf("error in __aeabi_drsub(%f, %f) = %f, expected %f\n", a, b, actual, expected); return actual != expected; }
int main () { unsigned char bytes[256]; int i; /* Table 2. Double-precision floating-point arithmetic. */ deq (__aeabi_dadd (dzero, done), done); deq (__aeabi_dadd (done, done), dtwo); deq (__aeabi_ddiv (dminus_four, dminus_two), dtwo); deq (__aeabi_ddiv (dminus_two, dtwo), dminus_one); deq (__aeabi_dmul (dtwo, dtwo), dfour); deq (__aeabi_dmul (dminus_one, dminus_two), dtwo); deq (__aeabi_dneg (dminus_one), done); deq (__aeabi_dneg (dfour), dminus_four); deq (__aeabi_drsub (done, dzero), dminus_one); deq (__aeabi_drsub (dtwo, dminus_two), dminus_four); deq (__aeabi_dsub (dzero, done), dminus_one); deq (__aeabi_dsub (dminus_two, dtwo), dminus_four); /* Table 3. Double-precision floating-point comparisons. */ ieq (__aeabi_dcmpeq (done, done), 1); ieq (__aeabi_dcmpeq (done, dzero), 0); ieq (__aeabi_dcmpeq (dNaN, dzero), 0); ieq (__aeabi_dcmpeq (dNaN, dNaN), 0); ieq (__aeabi_dcmplt (dzero, done), 1); ieq (__aeabi_dcmplt (done, dzero), 0); ieq (__aeabi_dcmplt (dzero, dzero), 0); ieq (__aeabi_dcmplt (dzero, dNaN), 0); ieq (__aeabi_dcmplt (dNaN, dNaN), 0); ieq (__aeabi_dcmple (dzero, done), 1); ieq (__aeabi_dcmple (done, dzero), 0); ieq (__aeabi_dcmple (dzero, dzero), 1); ieq (__aeabi_dcmple (dzero, dNaN), 0); ieq (__aeabi_dcmple (dNaN, dNaN), 0); ieq (__aeabi_dcmpge (dzero, done), 0); ieq (__aeabi_dcmpge (done, dzero), 1); ieq (__aeabi_dcmpge (dzero, dzero), 1); ieq (__aeabi_dcmpge (dzero, dNaN), 0); ieq (__aeabi_dcmpge (dNaN, dNaN), 0); ieq (__aeabi_dcmpgt (dzero, done), 0); ieq (__aeabi_dcmpgt (done, dzero), 1); ieq (__aeabi_dcmplt (dzero, dzero), 0); ieq (__aeabi_dcmpgt (dzero, dNaN), 0); ieq (__aeabi_dcmpgt (dNaN, dNaN), 0); ieq (__aeabi_dcmpun (done, done), 0); ieq (__aeabi_dcmpun (done, dzero), 0); ieq (__aeabi_dcmpun (dNaN, dzero), 1); ieq (__aeabi_dcmpun (dNaN, dNaN), 1); /* Table 4. Single-precision floating-point arithmetic. */ feq (__aeabi_fadd (fzero, fone), fone); feq (__aeabi_fadd (fone, fone), ftwo); feq (__aeabi_fdiv (fminus_four, fminus_two), ftwo); feq (__aeabi_fdiv (fminus_two, ftwo), fminus_one); feq (__aeabi_fmul (ftwo, ftwo), ffour); feq (__aeabi_fmul (fminus_one, fminus_two), ftwo); feq (__aeabi_fneg (fminus_one), fone); feq (__aeabi_fneg (ffour), fminus_four); feq (__aeabi_frsub (fone, fzero), fminus_one); feq (__aeabi_frsub (ftwo, fminus_two), fminus_four); feq (__aeabi_fsub (fzero, fone), fminus_one); feq (__aeabi_fsub (fminus_two, ftwo), fminus_four); /* Table 5. Single-precision floating-point comparisons. */ ieq (__aeabi_fcmpeq (fone, fone), 1); ieq (__aeabi_fcmpeq (fone, fzero), 0); ieq (__aeabi_fcmpeq (fNaN, fzero), 0); ieq (__aeabi_fcmpeq (fNaN, fNaN), 0); ieq (__aeabi_fcmplt (fzero, fone), 1); ieq (__aeabi_fcmplt (fone, fzero), 0); ieq (__aeabi_fcmplt (fzero, fzero), 0); ieq (__aeabi_fcmplt (fzero, fNaN), 0); ieq (__aeabi_fcmplt (fNaN, fNaN), 0); ieq (__aeabi_fcmple (fzero, fone), 1); ieq (__aeabi_fcmple (fone, fzero), 0); ieq (__aeabi_fcmple (fzero, fzero), 1); ieq (__aeabi_fcmple (fzero, fNaN), 0); ieq (__aeabi_fcmple (fNaN, fNaN), 0); ieq (__aeabi_fcmpge (fzero, fone), 0); ieq (__aeabi_fcmpge (fone, fzero), 1); ieq (__aeabi_fcmpge (fzero, fzero), 1); ieq (__aeabi_fcmpge (fzero, fNaN), 0); ieq (__aeabi_fcmpge (fNaN, fNaN), 0); ieq (__aeabi_fcmpgt (fzero, fone), 0); ieq (__aeabi_fcmpgt (fone, fzero), 1); ieq (__aeabi_fcmplt (fzero, fzero), 0); ieq (__aeabi_fcmpgt (fzero, fNaN), 0); ieq (__aeabi_fcmpgt (fNaN, fNaN), 0); ieq (__aeabi_fcmpun (fone, fone), 0); ieq (__aeabi_fcmpun (fone, fzero), 0); ieq (__aeabi_fcmpun (fNaN, fzero), 1); ieq (__aeabi_fcmpun (fNaN, fNaN), 1); /* Table 6. Floating-point to integer conversions. */ ieq (__aeabi_d2iz (dminus_one), -1); ueq (__aeabi_d2uiz (done), 1); leq (__aeabi_d2lz (dminus_two), -2LL); uleq (__aeabi_d2ulz (dfour), 4LL); ieq (__aeabi_f2iz (fminus_one), -1); ueq (__aeabi_f2uiz (fone), 1); leq (__aeabi_f2lz (fminus_two), -2LL); uleq (__aeabi_f2ulz (ffour), 4LL); /* Table 7. Conversions between floating types. */ feq (__aeabi_d2f (dtwo), ftwo); deq (__aeabi_f2d (fminus_four), dminus_four); /* Table 8. Integer to floating-point conversions. */ deq (__aeabi_i2d (-1), dminus_one); deq (__aeabi_ui2d (2), dtwo); deq (__aeabi_l2d (-1), dminus_one); deq (__aeabi_ul2d (2ULL), dtwo); feq (__aeabi_i2f (-1), fminus_one); feq (__aeabi_ui2f (2), ftwo); feq (__aeabi_l2f (-1), fminus_one); feq (__aeabi_ul2f (2ULL), ftwo); /* Table 9. Long long functions. */ leq (__aeabi_lmul (4LL, -1LL), -4LL); leq (__aeabi_llsl (2LL, 1), 4LL); leq (__aeabi_llsr (-1LL, 63), 1); leq (__aeabi_lasr (-1LL, 63), -1); ieq (__aeabi_lcmp (0LL, 1LL), -1); ieq (__aeabi_lcmp (0LL, 0LL), 0); ieq (__aeabi_lcmp (1LL, 0LL), 1); ieq (__aeabi_ulcmp (0LL, 1LL), -1); ieq (__aeabi_ulcmp (0LL, 0LL), 0); ieq (__aeabi_ulcmp (1LL, 0LL), 1); ieq (__aeabi_idiv (-550, 11), -50); ueq (__aeabi_uidiv (4000000000U, 1000000U), 4000U); for (i = 0; i < 256; i++) bytes[i] = i; #ifdef __ARMEB__ ieq (__aeabi_uread4 (bytes + 1), 0x01020304U); leq (__aeabi_uread8 (bytes + 3), 0x030405060708090aLL); ieq (__aeabi_uwrite4 (0x66778899U, bytes + 5), 0x66778899U); leq (__aeabi_uwrite8 (0x2030405060708090LL, bytes + 15), 0x2030405060708090LL); #else ieq (__aeabi_uread4 (bytes + 1), 0x04030201U); leq (__aeabi_uread8 (bytes + 3), 0x0a09080706050403LL); ieq (__aeabi_uwrite4 (0x99887766U, bytes + 5), 0x99887766U); leq (__aeabi_uwrite8 (0x9080706050403020LL, bytes + 15), 0x9080706050403020LL); #endif for (i = 0; i < 4; i++) ieq (bytes[5 + i], (6 + i) * 0x11); for (i = 0; i < 8; i++) ieq (bytes[15 + i], (2 + i) * 0x10); exit (0); }