| OLD | NEW |
|---|
| (Empty) |
| 1 /* Check the values of some constants. | |
| 2 | |
| 3 Copyright 2000, 2001, 2002, 2003 Free Software Foundation, Inc. | |
| 4 | |
| 5 This file is part of the GNU MP Library. | |
| 6 | |
| 7 The GNU MP Library is free software; you can redistribute it and/or modify | |
| 8 it under the terms of the GNU Lesser General Public License as published by | |
| 9 the Free Software Foundation; either version 3 of the License, or (at your | |
| 10 option) any later version. | |
| 11 | |
| 12 The GNU MP Library is distributed in the hope that it will be useful, but | |
| 13 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
| 14 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public | |
| 15 License for more details. | |
| 16 | |
| 17 You should have received a copy of the GNU Lesser General Public License | |
| 18 along with the GNU MP Library. If not, see http://www.gnu.org/licenses/. */ | |
| 19 | |
| 20 #include <stdio.h> | |
| 21 #include <stdlib.h> | |
| 22 #include "gmp.h" | |
| 23 #include "tests.h" | |
| 24 | |
| 25 | |
| 26 #ifdef ULONG_MAX | |
| 27 char *ulong_max_def = "defined"; | |
| 28 #else | |
| 29 char *ulong_max_def = "not defined"; | |
| 30 #endif | |
| 31 #ifdef LONG_MAX | |
| 32 char *long_max_def = "defined"; | |
| 33 #else | |
| 34 char *long_max_def = "not defined"; | |
| 35 #endif | |
| 36 | |
| 37 #ifdef UINT_MAX | |
| 38 char *uint_max_def = "defined"; | |
| 39 #else | |
| 40 char *uint_max_def = "not defined"; | |
| 41 #endif | |
| 42 #ifdef INT_MAX | |
| 43 char *int_max_def = "defined"; | |
| 44 #else | |
| 45 char *int_max_def = "not defined"; | |
| 46 #endif | |
| 47 | |
| 48 #ifdef USHRT_MAX | |
| 49 char *ushrt_max_def = "defined"; | |
| 50 #else | |
| 51 char *ushrt_max_def = "not defined"; | |
| 52 #endif | |
| 53 #ifdef SHRT_MAX | |
| 54 char *shrt_max_def = "defined"; | |
| 55 #else | |
| 56 char *shrt_max_def = "not defined"; | |
| 57 #endif | |
| 58 | |
| 59 #include "gmp-impl.h" | |
| 60 #include "longlong.h" | |
| 61 | |
| 62 | |
| 63 #ifdef _LONG_LONG_LIMB | |
| 64 #define LL(l,ll) ll | |
| 65 #else | |
| 66 #define LL(l,ll) l | |
| 67 #endif | |
| 68 | |
| 69 #if __GMP_MP_SIZE_T_INT | |
| 70 #define SS(i,l) i | |
| 71 #else | |
| 72 #define SS(i,l) l | |
| 73 #endif | |
| 74 | |
| 75 | |
| 76 #define CHECK_LIMB_S(x, xname, y, yname) \ | |
| 77 do { \ | |
| 78 if ((x) != (y)) \ | |
| 79 { \ | |
| 80 printf (LL("%s == %lx, but %s == %lx\n", \ | |
| 81 "%s == %llx, but %s == %llx\n"), \ | |
| 82 xname, x, yname, y); \ | |
| 83 error = 1; \ | |
| 84 } \ | |
| 85 } while (0) | |
| 86 | |
| 87 #define CHECK_INT_S(x, xname, y, yname) \ | |
| 88 do { \ | |
| 89 if ((x) != (y)) \ | |
| 90 { \ | |
| 91 printf ("%s == %d, but %s == %d\n", xname, x, yname, y); \ | |
| 92 error = 1; \ | |
| 93 } \ | |
| 94 } while (0) | |
| 95 | |
| 96 | |
| 97 | |
| 98 #define CHECK_CONDITION_S(x, xname) \ | |
| 99 do { \ | |
| 100 if (!(x)) \ | |
| 101 { \ | |
| 102 printf ("%s is false\n", xname); \ | |
| 103 error = 1; \ | |
| 104 } \ | |
| 105 } while (0) | |
| 106 | |
| 107 | |
| 108 /* How many bits seem to work in the given type. */ | |
| 109 #define CALC_BITS(result, type) \ | |
| 110 do { \ | |
| 111 type n = 1; \ | |
| 112 result = 0; \ | |
| 113 while (n != 0) \ | |
| 114 { \ | |
| 115 n <<= 1; \ | |
| 116 result++; \ | |
| 117 } \ | |
| 118 } while (0) | |
| 119 | |
| 120 #define CHECK_BITS_S(constant, constant_name, type) \ | |
| 121 do { \ | |
| 122 int calculated; \ | |
| 123 CALC_BITS (calculated, type); \ | |
| 124 if (calculated != constant) \ | |
| 125 { \ | |
| 126 printf ("%s == %d, but calculated %d\n", \ | |
| 127 constant_name, constant, calculated); \ | |
| 128 error = 1; \ | |
| 129 } \ | |
| 130 } while (0) | |
| 131 | |
| 132 | |
| 133 #define CHECK_HIGHBIT_S(value, value_name, type, format) \ | |
| 134 do { \ | |
| 135 type n = value; \ | |
| 136 if (n == 0) \ | |
| 137 { \ | |
| 138 printf ("%s == 0\n", value_name); \ | |
| 139 error = 1; \ | |
| 140 } \ | |
| 141 n <<= 1; \ | |
| 142 if (n != 0) \ | |
| 143 { \ | |
| 144 printf ("%s << 1 = ", value_name); \ | |
| 145 printf (format, n); \ | |
| 146 printf (" != 0\n"); \ | |
| 147 error = 1; \ | |
| 148 } \ | |
| 149 } while (0) | |
| 150 | |
| 151 | |
| 152 #define CHECK_MAX_S(max_val, max_name, min_val, min_name, type, format) \ | |
| 153 do { \ | |
| 154 type maxval = max_val; \ | |
| 155 type minval = min_val; \ | |
| 156 type n = maxval; \ | |
| 157 n++; \ | |
| 158 if (n != minval) \ | |
| 159 { \ | |
| 160 printf ("%s + 1 = ", max_name); \ | |
| 161 printf (format, n); \ | |
| 162 printf (" != %s = ", min_name); \ | |
| 163 printf (format, minval); \ | |
| 164 printf ("\n"); \ | |
| 165 error = 1; \ | |
| 166 } \ | |
| 167 if (maxval <= minval) \ | |
| 168 { \ | |
| 169 printf ("%s = ", max_name); \ | |
| 170 printf (format, maxval); \ | |
| 171 printf (" <= %s = ", min_name); \ | |
| 172 printf (format, minval); \ | |
| 173 printf ("\n"); \ | |
| 174 error = 1; \ | |
| 175 } \ | |
| 176 } while (0) | |
| 177 | |
| 178 | |
| 179 #if HAVE_STRINGIZE | |
| 180 #define CHECK_LIMB(x,y) CHECK_LIMB_S (x, #x, y, #y) | |
| 181 #define CHECK_INT(x,y) CHECK_INT_S (x, #x, y, #y) | |
| 182 #define CHECK_CONDITION(x) CHECK_CONDITION_S (x, #x) | |
| 183 #define CHECK_BITS(c,t) CHECK_BITS_S (c, #c, t) | |
| 184 #define CHECK_MAX(m,n,t,f) CHECK_MAX_S (m, #m, n, #n, t, f) | |
| 185 #define CHECK_HIGHBIT(n,t,f) CHECK_HIGHBIT_S (n, #n, t, f) | |
| 186 #else | |
| 187 #define CHECK_LIMB(x,y) CHECK_LIMB_S (x, "x", y, "y") | |
| 188 #define CHECK_INT(x,y) CHECK_INT_S (x, "x", y, "y") | |
| 189 #define CHECK_CONDITION(x) CHECK_CONDITION_S (x, "x") | |
| 190 #define CHECK_BITS(c,t) CHECK_BITS_S (c, "c", t) | |
| 191 #define CHECK_MAX(m,n,t,f) CHECK_MAX_S (m, "m", n, "n", t, f) | |
| 192 #define CHECK_HIGHBIT(n,t,f) CHECK_HIGHBIT_S (n, "n", t, f) | |
| 193 #endif | |
| 194 | |
| 195 | |
| 196 /* The tests below marked "Bad!" fail on Cray T90 systems, where int, short | |
| 197 and mp_size_t are 48 bits or some such but don't wraparound in a plain | |
| 198 twos complement fashion. In particular, | |
| 199 | |
| 200 INT_HIGHBIT << 1 = 0xFFFFC00000000000 != 0 | |
| 201 INT_MAX + 1 = 35184372088832 != INT_MIN = -35184372088832 | |
| 202 | |
| 203 This is a bit bizarre, but doesn't matter because GMP doesn't rely on any | |
| 204 particular overflow behaviour for int or short, only for mp_limb_t. */ | |
| 205 | |
| 206 int | |
| 207 main (int argc, char *argv[]) | |
| 208 { | |
| 209 int error = 0; | |
| 210 | |
| 211 CHECK_INT (BYTES_PER_MP_LIMB, (int) sizeof(mp_limb_t)); | |
| 212 CHECK_INT (mp_bits_per_limb, BITS_PER_MP_LIMB); | |
| 213 CHECK_INT (__GMP_BITS_PER_MP_LIMB, BITS_PER_MP_LIMB); | |
| 214 | |
| 215 CHECK_BITS (BITS_PER_MP_LIMB, mp_limb_t); | |
| 216 CHECK_BITS (BITS_PER_ULONG, unsigned long); | |
| 217 | |
| 218 CHECK_HIGHBIT (GMP_LIMB_HIGHBIT, mp_limb_t, LL("0x%lX","0x%llX")); | |
| 219 CHECK_HIGHBIT (ULONG_HIGHBIT, unsigned long, "0x%lX"); | |
| 220 CHECK_HIGHBIT (UINT_HIGHBIT, unsigned int, "0x%X"); | |
| 221 CHECK_HIGHBIT (USHRT_HIGHBIT, unsigned short, "0x%hX"); | |
| 222 CHECK_HIGHBIT (LONG_HIGHBIT, long, "0x%lX"); | |
| 223 #if 0 /* Bad! */ | |
| 224 CHECK_HIGHBIT (INT_HIGHBIT, int, "0x%X"); | |
| 225 CHECK_HIGHBIT (SHRT_HIGHBIT, short, "0x%hX"); | |
| 226 #endif | |
| 227 | |
| 228 #if 0 /* Bad! */ | |
| 229 CHECK_MAX (LONG_MAX, LONG_MIN, long, "%ld"); | |
| 230 CHECK_MAX (INT_MAX, INT_MIN, int, "%d"); | |
| 231 CHECK_MAX (SHRT_MAX, SHRT_MIN, short, "%hd"); | |
| 232 #endif | |
| 233 CHECK_MAX (ULONG_MAX, 0, unsigned long, "%lu"); | |
| 234 CHECK_MAX (UINT_MAX, 0, unsigned int, "%u"); | |
| 235 CHECK_MAX (USHRT_MAX, 0, unsigned short, "%hu"); | |
| 236 #if 0 /* Bad! */ | |
| 237 CHECK_MAX (MP_SIZE_T_MAX, MP_SIZE_T_MIN, mp_size_t, SS("%d","%ld")); | |
| 238 #endif | |
| 239 | |
| 240 /* UHWtype should have at least enough bits for half a UWtype */ | |
| 241 { | |
| 242 int bits_per_UWtype, bits_per_UHWtype; | |
| 243 CALC_BITS (bits_per_UWtype, UWtype); | |
| 244 CALC_BITS (bits_per_UHWtype, UHWtype); | |
| 245 CHECK_CONDITION (2*bits_per_UHWtype >= bits_per_UWtype); | |
| 246 } | |
| 247 | |
| 248 ASSERT_ALWAYS_LIMB (MODLIMB_INVERSE_3); | |
| 249 { | |
| 250 mp_limb_t modlimb_inverse_3_calc; | |
| 251 binvert_limb (modlimb_inverse_3_calc, CNST_LIMB(3)); | |
| 252 ASSERT_ALWAYS_LIMB (modlimb_inverse_3_calc); | |
| 253 CHECK_LIMB (MODLIMB_INVERSE_3, modlimb_inverse_3_calc); | |
| 254 } | |
| 255 { | |
| 256 mp_limb_t MODLIMB_INVERSE_3_times_3 | |
| 257 = (MODLIMB_INVERSE_3 * CNST_LIMB(3)) & GMP_NUMB_MASK; | |
| 258 CHECK_LIMB (MODLIMB_INVERSE_3_times_3, CNST_LIMB(1)); | |
| 259 } | |
| 260 | |
| 261 { | |
| 262 mp_limb_t hi, lo; | |
| 263 hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_MAX_DIV3-1, | |
| 264 CNST_LIMB(3) << GMP_NAIL_BITS); | |
| 265 if (! (hi < 1)) | |
| 266 { | |
| 267 printf ("GMP_NUMB_CEIL_MAX_DIV3 too big\n"); | |
| 268 error = 1; | |
| 269 } | |
| 270 hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_MAX_DIV3, | |
| 271 CNST_LIMB(3) << GMP_NAIL_BITS); | |
| 272 if (! (hi >= 1)) | |
| 273 { | |
| 274 printf ("GMP_NUMB_CEIL_MAX_DIV3 too small\n"); | |
| 275 error = 1; | |
| 276 } | |
| 277 } | |
| 278 | |
| 279 { | |
| 280 mp_limb_t hi, lo; | |
| 281 hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_2MAX_DIV3-1, | |
| 282 CNST_LIMB(3) << GMP_NAIL_BITS); | |
| 283 if (! (hi < 2)) | |
| 284 { | |
| 285 printf ("GMP_NUMB_CEIL_2MAX_DIV3 too big\n"); | |
| 286 error = 1; | |
| 287 } | |
| 288 hi = refmpn_umul_ppmm (&lo, GMP_NUMB_CEIL_2MAX_DIV3, | |
| 289 CNST_LIMB(3) << GMP_NAIL_BITS); | |
| 290 if (! (hi >= 2)) | |
| 291 { | |
| 292 printf ("GMP_NUMB_CEIL_2MAX_DIV3 too small\n"); | |
| 293 error = 1; | |
| 294 } | |
| 295 } | |
| 296 | |
| 297 #ifdef PP_INVERTED | |
| 298 { | |
| 299 mp_limb_t pp_inverted_calc; | |
| 300 invert_limb (pp_inverted_calc, PP); | |
| 301 CHECK_LIMB (PP_INVERTED, pp_inverted_calc); | |
| 302 } | |
| 303 #endif | |
| 304 | |
| 305 if (argc >= 2 || error) | |
| 306 { | |
| 307 int bits; | |
| 308 | |
| 309 printf ("\n"); | |
| 310 printf ("After gmp.h,\n"); | |
| 311 printf (" ULONG_MAX %s\n", ulong_max_def); | |
| 312 printf (" LONG_MAX %s\n", long_max_def); | |
| 313 printf (" UINT_MAX %s\n", uint_max_def); | |
| 314 printf (" INT_MAX %s\n", int_max_def); | |
| 315 printf (" USHRT_MAX %s\n", ushrt_max_def); | |
| 316 printf (" SHRT_MAX %s\n", shrt_max_def); | |
| 317 printf ("\n"); | |
| 318 | |
| 319 #ifdef _CRAY | |
| 320 printf ("_CRAY is defined, so limits.h is being used\n"); | |
| 321 #endif | |
| 322 | |
| 323 printf ("ULONG_MAX %lX\n", ULONG_MAX); | |
| 324 printf ("ULONG_HIGHBIT %lX\n", ULONG_HIGHBIT); | |
| 325 printf ("LONG_MAX %lX\n", LONG_MAX); | |
| 326 printf ("LONG_MIN %lX\n", LONG_MIN); | |
| 327 | |
| 328 printf ("UINT_MAX %X\n", UINT_MAX); | |
| 329 printf ("UINT_HIGHBIT %X\n", UINT_HIGHBIT); | |
| 330 printf ("INT_MAX %X\n", INT_MAX); | |
| 331 printf ("INT_MIN %X\n", INT_MIN); | |
| 332 | |
| 333 printf ("USHRT_MAX %hX\n", USHRT_MAX); | |
| 334 printf ("USHRT_HIGHBIT %hX\n", USHRT_HIGHBIT); | |
| 335 printf ("SHRT_MAX %hX\n", SHRT_MAX); | |
| 336 printf ("SHRT_MIN %hX\n", SHRT_MIN); | |
| 337 | |
| 338 printf ("\n"); | |
| 339 printf ("Bits\n"); | |
| 340 CALC_BITS (bits, long); printf (" long %d\n", bits); | |
| 341 CALC_BITS (bits, int); printf (" int %d\n", bits); | |
| 342 CALC_BITS (bits, short); printf (" short %d\n", bits); | |
| 343 CALC_BITS (bits, unsigned long); printf (" unsigned long %d\n", bits); | |
| 344 CALC_BITS (bits, unsigned int); printf (" unsigned int %d\n", bits); | |
| 345 CALC_BITS (bits, unsigned short); printf (" unsigned short %d\n", bits); | |
| 346 CALC_BITS (bits, mp_size_t); printf (" mp_size_t %d\n", bits); | |
| 347 } | |
| 348 | |
| 349 if (error) | |
| 350 abort (); | |
| 351 | |
| 352 exit (0); | |
| 353 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 3050029:
[gcc] GCC 4.5.0=>4.5.1 (Closed)
Base URL: ssh://git@gitrw.chromium.org:9222/nacl-toolchain.git