1 /* 2 * ppc64_helpers.h 3 * Copyright (C) 2016-2017 Will Schmidt <will_schmidt (at) vnet.ibm.com> 4 * 5 * This file contains helper functions for the ISA 3.0 test suite. 6 */ 7 8 /* 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License V2 11 * as published by the Free Software Foundation 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 */ 22 23 #include "tests/malloc.h" // memalign32 24 25 typedef uint64_t HWord_t; 26 27 #if defined (DEBUG_ARGS_BUILD) 28 #define AB_DPRINTF(fmt, args...) do { fprintf(stderr, fmt , ##args); } while (0) 29 #else 30 #define AB_DPRINTF(fmt, args...) do { } while (0) 31 #endif 32 33 /* Exhaustive tests? 34 * Due to the excessive size of the test results, allow a #ifdef to 35 * enable/disable most of the input values. 36 * Off by default. 37 */ 38 // #define EXHAUSTIVE_TESTS 1 39 40 41 #define ALLCR "cr0","cr1","cr2","cr3","cr4","cr5","cr6","cr7" 42 43 #define SET_CR(_arg) \ 44 __asm__ __volatile__ ("mtcr %0" : : "b"(_arg) : ALLCR ); 45 46 #define SET_CR0_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x80,%0 " : : "b" (_arg):"cr0"); 47 #define SET_CR1_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x40,%0 " : : "b" (_arg):"cr1"); 48 #define SET_CR2_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x20,%0 " : : "b" (_arg):"cr2"); 49 #define SET_CR3_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x10,%0 " : : "b" (_arg):"cr3"); 50 #define SET_CR4_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x08,%0 " : : "r" (_arg):"cr4"); 51 #define SET_CR5_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x04,%0 " : : "r" (_arg):"cr5"); 52 #define SET_CR6_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x02,%0 " : : "r" (_arg):"cr6"); 53 #define SET_CR7_FIELD(_arg) __asm__ __volatile__ ("mtocrf 0x01,%0 " : : "r" (_arg):"cr7"); 54 55 #define SET_XER(_arg) \ 56 __asm__ __volatile__ ("mtxer %0" : : "b"(_arg) : "xer" ); 57 58 #define GET_CR(_lval) \ 59 __asm__ __volatile__ ("mfcr %0" : "=b"(_lval) ) 60 61 #define GET_XER(_lval) \ 62 __asm__ __volatile__ ("mfxer %0" : "=b"(_lval) ) 63 64 #define SET_CR_ZERO \ 65 SET_CR(0) 66 67 #define SET_FPSCR_ZERO \ 68 do { \ 69 double _d = 0.0; \ 70 __asm__ __volatile__ ("mtfsf 0xFF, %0" : : "f"(_d) ); \ 71 } while (0); 72 73 #define GET_FPSCR(_arg) \ 74 __asm__ __volatile__ ("mffs %0" : "=f"(_arg) ); 75 76 /* The bit definitions for the FPSCR are as follows. 77 Bit(s) Description 78 0:31 Reserved 79 32 Floating-Point Exception Summary (FX) 80 33 Floating-Point Enabled Exception Summary (FEX) 81 34 Floating-Point Invalid Operation Exception Summary (VX) 82 35 Floating-Point Overflow Exception (OX) 83 36 Floating-Point Underflow Exception (UX) 84 37 Floating-Point Zero Divide Exception (ZX) 85 38 Floating-Point Inexact Exception (XX) 86 39 Floating-Point Invalid Operation Exception (SNaN) (VXSNAN) 87 40 Floating-Point Invalid Operation Exception ( - ) (VXISI) 88 41 Floating-Point Invalid Operation Exception ( ) (VXIDI) 89 42 Floating-Point Invalid Operation Exception (0 0) (VXZDZ) 90 43 Floating-Point Invalid Operation Exception ( 0) (VXIMZ) 91 44 Floating-Point Invalid Operation Exception (Invalid Compare) (VXVC) 92 45 Floating-Point Fraction Rounded (FR) 93 46 Floating-Point Fraction Inexact (FI) 94 47:51 Floating-Point Result Flags (FPRF) 95 47 Floating-Point Result Class Descriptor (C) 96 48:51 Floating-Point Condition Code (FPCC) 97 48 Floating-Point Less Than or Negative (FL or <) 98 49 Floating-Point Greater Than or Positive (FG or >) 99 50 Floating-Point Equal or Zero (FE or =) 100 51 Floating-Point Unordered or NaN (FU or ?) 101 52 Reserved 102 53 Floating-Point Invalid Operation Exception (Software-Defined Condition) (VXSOFT) 103 54 Floating-Point Invalid Operation Exception (Invalid Square Root) (VXSQRT) 104 55 Floating-Point Invalid Operation Exception (Invalid Integer Convert) (VXCVI) 105 56 Floating-Point Invalid Operation Exception Enable (VE) 106 57 Floating-Point Overflow Exception Enable (OE) 107 58 Floating-Point Underflow Exception Enable (UE) 108 59 Floating-Point Zero Divide Exception Enable (ZE) 109 60 Floating-Point Inexact Exception Enable (XE) 110 61 Floating-Point Non-IEEE Mode (NI) 111 62:63 Floating-Point Rounding Control (RN) 112 00 Round to Nearest 113 01 Round toward Zero 114 10 Round toward +Infinity 115 11 Round toward -Infinity 116 */ 117 /* NOTE, currently Valgrind only tracks the rounding mode, C and FPCC fields in the 118 * FPSCR register. 119 */ 120 121 static char * fpscr_strings[] = { 122 " 0-RSVD", " 1-RSVD", " 2-RSVD", " 3-RSVD", " 4-RSVD", " 5-RSVD", " 6-RSVD", 123 " 7-RSVD", " 8-RSVD", " 9-RSVD", "10-RSVD", "11-RSVD", "12-RSVD", "13-RSVD", 124 "14-RSVD", "15-RSVD", "16-RSVD", "17-RSVD", "18-RSVD", "19-RSVD", "20-RSVD", 125 "21-RSVD", "22-RSVD", "23-RSVD", "24-RSVD", "25-RSVD", "26-RSVD", "27-RSVD", 126 "28-RSVD", "29-DRN0", "30-DRN1", "31-DRN2", 127 /* 32 */ "FX", "FEX", "VX", 128 /* 35 */ "OX", "UX", "ZX", "XX", "VXSNAN", 129 /* 40 */ "VXISI (inf-inf)", "VXIDI (inf/inf)", "VXZDZ (0/0)", 130 /* 43 */ "VXIMZ (inf*0)", "VXVC", 131 /* 45 */ "FR", "FI", 132 /* 47 */ "FPRF-C", "FPCC-FL", "FPCC-FG", 133 /* 50 */ "FPCC-FE", "FPCC-FU", 134 /* 52 */ "52-RSVD", "FXSOFT", "VXSQRT", 135 /* 55 */ "VXCVI", "VE", "OE", "UE", "ZE", 136 /* 60 */ "XE", "NI", "RN-bit62", "RN-bit63" 137 }; 138 139 #define FPCC_C_BIT (0x1 << (63-47)) 140 #define FPCC_FL_BIT (0x1 << (63-48)) 141 #define FPCC_FG_BIT (0x1 << (63-49)) 142 #define FPCC_FE_BIT (0x1 << (63-50)) 143 #define FPCC_FU_BIT (0x1 << (63-51)) 144 #define FPCC_FPRF_MASK FPCC_C_BIT|FPCC_FL_BIT|FPCC_FG_BIT|FPCC_FE_BIT|FPCC_FU_BIT 145 146 #define FPSCR_RN_BIT62 (0x1 << (63-62)) 147 #define FPSCR_RN_BIT63 (0x1 << (63-63)) 148 149 #define CRFIELD_BIT0 0x8 150 #define CRFIELD_BIT1 0x4 151 #define CRFIELD_BIT2 0x2 152 #define CRFIELD_BIT3 0x1 153 154 /* dissect_cr*: 155 * display the condition register bits in a 156 * human readable format. 157 */ 158 159 inline int cr_overflow_set(unsigned this_cr) { 160 return (this_cr & CRFIELD_BIT3); 161 } 162 163 inline int cr_zero_set(unsigned this_cr) { 164 return (this_cr & CRFIELD_BIT2); 165 } 166 167 inline int cr_positive_set(unsigned this_cr) { 168 return (this_cr & CRFIELD_BIT1); 169 } 170 171 inline int cr_negative_set(unsigned this_cr) { 172 return (this_cr & CRFIELD_BIT0); 173 } 174 175 /* __dissect_cr takes a bitfield directly, not the full condition register. 176 * This is a helper for dissect_cr_rn. 177 */ 178 inline static void __dissect_cr(unsigned this_cr) { 179 if (cr_negative_set(this_cr)) 180 printf("%s(LT)", verbose ? " 0x1=Negative" : ""); 181 182 if (cr_positive_set(this_cr)) 183 printf("%s(GT)", verbose ? " 0x2=Positive" : ""); 184 185 if (cr_zero_set(this_cr)) 186 printf("%s(EQ)", verbose ? " 0x4=Zero" : ""); 187 188 if (cr_overflow_set(this_cr)) 189 printf("%s(SO)", verbose ? " 0x8=Overflow" : ""); 190 } 191 192 /* Extract one CR field */ 193 static int extract_cr_rn(unsigned long local_cr,unsigned long rn) { 194 unsigned int masked_cr; 195 unsigned long shifted_value; 196 197 shifted_value = local_cr >> ( ( (7 - rn) * 4 ) ); 198 masked_cr = shifted_value & 0xf; 199 return masked_cr; 200 } 201 202 /* Display one CR field */ 203 static void dissect_cr_rn(unsigned long local_cr, unsigned long rn) { 204 unsigned int masked_cr; 205 206 masked_cr = extract_cr_rn(local_cr, rn); 207 __dissect_cr(masked_cr); 208 } 209 210 /* Display all of the CR fields... */ 211 static void dissect_cr(unsigned long local_cr) { 212 unsigned int crn; 213 214 for (crn = 0; crn < 8; crn++) { 215 dissect_cr_rn(local_cr, crn); 216 } 217 } 218 219 /* dissect the fpscr bits that are valid under valgrind. 220 * Valgrind tracks the C (FPSCR[47]), FPCC (FPSCR[48:51) 221 * DRN (FPSCR[29:31]) and RN (FPSCR[62:63]). 222 */ 223 static void dissect_fpscr_valgrind(unsigned long local_fpscr) { 224 int i; 225 long mybit; 226 227 /* Print DRN fields */ 228 for (i = 29; i < 32; i++) { 229 mybit = 1LL << (63 - i); 230 if (mybit & local_fpscr) { 231 printf(" %s",fpscr_strings[i]); 232 } 233 } 234 235 /* Print C and FPCC fields */ 236 for (i = 47; i < 52; i++) { 237 mybit = 1LL << (63 - i); 238 if (mybit & local_fpscr) { 239 printf(" %s",fpscr_strings[i]); 240 } 241 } 242 243 /* Print RN field */ 244 for (i = 62; i < 64; i++) { 245 mybit = 1LL << (63 - i); 246 if (mybit & local_fpscr) { 247 printf(" %s",fpscr_strings[i]); 248 } 249 } 250 } 251 252 /* dissect the fpscr bits. 253 * This prints the entire FPSCR field. This is only called under higher 254 * verbosities, as valgrind does not track most of these bits. 255 */ 256 static void dissect_fpscr_raw(unsigned long local_fpscr) { 257 /* Due to the additional involved logic, the rounding mode (RN) bits 61-62 258 * are handled within dissect_fpscr_rounding_mode(). */ 259 int i; 260 long mybit; 261 262 for (i = 0; i < 61; i++) { 263 /* also note that the bit numbering is backwards. */ 264 mybit = 1LL << (63 - i); 265 if (mybit & local_fpscr) { 266 printf(" %s", fpscr_strings[i]); 267 } 268 } 269 } 270 271 static void dissect_fpscr(unsigned long local_fpscr) { 272 if (verbose > 1) { 273 printf(" [[ fpscr:%lx ]] ", local_fpscr); 274 dissect_fpscr_raw(local_fpscr); 275 } else { 276 dissect_fpscr_valgrind(local_fpscr); 277 } 278 } 279 280 /* Display the rounding mode */ 281 static void dissect_fpscr_rounding_mode(unsigned long local_fpscr) { 282 /* special case handing for the rounding mode round-nearest (RN) bits. 62:63 */ 283 printf("Rounding Mode: "); 284 285 if (local_fpscr & FPSCR_RN_BIT62) 286 if (local_fpscr & FPSCR_RN_BIT63) 287 /* 0b11 */ printf("RN-to--INF"); 288 else 289 /* 0b10 */ printf("RN-to-+INF"); 290 else 291 if (local_fpscr & FPSCR_RN_BIT63) 292 /* 0b01 */ printf("RN-to-Nearest"); 293 else 294 /* 0b00 */ printf("RN-to-Zero"); 295 } 296 297 /* 298 * Arithmetic, rounding, and Convert From Integer instructions will set 299 * bits in the FPCC field to indicate the class of the result. 300 * The table is described as follows; 301 flags / Result value class 302 C < > = ? 303 1 0 0 0 1 Quiet NaN 304 0 1 0 0 1 -Infinity 305 0 1 0 0 0 -Normalized Number 306 1 1 0 0 0 -Denormalized Number 307 1 0 0 1 0 -Zero 308 0 0 0 1 0 +Zero 309 1 0 1 0 0 +Denormalized Number 310 0 0 1 0 0 +Normalized Number 311 0 0 1 0 1 +Infinity 312 */ 313 314 static void dissect_fpscr_result_value_class(unsigned long local_fpscr) { 315 if (local_fpscr & FPCC_C_BIT) { 316 if (local_fpscr & FPCC_FL_BIT) 317 printf("-Denormalized"); 318 319 else if (local_fpscr & FPCC_FG_BIT) 320 printf("+Denormalized"); 321 322 else if (local_fpscr & FPCC_FE_BIT) 323 printf("-Zero "); 324 325 else if (local_fpscr & FPCC_FU_BIT) 326 printf("Quiet NaN "); 327 328 } else { 329 if (local_fpscr & FPCC_FL_BIT) { 330 if (local_fpscr & FPCC_FU_BIT) 331 printf("-Infinity "); 332 333 else 334 printf("-Normalized "); 335 336 } else if (local_fpscr & FPCC_FG_BIT) { 337 if (local_fpscr & FPCC_FU_BIT) 338 printf("+Infinity "); 339 340 else 341 printf("+Normalized "); 342 343 if (local_fpscr & FPCC_FE_BIT) 344 printf("+Zero "); 345 } 346 } 347 } 348 349 /* Interpret the fields in the FPCC as they apply to the DCMX checks. 350 * The 'Match' indicator will typically be evaluated by the caller. 351 * 352 * DMCX: 353 * DCMX bit / 0x value / Data Class 354 * 0 0x01 NaN 355 * 1 0x02 +Infinity 356 * 2 0x04 -Infinity 357 * 3 0x08 +Zero 358 * 4 0x10 -Zero 359 * 5 0x20 +Denormal 360 * 6 0x40 -Denormal 361 * 7 0x7f ALL bits set. 362 */ 363 364 static void dissect_fpscr_dcmx_indicator(unsigned long local_fpscr) { 365 if (verbose > 2) printf("fpscr_cc:%lx ", local_fpscr & (FPCC_FPRF_MASK) ); 366 367 // See if the data class of the src value matches the set DCMX bits. 368 if (verbose > 1) printf("%s ", (local_fpscr&FPCC_FE_BIT) ? "Match":""); 369 370 // Display the sign bit of the src value. 371 if (verbose > 1) printf("SRC sign:%s ", (local_fpscr&FPCC_FL_BIT) ? "-" : "+"); 372 373 // The src value can be either a SP or DP value, this indicates 374 // if it is a valid SP value. 375 if (verbose > 1) printf("%s ", (local_fpscr&FPCC_FE_BIT) ? "SP" : ""); 376 } 377 378 /* dissect_xer helpers*/ 379 static char * xer_strings[] = { 380 " 0-RSVD", " 1-RSVD", " 2-RSVD", " 3-RSVD", " 4-RSVD", " 5-RSVD", " 6-RSVD", 381 " 7-RSVD", " 8-RSVD", " 9-RSVD", "10-RSVD", "11-RSVD", "12-RSVD", "13-RSVD", 382 "14-RSVD", "15-RSVD", "16-RSVD", "17-RSVD", "18-RSVD", "19-RSVD", 383 "20-RSVD", "21-RSVD", "22-RSVD", "23-RSVD", "24-RSVD", "25-RSVD", 384 "26-RSVD", "27-RSVD", "28-RSVD", "29-RSVD", "30-RSVD", "31-RSVD", 385 /* 32 */ "SO", "OV", "CA", 386 /* 35 */ "35-RSVD", "36-RSVD", "37-RSVD", "38-RSVD", "39-RSVD", 387 /* 40 */ "40-RSVD", "41-RSVD", "42-RSVD", "43-RSVD", 388 /* 44 */ "OV32", "CA32", 389 /* 46 */ "46-RSVD", "47-RSVD", "48-RSVD", "49-RSVD", "50-RSVD", "51-RSVD", 390 "52-RSVD", "53-RSVD", "54-RSVD", "55-RSVD", "56-RSVD", 391 /* 57:63 # bytes transferred by a Load/Store String Indexed instruction. */ 392 "LSI/SSI-0", "LSI/SSI-1", "LSI/SSI-2", "LSI/SSI-3", 393 "LSI/SSI-4", "LSI/SSI-5", "LSI/SSI-6", 394 }; 395 396 /* Dissect the XER register contents. 397 */ 398 static void dissect_xer_raw(unsigned long local_xer) { 399 int i; 400 long mybit; 401 402 for (i = 0; i <= 63; i++) { 403 mybit = 1ULL << (63 - i); /* compensate for reversed bit numbering. */ 404 if (mybit & local_xer) 405 printf(" %s", xer_strings[i]); 406 } 407 } 408 409 /* */ 410 static void dissect_xer(unsigned long local_xer) { 411 if (verbose > 1) 412 printf(" [[ xer:%lx ]]", local_xer); 413 dissect_xer_raw(local_xer); 414 } 415 416 417 /* DFP helpers for bcd-to-dpd, dpd-to-bcd, misc. 418 * pulled from vex/.../host_generic_simd64.c 419 */ 420 /*------------------------------------------------------------------*/ 421 /* Decimal Floating Point (DFP) helper functions */ 422 /*------------------------------------------------------------------*/ 423 #define NOT( x ) ( ( ( x ) == 0) ? 1 : 0) 424 #define GET( x, y ) ( ( ( x ) & ( 0x1UL << ( y ) ) ) >> ( y ) ) 425 #define PUT( x, y ) ( ( x )<< ( y ) ) 426 427 static unsigned long dpb_to_bcd( unsigned long chunk ) 428 { 429 int a, b, c, d, e, f, g, h, i, j, k, m; 430 int p, q, r, s, t, u, v, w, x, y; 431 unsigned long value; 432 433 /* convert 10 bit densely packed BCD to BCD */ 434 p = GET( chunk, 9 ); 435 q = GET( chunk, 8 ); 436 r = GET( chunk, 7 ); 437 s = GET( chunk, 6 ); 438 t = GET( chunk, 5 ); 439 u = GET( chunk, 4 ); 440 v = GET( chunk, 3 ); 441 w = GET( chunk, 2 ); 442 x = GET( chunk, 1 ); 443 y = GET( chunk, 0 ); 444 445 /* The BCD bit values are given by the following boolean equations.*/ 446 a = ( NOT(s) & v & w ) | ( t & v & w & s ) | ( v & w & NOT(x) ); 447 b = ( p & s & x & NOT(t) ) | ( p & NOT(w) ) | ( p & NOT(v) ); 448 c = ( q & s & x & NOT(t) ) | ( q & NOT(w) ) | ( q & NOT(v) ); 449 d = r; 450 e = ( v & NOT(w) & x ) | ( s & v & w & x ) | ( NOT(t) & v & x & w ); 451 f = ( p & t & v & w & x & NOT(s) ) | ( s & NOT(x) & v ) | ( s & NOT(v) ); 452 g = ( q & t & w & v & x & NOT(s) ) | ( t & NOT(x) & v ) | ( t & NOT(v) ); 453 h = u; 454 i = ( t & v & w & x ) | ( s & v & w & x ) | ( v & NOT(w) & NOT(x) ); 455 j = ( p & NOT(s) & NOT(t) & w & v ) | ( s & v & NOT(w) & x ) 456 | ( p & w & NOT(x) & v ) | ( w & NOT(v) ); 457 k = ( q & NOT(s) & NOT(t) & v & w ) | ( t & v & NOT(w) & x ) 458 | ( q & v & w & NOT(x) ) | ( x & NOT(v) ); 459 m = y; 460 461 value = PUT(a, 11) | PUT(b, 10) | PUT(c, 9) | PUT(d, 8) | PUT(e, 7) 462 | PUT(f, 6) | PUT(g, 5) | PUT(h, 4) | PUT(i, 3) | PUT(j, 2) 463 | PUT(k, 1) | PUT(m, 0); 464 return value; 465 } 466 #undef NOT 467 #undef GET 468 #undef PUT 469 470 471 typedef union dfp_union { 472 _Decimal128 dec_val128; 473 struct { 474 #if defined(VGP_ppc64le_linux) 475 unsigned long vall; 476 unsigned long valu; 477 #else 478 unsigned long valu; 479 unsigned long vall; 480 #endif 481 } u128; 482 } dfp_val_t; 483 484 /* Based on and enhanced from the dfp128_vals table in test_dfp5.c. 485 * Todo: Refine/refactor and turn into a build_table function. 486 */ 487 488 static unsigned long dfp128_vals[] = { 489 #ifdef EXHAUSTIVE_TESTS 490 // Some finite numbers 491 0x2208000000000000ULL, 0x0000000000000001ULL, // 1 *10^0 492 0xa208800000000000ULL, 0x0000000000000001ULL, // -1 *10^1 493 0x0000000000000000ULL, 0x0000000000000001ULL, // 1 *10^-6176. (smallest exp) 494 0x43ffc00000000000ULL, 0x0000000000000001ULL, // 1 *10^6111 495 0x6fffc00000000000ULL, 0x0000000000000001ULL, // foo *10^2015. 496 0x67ffc00000000000ULL, 0x0000000000000001ULL, // foo *10^-2081. 497 0x77ffc00000000000ULL, 0x0000000000000001ULL, // 1 *10^6111 (largest exp) 498 0x77ffffffffffffffULL, 0xffffffffffffffffULL, // max possible value *10^6111 (largest exp) 499 0x0000000000000000ULL, 0x0000000000000001ULL, // min possible value 1 *10^-6176. (smallest exp) 500 0x8000000000000000ULL, 0x0000000000000001ULL, // -1 *10^-6176. (smallest exp) 501 502 /* data bits sprinkled across the significand field. */ 503 0xa208800001000000ULL, 0x0000000000010000ULL, //-foo *10^1 504 0xa208800000000100ULL, 0x0000000000000100ULL, //-foo *10^1 505 0xa208800000000000ULL, 0x0000100000000000ULL, //-foo *10^1 506 0xa208800000000000ULL, 0x0000000001000000ULL, //-foo *10^1 507 0xa208800000000000ULL, 0x0000000000000001ULL, //-foo *10^1 508 509 // pre-existing dfp128 values: 510 0x2207c00000000000ULL, 0x0000000000000e50ULL, // foo * 10^-1 511 0x2207c00000000000ULL, 0x000000000014c000ULL, // foo * 10^-1 512 0xa207c00000000000ULL, 0x00000000000000e0ULL, // foo * 10^-1 513 0x2206c00000000000ULL, 0x00000000000000cfULL, // foo * 10^-5 514 0xa205c00000000000ULL, 0x000000010a395bcfULL, // foo * 10^-9 515 0x6209400000fd0000ULL, 0x00253f1f534acdd4ULL, // foo * 10^-4091 516 0x000400000089b000ULL, 0x0a6000d000000049ULL, // very small number // foo * 10^-6160 517 518 // flavors of zero 519 0x2208000000000000ULL, 0x0000000000000000ULL, // 0*10^256 520 0xa208000000000000ULL, 0x0000000000000000ULL, // -0*10^0 521 0xa248000000000000ULL, 0x0000000000000000ULL, // 0*10^256 522 523 // flavors of NAN 524 0x7c00000000000000ULL, 0x0000000000000000ULL, // quiet 525 0xfc00000000000000ULL, 0xc00100035b007700ULL, // NAN 526 0x7e00000000000000ULL, 0xfe000000d0e0a0d0ULL, // signaling NAN 527 528 // flavors of Infinity 529 0x7800000000000000ULL, 0x0000000000000000ULL, // +inf 530 0xf800000000000000ULL, 0x0000000000000000ULL, // -inf 531 0xf900000000000000ULL, 0x0000000000000000ULL // -inf 532 #else 533 0x2208000000000000ULL, 0x0000000000000001ULL, // 1 *10^0 534 0x77ffffffffffffffULL, 0xffffffffffffffffULL, // max possible value *10^6111 (largest exp) 535 0xa208000000000000ULL, 0x0000000000000000ULL, // -0*10^0 536 0xfc00000000000000ULL, 0xc00100035b007700ULL, // NAN 537 0x7e00000000000000ULL, 0xfe000000d0e0a0d0ULL, // signaling NAN 538 0xf800000000000000ULL, 0x0000000000000000ULL, // -inf 539 #endif 540 }; 541 542 #define NUM_DFP128_VALS (sizeof(dfp128_vals) / 8) 543 unsigned long nb_dfp128_vals = NUM_DFP128_VALS; 544 545 /* Todo: update dfp64_vals to match dfp128_vals content. */ 546 547 static unsigned long dfp64_vals[] = { 548 #ifdef EXHAUSTIVE_TESTS 549 0x77fcffffffffffffULL, // max possible value 9..9 *10^369 (largest exp) 550 0x0000000000000001ULL, // min possible nonzero value 1 *10^-398. (smallest exp) 551 0x4248000000000001ULL, // 1*10^260 552 0x2234000000000e50ULL, // foo*10^-1 553 0x223400000014c000ULL, // 554 0xa2340000000000e0ULL, // 555 0x22240000000000cfULL, // foo*10^-5 556 0xa21400010a395bcfULL, // negative -foo*10^-9 557 0x6e4d3f1f534acdd4ULL, // huge number foo*10^5 558 0x000400000089b000ULL, // very small number foo*10^-397 559 560 // flavors of zero 561 0x2238000000000000ULL, 562 0xa238000000000000ULL, // 0 * 10 ^0 563 0x4248000000000000ULL, // 0 * 10 ^260 564 565 // flavors of NAN 566 0x7e34000000000111ULL, //signaling NaN 567 0xfe000000d0e0a0d0ULL, //signaling NaN 568 0xfc00000000000000ULL, //quiet NaN 569 570 // flavors of Infinity 571 0x7800000000000000ULL, //+Inf 572 0xf800000000000000ULL, //-Inf 573 0x7a34000000000000ULL, //+Inf 574 #else 575 0x77fcffffffffffffULL, // max possible value 9..9 *10^369 (largest exp) 576 0x4248000000000000ULL, // 0 * 10 ^260 577 0xfe000000d0e0a0d0ULL, //signaling NaN 578 0xf800000000000000ULL, //-Inf 579 #endif 580 }; 581 582 #define NUM_DFP64_VALS (sizeof(dfp64_vals) / 8) 583 unsigned long nb_dfp64_vals = NUM_DFP64_VALS; 584 585 /* shift helpers */ 586 #define SH_0 0 587 #define SH_1 1 588 #define SH_2 15 589 #define SH_3 63 590 591 static uint64_t shift_amounts[] = { 592 SH_0, 593 SH_1, 594 SH_2, 595 SH_3, 596 #define SHIFT_ARRAY_SIZE 4 597 }; 598 599 /* vector splat helpers */ 600 #define SPLAT0 0 601 #define SPLAT1 1 602 #define SPLAT2 0xaa 603 #define SPLAT3 0x55 604 #define SPLAT4 0xff 605 606 static uint64_t splat_values[] = { 607 SPLAT0, 608 SPLAT1, 609 SPLAT2, 610 SPLAT3, 611 SPLAT4, 612 #define SPLAT_ARRAY_SIZE 5 613 }; 614 615 /* a small memory range used to test load-from and store-to vsx */ 616 #define BUFFER_SIZE 4 617 #define MAX_BUFFER_PATTERNS 6 618 unsigned long buffer[BUFFER_SIZE]; 619 620 static void initialize_buffer(int t) 621 { 622 int x; 623 624 for (x = 0; x < BUFFER_SIZE; x++) 625 /* Don't want each of the 32-bit chunks to be identical. Loads of a 626 * byte from the wrong 32-bit chuck are not detectable if the chunks 627 * are identical. 628 */ 629 switch((t+x)%BUFFER_SIZE) { 630 case 0: 631 buffer[x] = 0xffffffffffffffff; 632 break; 633 case 1: 634 buffer[x] = 0x0001020304050607; 635 break; 636 case 2: 637 buffer[x] = 0x5555555555555555; 638 break; 639 case 3: 640 buffer[x] = 0x0000000000000000; 641 break; 642 case 4: 643 buffer[x] = 0x5a05a05a05a05a05; 644 break; 645 case 5: 646 buffer[x] = 0x0102030405060708; 647 break; 648 default: 649 buffer[x] = 0x1010101010101010; 650 break; 651 } 652 } 653 654 #define PATTERN_SIZE 5 655 unsigned long pattern[PATTERN_SIZE] = { 656 0xffffffffffffffff, 657 0xaaaaaaaaaaaaaaaa, 658 0x5152535455565758, 659 0x0000000000000000, 660 0xffaa5599113377cc, 661 }; 662 663 664 static void dump_small_buffer(void) { 665 int x; 666 667 printf("[ "); 668 669 for (x = 0; x < BUFFER_SIZE; x++) 670 printf("%016lx ", buffer[x] ); 671 672 printf("]"); 673 } 674 675 /* value to be shifted */ 676 static uint64_t values_to_shift[] = { 677 0x0, 678 0x1, 679 0x10, 680 0x100, 681 0x1000, 682 0x10000, 683 0x100000, 684 0x1000000, 685 0x10000000, 686 0x100000000, 687 0x1000000000, 688 0x10000000000, 689 0x100000000000, 690 0x1000000000000, 691 0x10000000000000, 692 0x100000000000000, 693 0x1000000000000000, 694 0xf, 695 0x1f, 696 0x10f, 697 0x100f, 698 0x1000f, 699 0x10000f, 700 0x100000f, 701 0x1000000f, 702 0x10000000f, 703 0x100000000f, 704 0x1000000000f, 705 0x10000000000f, 706 0x100000000000f, 707 0x1000000000000f, 708 0x10000000000000f, 709 0x100000000000000f, 710 0x7, 711 0x70, 712 0x700, 713 0x7000, 714 0x70000, 715 0x700000, 716 0x7000000, 717 0x70000000, 718 0x700000000, 719 0x7000000000, 720 0x70000000000, 721 0x700000000000, 722 0x7000000000000, 723 0x70000000000000, 724 0x700000000000000, 725 0x7000000000000000, 726 0x8, 727 0x80, 728 0x800, 729 0x8000, 730 0x80000, 731 0x800000, 732 0x8000000, 733 0x80000000, 734 0x800000000, 735 0x8000000000, 736 0x80000000000, 737 0x800000000000, 738 0x8000000000000, 739 0x80000000000000, 740 0x800000000000000, 741 0x8000000000000000, 742 0xffffffffffffffff, 743 0 744 #define SHIFT_VALUES_SIZE 66 745 }; 746 747 /* DFP related helper functions: */ 748 749 /* For DFP finite numbers, the combination field (G field) is a 750 * combination of the exponent and the LMD (Left Most Digit) of the 751 * significand. The fields are encoded/decoded as described in the 752 * table here. 753 * 00 01 10 -< Exponent bits. 754 * 0: 00000 01000 10000 755 * ... 756 * 7: 00111 01111 10111 757 * 8: 11000 11010 11100 758 * 9: 11001 11011 11101 (encoded special field). 759 * | 760 * ^ LMD value. 761 */ 762 #define DFP_GFIELD_MASK 0x7c00000000000000UL 763 #define DFP_GFIELD_SHIFT 58 764 765 static unsigned int special_field_LMD(uint64_t dword1) { 766 unsigned long g_field_specials; 767 int left_two_bits; 768 int right_three_bits; 769 770 g_field_specials = (dword1 & DFP_GFIELD_MASK) >> DFP_GFIELD_SHIFT; 771 left_two_bits = (g_field_specials & 0x18) >> 3; 772 right_three_bits = g_field_specials & 0x07; 773 774 /* The LMD result maps directly to the right_three_bits value as 775 * long as the left two bits are 0b00,0b01,0b10. So a compare 776 * against 3 is sufficient to determine if we can return the right 777 * three bits directly. (LMD values 0..7). 778 */ 779 if (left_two_bits < 3) { 780 return (right_three_bits); 781 } 782 783 /* LMD values of 8 or 9 require a bit of swizzle, but a check of 784 * the right-most bit is sufficient to determine whether LMD value 785 * is 8 or 9. 786 */ 787 if (right_three_bits & 0x1) 788 return 9; 789 else 790 return 8; 791 } 792 793 /* Returns the exponent bits, as decoded from the G field. */ 794 static inline int special_field_exponent_bits(unsigned long dword1) { 795 unsigned long g_field_specials; 796 int left_two_bits; 797 int right_three_bits; 798 799 g_field_specials = (dword1 & DFP_GFIELD_MASK) >> DFP_GFIELD_SHIFT; 800 left_two_bits = (g_field_specials & 0x18) >> 3; 801 right_three_bits = g_field_specials & 0x07; 802 803 /* The special field exponent bits maps directly to the left_two_bits 804 * value as long as the left two bits are 0b00,0b01,0b10. So a compare 805 * against 3 is sufficient for those values. 806 */ 807 if (left_two_bits < 3) { 808 return (left_two_bits); 809 } 810 811 switch(right_three_bits) { 812 case 0: 813 case 1: return 0x0; 814 case 2: 815 case 3: return 0x1; 816 case 4: 817 case 5: return 0x2; 818 case 6: /* Infinity */ return 0x0; 819 case 7: /* NaN */ return 0x0; 820 } 821 return -1; /* should never hit this */ 822 } 823 824 /* get_declet(). Return a 10-bit declet, beginning at the 'start' 825 * offset. 826 * 827 * | dword1 | dword0 | 828 * | 0 63|64 127| 829 */ 830 #define TEN_BITS 0x03ffULL 831 832 static inline int get_declet(int start, uint64_t dword1, uint64_t dword0) { 833 unsigned long local_declet; 834 unsigned int dword0_shift; 835 unsigned int dword1_shift; 836 837 dword1_shift = 63 - (start + 9); 838 dword0_shift = 127 - (start + 9); 839 840 if (verbose>5) printf("\n%s (%d) %016lx %016lx", 841 __FUNCTION__, start, dword1, dword0); 842 843 if ((start + 9) < 63) { /* fully within dword1 */ 844 local_declet = (dword1 >> dword1_shift) & TEN_BITS; 845 846 } else if (start >= 65) {/* fully within dword0 */ 847 local_declet = (dword0 >> dword0_shift) & TEN_BITS; 848 849 } else { /* straddling the two dwords*/ 850 unsigned long mask_dword0; 851 unsigned long mask_dword1; 852 853 mask_dword1 = TEN_BITS >> (64 - dword0_shift); 854 mask_dword0 = TEN_BITS << (dword0_shift); 855 local_declet = 856 ((dword1 & mask_dword1) << (64-dword0_shift)) + 857 ((dword0 & mask_dword0) >> dword0_shift); 858 } 859 return local_declet; 860 } 861 862 static int get_bcd_digit_from_dpd(int start, uint64_t dword1, 863 uint64_t dword0) { 864 long bcd_digit; 865 long declet; 866 867 declet = get_declet(start, dword1, dword0); 868 bcd_digit = dpb_to_bcd(declet); 869 return bcd_digit; 870 } 871 872 873 /* The 'exponent left' shift is for moving the leftmost two bits 874 * of the exponent down to where they can be easily merged with the 875 * rest of the exponent. 876 */ 877 #define DFP128_EXPONENT_RIGHT_MASK 0x03ffc00000000000 878 #define DFP64_EXPONENT_RIGHT_MASK 0x03fc000000000000 879 #define DFP128_EXPONENT_RIGHT_MASK_SHIFT 46 880 #define DFP64_EXPONENT_RIGHT_MASK_SHIFT 50 881 #define DFP128_EXPONENT_LEFT_SHIFT 12 882 #define DFP64_EXPONENT_LEFT_SHIFT 8 883 884 #define DFP_NAN 0x1f 885 #define DFP_INF 0x1e 886 #define DFP_SIGNALING_NAN_BIT 0x0200000000000000 887 888 /* Start of the Trailing Significand field is at bit # .. */ 889 #define DFP128_T_START 18 890 #define DFP64_T_START 14 891 892 //The exponent bias value is 101 for DFP Short, 398 893 //for DFP Long, and 6176 for DFP Extended. 894 #define DFP128_EXPONENT_BIAS 6176 895 #define DFP64_EXPONENT_BIAS 398 896 897 /* return the dfp exponent from the leading dword. */ 898 static inline signed long dfp128_exponent(unsigned long dword1) { 899 unsigned long exponent_left; 900 unsigned long exponent_right; 901 unsigned long biased_exponent; 902 signed long exponent; 903 904 exponent_left = special_field_exponent_bits(dword1); 905 exponent_right = (dword1 & DFP128_EXPONENT_RIGHT_MASK); 906 biased_exponent = (exponent_left << DFP128_EXPONENT_LEFT_SHIFT) + 907 (exponent_right >> DFP128_EXPONENT_RIGHT_MASK_SHIFT); 908 909 /* Unbias the exponent. */ 910 exponent = biased_exponent - DFP128_EXPONENT_BIAS; 911 912 return exponent; 913 } 914 915 /* Interpret the paired 64-bit values as a extended (quad) 128 bit DFP. 916 * 917 * | Significand | Combination Field/ | | 918 * | sign bit | Encoded Exponent | remainder of significand | 919 * |0 |1 17|18 127| 920 * ^ (bit0) Significand sign bit. 921 * ^ (bit 1:17) Combination field. Contains high bits of 922 * exponent (encoded), LMD of significand (encoded), 923 * and the remainder of the exponent. First five bits 924 * will indicate special cases NAN or INF. 925 * ^ (bit 18:127) Remainder of the 926 * significand. 927 */ 928 929 #define DFP128_COMBINATION_MASK 0x7fffc 930 #define DFP64_COMBINATION_MASK 0x7ffc 931 #define DFP128_COMBINATION_SHIFT 46 932 #define DFP64_COMBINATION_SHIFT 50 933 #define DFP_SPECIAL_SYMBOLS_MASK 0x1f 934 #define DFP_SPECIAL_SYMBOLS_SHIFT 58 935 936 static inline void dissect_dfp128_float(uint64_t dword1, uint64_t dword0) { 937 long signbit; 938 signed long exponent; 939 unsigned long gfield_special_symbols; 940 unsigned long lmd_digit; 941 unsigned long bcd_digits[13]; 942 int i; 943 int silent=0; // suppress leading zeros from the output. 944 945 if (verbose > 5) printf("RAW128: %016lx %016lx ", dword1, dword0); 946 947 signbit = (dword1 >> 63); 948 949 if (signbit) printf("-"); 950 else printf("+"); 951 952 gfield_special_symbols = 953 ((dword1 >> DFP_SPECIAL_SYMBOLS_SHIFT) & DFP_SPECIAL_SYMBOLS_MASK); 954 955 switch (gfield_special_symbols) { 956 case DFP_INF: 957 printf( "inf "); 958 break; 959 960 case DFP_NAN: 961 if (dword1 & DFP_SIGNALING_NAN_BIT) 962 printf("SNaN "); 963 else 964 printf("QNaN "); 965 break; 966 967 default: 968 printf( "Finite "); 969 exponent = dfp128_exponent(dword1); 970 lmd_digit = special_field_LMD(dword1); 971 972 for (i = 0; i < 11; i++) { 973 bcd_digits[i] = get_bcd_digit_from_dpd((DFP128_T_START 974 + 10 * i), dword1, dword0); 975 } 976 977 if (lmd_digit) { 978 silent++; 979 printf("%01lx", lmd_digit); 980 981 } else { 982 printf(" "); 983 } 984 985 for (i = 0; i < 11; i++) { 986 if (bcd_digits[i] || silent ) { 987 silent++; 988 printf("%03lx", bcd_digits[i]); 989 990 } else { 991 /* always print at least the last zero */ 992 if (i == 10) 993 printf(" 0"); 994 995 else 996 printf(" "); 997 } 998 } 999 printf(" * 10 ^ "); 1000 printf("%ld ", exponent); 1001 } 1002 } 1003 1004 /* Interpret the 64-bit values as a 64 bit DFP. 1005 * 1006 * | Significand | Combination Field/ | | 1007 * | sign bit | Encoded Exponent | remainder of significand | 1008 * |0 |1 13|14 63| 1009 * ^ (bit0) Significand sign bit. 1010 * ^ (bit 1:13) Combination field. Contains high bits of 1011 * exponent (encoded), LMD of significand (encoded), 1012 * and the remainder of the exponent. First five bits 1013 * will indicate special cases NAN or INF. 1014 * ^ (bit 14:63) Remainder of the 1015 * significand. 1016 */ 1017 1018 /* return the dfp exponent from the leading dword. */ 1019 static inline signed long dfp64_exponent(unsigned long dword1) { 1020 unsigned long exponent_left; 1021 unsigned long exponent_right; 1022 unsigned long biased_exponent; 1023 signed long exponent; 1024 1025 exponent_left = special_field_exponent_bits(dword1); 1026 exponent_right = (dword1 & DFP64_EXPONENT_RIGHT_MASK); 1027 biased_exponent = (exponent_left << DFP64_EXPONENT_LEFT_SHIFT) + 1028 (exponent_right >> DFP64_EXPONENT_RIGHT_MASK_SHIFT); 1029 1030 /* Unbias the exponent. */ 1031 exponent = biased_exponent - DFP64_EXPONENT_BIAS; 1032 return exponent; 1033 } 1034 1035 static inline void dissect_dfp64_float(uint64_t dword1) { 1036 long signbit; 1037 signed long exponent; 1038 unsigned long gfield_special_symbols; 1039 unsigned long lmd_digit; 1040 unsigned long bcd_digits[13]; 1041 int i; 1042 int silent=0; // suppress leading zeros from the output. 1043 1044 if (verbose > 5) printf("RAW64: %016lx ", dword1); 1045 1046 signbit = (dword1 >> 63); 1047 1048 if (signbit) printf("-"); 1049 else printf("+"); 1050 1051 gfield_special_symbols = 1052 ((dword1 >> DFP_SPECIAL_SYMBOLS_SHIFT) & DFP_SPECIAL_SYMBOLS_MASK); 1053 1054 switch (gfield_special_symbols) { 1055 case DFP_INF: 1056 printf( "inf "); 1057 break; 1058 1059 case DFP_NAN: 1060 if (dword1 & DFP_SIGNALING_NAN_BIT) 1061 printf("SNaN "); 1062 else 1063 printf("QNaN "); 1064 break; 1065 1066 default: 1067 printf( "Finite "); 1068 exponent = dfp64_exponent(dword1); 1069 lmd_digit = special_field_LMD(dword1); 1070 1071 for (i = 0; i < 5; i++) 1072 bcd_digits[i] = get_bcd_digit_from_dpd((DFP64_T_START + 10 * i), 1073 dword1, 0); 1074 1075 if (lmd_digit) { 1076 silent++; 1077 printf("%01lx", lmd_digit); 1078 1079 } else { 1080 printf(" "); 1081 } 1082 1083 for (i = 0; i < 5; i++) { 1084 if (bcd_digits[i] || silent) { 1085 silent++; 1086 printf("%03lx", bcd_digits[i]); 1087 1088 } else { // suppress leading zeros. 1089 /* always print at least the last zero */ 1090 if (i == 4) 1091 printf(" 0"); 1092 1093 else 1094 printf(" "); 1095 } 1096 } 1097 printf(" * 10 ^ "); 1098 printf("%ld ", exponent); 1099 } 1100 } 1101 1102 static void dump_dfp128_table(void) { 1103 int i; 1104 1105 printf("DFP 128 table:\n"); 1106 1107 for (i = 0; i < nb_dfp128_vals; i += 2) { 1108 printf("i=:%2d ", i); 1109 dissect_dfp128_float(dfp128_vals[i], dfp128_vals[i+1]); 1110 printf("\n"); 1111 } 1112 } 1113 1114 static void dump_dfp64_table(void) { 1115 int i; 1116 1117 printf("DFP 64 table:\n"); 1118 1119 for (i = 0; i<nb_dfp64_vals; i++) { 1120 printf("i=:%2d ", i); 1121 dissect_dfp64_float(dfp64_vals[i]); 1122 printf("\n"); 1123 } 1124 } 1125 1126 1127 /* Data Formats for floating point. 1128 * Floating point values include the following: 1129 * -INF -NOR -DEN -0 +0 +DEN +NOR +INF 1130 * INFinite: When the biased exponent is the MAX possible value, and 1131 * the fraction field is 0. 1132 * ZERo. biased exponent is zero, fraction is 0. 1133 * DENormalized. biased exponent is 0, and fraction is non-zero. 1134 * NORmalized. All other values that are neither Zero, Denormalized, 1135 * or Infinite. Biased exponent=1..MAX-1. 1136 */ 1137 1138 /* Quad (128bit): 1139 * | Sign | EXPonent+Bias | FRACTION/Mantissa | 1140 * 0 1 15 16 127 1141 * exponent is 15 bits. ranging from: 0x0000 .. 0x7fff 1142 * 0 = (zero if fraction==0, DeNormal if fraction !=0 ) 1143 * 1...0x7ffe = normalized 1144 * 7fff = (infinite if fraction==0, NaN if fraction !=0) 1145 */ 1146 #define QUAD_EXP_MASK 0x7fff 1147 1148 /* This assumes we are working on the top half of a quad stored in a 64-bit 1149 * register. 1150 */ 1151 #define QUAD_EXP_SHIFT 48 1152 #define QUAD_MANTISSA_MASK 0x0000ffffffffffff 1153 static inline unsigned long build_binary128_float(unsigned long signbit, 1154 unsigned long exponent, 1155 unsigned long mantissa) { 1156 unsigned long thevalue; 1157 1158 thevalue = (unsigned long) (signbit << 63) | 1159 ((exponent & QUAD_EXP_MASK) << QUAD_EXP_SHIFT) | 1160 (mantissa & QUAD_MANTISSA_MASK); 1161 1162 if (verbose > 3) 1163 printf("%s %lx \n", __FUNCTION__, (unsigned long)thevalue); 1164 1165 return thevalue; 1166 } 1167 1168 /* double (64bit): 1169 * | Sign | EXPonent+Bias | FRACTION/Mantissa | 1170 * 0 1 11 12 63 1171 * exponent is 11 bits. ranging from: 0x000 .. 0x7ff 1172 * 0 = (zero if fraction==0, DeNormal if fraction !=0 ) 1173 * 1...0x7fe = normalized 1174 * 7ff = (infinite if fraction==0, NaN if fraction !=0) 1175 */ 1176 #define DOUBLE_EXP_MASK 0x7ff 1177 #define DOUBLE_EXP_SHIFT 52 1178 #define DOUBLE_MANTISSA_MASK 0x000fffffffffffff 1179 1180 static inline unsigned long build_binary64_float(unsigned long signbit, 1181 unsigned long exponent, 1182 unsigned long mantissa) { 1183 unsigned long thevalue; 1184 1185 thevalue = (unsigned long ) (signbit << 63) | 1186 ((exponent & DOUBLE_EXP_MASK) << DOUBLE_EXP_SHIFT) | 1187 (mantissa & DOUBLE_MANTISSA_MASK ); 1188 1189 if (verbose > 3) 1190 printf("%s %lx \n", __FUNCTION__, (unsigned long)thevalue); 1191 1192 return thevalue; 1193 } 1194 1195 /* floating point single (32bit): 1196 * | Sign | EXPonent+Bias | FRACTION/Mantissa | 1197 * 0 1 8 9 31 1198 * exponent is 8 bits. ranging from: 0x00 .. 0xff 1199 * 0 = (zero if fraction==0, DeNormal if fraction !=0 ) 1200 * 1...0x7e = normalized 1201 * 7f = (infinite if fraction==0, NaN if fraction !=0) */ 1202 #define SINGLE_EXP_MASK 0xff 1203 #define SINGLE_EXP_SHIFT 23 1204 #define SINGLE_MANTISSA_MASK 0x007fffff 1205 1206 /* This is building the 32-bit float. */ 1207 static inline unsigned long build_binary32_float(unsigned long signbit, 1208 unsigned long exponent, 1209 unsigned long mantissa) { 1210 unsigned long thevalue; 1211 unsigned long local_signbit; 1212 unsigned long local_exponent; 1213 unsigned long local_mantissa; 1214 1215 local_signbit = (signbit != 0) << 31; 1216 local_exponent = ((exponent & SINGLE_EXP_MASK) << SINGLE_EXP_SHIFT); 1217 local_mantissa = (mantissa & SINGLE_MANTISSA_MASK); 1218 1219 thevalue = (unsigned long) (local_signbit) | 1220 (local_exponent) | 1221 (local_mantissa); 1222 1223 if (verbose > 3) 1224 printf("%s %lx \n", __FUNCTION__, (unsigned long)thevalue); 1225 1226 return thevalue; 1227 } 1228 1229 /* floating point half (16bit): 1230 * | Sign | EXPonent+Bias | FRACTION/Mantissa | 1231 * 0 1 6 7 15 1232 * exponent is 6 bits. 0x00 .. 0x7e masked with EXP_MASK 1233 * 0 = (zero if fraction==0, DeNormal if fraction !=0 ) 1234 * 1...0x7d = normalized 1235 * 7e = (infinite if fraction==0, NaN if fraction !=0) */ 1236 /* when extracting the exponent from the 16-bit half-word, use this mask. */ 1237 #define HALF_EXP_MASK 0x7e00 1238 1239 /* when building the 16-bit half-word, mask against this, 1240 * then shift into place 1241 */ 1242 #define HALF_EXP_MASK_NORMALIZED 0x3f 1243 #define HALF_EXP_SHIFT 9 1244 #define HALF_MANTISSA_MASK 0x01ff 1245 1246 /* This is building the 16-bit float. */ 1247 static inline unsigned long build_binary16_float(unsigned long in_signbit, 1248 unsigned long exponent, 1249 unsigned mantissa) { 1250 unsigned long thevalue; 1251 unsigned long local_signbit; 1252 unsigned long local_exponent; 1253 unsigned long local_mantissa; 1254 1255 local_signbit = (in_signbit != 0) << 15; 1256 1257 local_exponent= ((exponent & HALF_EXP_MASK_NORMALIZED) << HALF_EXP_SHIFT); 1258 local_mantissa = (mantissa & HALF_MANTISSA_MASK); 1259 1260 thevalue = (unsigned long) (local_signbit) | (local_exponent) 1261 | (local_mantissa); 1262 1263 if (verbose > 3) 1264 printf("%s %lx \n", __FUNCTION__, (unsigned long)thevalue); 1265 1266 return thevalue; 1267 } 1268 1269 /* dissect_binary128_float: 1270 * Interpret the (high half) 64-bit value as normal/denormal/inf/NaN. 1271 * This is as it would be interpreted as the MSB portion of 1272 * a 128-bit wide QUAD. 1273 */ 1274 static inline void dissect_binary128_float(uint64_t value) { 1275 unsigned long signbit; 1276 unsigned long exponent; 1277 unsigned long mantissa; 1278 1279 signbit = (value >> 63); 1280 exponent = ( QUAD_EXP_MASK & (value >> QUAD_EXP_SHIFT)); 1281 mantissa = ( QUAD_MANTISSA_MASK & value); 1282 1283 if (verbose > 4) printf("128 bit:"); 1284 1285 if (signbit) printf("-"); 1286 else printf("+"); 1287 1288 switch (exponent) { 1289 case 0x0: 1290 if (mantissa == 0) printf("zero "); 1291 else printf("denormal "); 1292 break; 1293 1294 case QUAD_EXP_MASK: 1295 if (mantissa == 0) printf("inf "); 1296 else printf("NaN "); 1297 break; 1298 1299 default: printf("Normal "); 1300 } 1301 1302 if (verbose > 4) 1303 printf("%lx %4lx %16lx %16lx \n", signbit, exponent, mantissa, value); 1304 } 1305 1306 /* Interpret the 64-bit value as normal/denormal/inf/NaN 1307 * this is as interpreted as the 64-bit float 1308 */ 1309 static inline void dissect_binary64_float(uint64_t value) { 1310 unsigned long signbit; 1311 unsigned long exponent; 1312 unsigned long mantissa; 1313 1314 signbit = (value >> 63); // bit0 1315 exponent = ( DOUBLE_EXP_MASK & (value >> DOUBLE_EXP_SHIFT)); 1316 mantissa = ( DOUBLE_MANTISSA_MASK & value); 1317 1318 if (verbose > 4) printf(" 64 bit:"); 1319 1320 if (signbit) printf("-"); 1321 else printf("+"); 1322 1323 switch (exponent) { 1324 case 0x0: 1325 if (mantissa == 0) printf("zero "); 1326 else printf("denormal "); 1327 break; 1328 1329 case DOUBLE_EXP_MASK: 1330 if (mantissa == 0) printf("inf "); 1331 else printf("NaN "); 1332 break; 1333 1334 default: printf("Normal "); 1335 } 1336 1337 if (verbose>4) 1338 printf("%lx %4lx %16lx %16lx\n", signbit, exponent, mantissa, value); 1339 } 1340 1341 /* interpret the 32-bit value as normal/denormal/inf/NaN. 1342 * Note that the value is stored in the upper half of a 1343 * 64-bit, which is itself in the upper half of a quad. 1344 */ 1345 static inline void dissect_binary32_float(uint64_t value) { 1346 unsigned long signbit; 1347 unsigned long exponent; 1348 unsigned long mantissa; 1349 unsigned long adj_value; 1350 1351 /* shift down to where the offsets make more sense.*/ 1352 adj_value = value; //>>32; 1353 signbit = (adj_value >> 31); 1354 exponent = ( SINGLE_EXP_MASK & (adj_value >> SINGLE_EXP_SHIFT)); 1355 mantissa = ( SINGLE_MANTISSA_MASK & adj_value); 1356 1357 if (verbose > 4) printf(" 32 bit:"); 1358 1359 if (signbit) printf("-"); 1360 else printf("+"); 1361 1362 switch (exponent) { 1363 case 0x0: 1364 if (mantissa == 0) printf("zero "); 1365 else printf("denormal "); 1366 break; 1367 1368 case SINGLE_EXP_MASK: 1369 if (mantissa == 0) printf("inf "); 1370 else printf("NaN "); 1371 break; 1372 1373 default: printf("Normal "); 1374 } 1375 1376 if (verbose>4) 1377 printf("%lx %4lx %16lx %16lx \n", signbit, exponent, mantissa, adj_value); 1378 } 1379 1380 /* Interpret the 16-bit value as normal/denormal/inf/NaN. */ 1381 static inline void dissect_binary16_float(uint64_t value) { 1382 unsigned long signbit; 1383 unsigned long exponent; 1384 unsigned long mantissa; 1385 unsigned long adj_value; 1386 1387 adj_value = (value & 0xffff); 1388 signbit = ((adj_value & 0x8000) > 1); 1389 exponent = ((adj_value & HALF_EXP_MASK ) >> HALF_EXP_SHIFT) ; 1390 mantissa = (adj_value & HALF_MANTISSA_MASK); 1391 1392 if (verbose > 4) printf(" 16 bit:"); 1393 1394 if (signbit) printf("-"); 1395 else printf("+"); 1396 1397 switch (exponent) { 1398 case 0x0: 1399 if (mantissa == 0) printf("zero "); 1400 else printf("denormal "); 1401 break; 1402 1403 case HALF_EXP_MASK: 1404 if (mantissa == 0) printf("inf "); 1405 else printf("NaN "); 1406 break; 1407 1408 default: printf("Normal "); 1409 } 1410 1411 if (verbose > 4) 1412 printf("%lx %4lx %16lx %16lx \n", 1413 signbit, exponent>>HALF_EXP_SHIFT, mantissa, adj_value); 1414 } 1415 1416 #define dissect_double_as_32s(vec_foo) \ 1417 printf(" "); \ 1418 dissect_binary16_float((vec_foo & 0xffffffff)); \ 1419 printf(" "); \ 1420 dissect_binary16_float((vec_foo >> 32) & 0xffffffff); 1421 1422 #define dissect_double_as_16s(vec_foo) \ 1423 printf(" "); \ 1424 dissect_binary16_float((vec_foo&0xffff)); \ 1425 printf(" "); \ 1426 dissect_binary16_float((vec_foo>>16)&0xffff); \ 1427 printf(" "); \ 1428 dissect_binary16_float((vec_foo>>32)&0xffff); \ 1429 printf(" "); \ 1430 dissect_binary16_float((vec_foo>>48)&0xffff); 1431 1432 /* a table of exponent values for use in the float precision tests. */ 1433 unsigned long exponent_table[] = { 1434 #ifdef EXHAUSTIVE_TESTS 1435 0x0000, /* +/-0 or +/-DENormalized, depending on associated mantissa. */ 1436 0x1a, /* within NORmalized for 16,32,64,128-bit. */ 1437 0x1f, /* +/-INF or +/-NaN for 16bit, NORmalized for 32,64,128 */ 1438 0xff, /* +/-INF or +/-NaN for 32bit, NORmalized for 64,128 */ 1439 0x7ff, /* +/-INF or +/-NaN for 32 and 64bit, NORmalized for 128 */ 1440 0x7fff, /* +/-INF or +/-NaN for 128bit. */ 1441 #else 1442 0x0000, /* +/-0 or +/-DENormalized, depending on associated mantissa. */ 1443 0xff, /* +/-INF or +/-NaN for 32bit, NORmalized for 64,128 */ 1444 0x7ff, /* +/-INF or +/-NaN for 32 and 64bit, NORmalized for 128 */ 1445 0x7fff, /* +/-INF or +/-NaN for 128bit. */ 1446 #endif 1447 }; 1448 #define MAX_EXPONENTS (sizeof(exponent_table) / sizeof(unsigned long)) 1449 1450 unsigned long mantissa_table[] = { 1451 #ifdef EXHAUSTIVE_TESTS 1452 0xbeefbeefbeef, /* NOR or DEN or NaN */ 1453 0x000000000000, /* ZERO or INF */ 1454 0x7fffffffffff, /* NOR or DEN or NaN */ 1455 #else 1456 0x000000000000, /* ZERO or INF */ 1457 0x7fffffffffff, /* NOR or DEN or NaN */ 1458 #endif 1459 }; 1460 #define MAX_MANTISSAS (sizeof(mantissa_table) / sizeof(unsigned long)) 1461 1462 /* build in 64-bit chunks, low doubleword is zero. */ 1463 static unsigned long * float_vsxargs; 1464 static unsigned long * binary128_float_vsxargs = NULL; 1465 static unsigned long * binary64_float_vsxargs = NULL; 1466 static unsigned long * binary32_float_vsxargs = NULL; 1467 static unsigned long * binary16_float_vsxargs = NULL; 1468 1469 unsigned long nb_float_vsxargs; 1470 1471 #define MAX_FLOAT_VSX_ARRAY_SIZE (((MAX_EXPONENTS * MAX_MANTISSAS) * 2 + 1) * 2) 1472 1473 void build_float_vsx_tables (void) 1474 { 1475 long i = 0; 1476 unsigned long signbit; 1477 unsigned long exponent; 1478 unsigned long mantissa;/* also referred to as FRACTION in the ISA.*/ 1479 unsigned long exponent_index; 1480 unsigned long mantissa_index; 1481 1482 if (verbose > 2) printf("%s\n", __FUNCTION__); 1483 1484 binary128_float_vsxargs = malloc(MAX_FLOAT_VSX_ARRAY_SIZE 1485 * sizeof(unsigned long)); 1486 1487 float_vsxargs = binary128_float_vsxargs; 1488 1489 binary64_float_vsxargs = malloc(MAX_FLOAT_VSX_ARRAY_SIZE 1490 * sizeof(unsigned long)); 1491 1492 binary32_float_vsxargs = malloc(MAX_FLOAT_VSX_ARRAY_SIZE 1493 * sizeof(unsigned long)); 1494 binary16_float_vsxargs = malloc(MAX_FLOAT_VSX_ARRAY_SIZE 1495 * sizeof(unsigned long)); 1496 1497 for (signbit = 0; signbit < 2; signbit++) { 1498 for (exponent_index = 0; exponent_index < MAX_EXPONENTS; 1499 exponent_index++) { 1500 1501 for (mantissa_index = 0; mantissa_index < MAX_MANTISSAS; 1502 mantissa_index++) { 1503 1504 exponent = exponent_table[exponent_index]; 1505 mantissa = mantissa_table[mantissa_index]; 1506 1507 if (verbose > 2) { 1508 printf("signbit:%lx ", signbit); 1509 printf("exponent:%4lx ", exponent); 1510 printf("mantissa:%lx ", mantissa); 1511 printf("\n"); 1512 } 1513 1514 binary128_float_vsxargs[i] = build_binary128_float(signbit, exponent, 1515 mantissa); 1516 1517 binary128_float_vsxargs[i+1] = 0; 1518 1519 binary64_float_vsxargs[i] = build_binary64_float(signbit, exponent, 1520 mantissa); 1521 1522 binary64_float_vsxargs[i+1] = build_binary64_float(signbit, exponent, 1523 mantissa); 1524 1525 binary32_float_vsxargs[i] = build_binary32_float(signbit, exponent, 1526 mantissa); 1527 1528 binary32_float_vsxargs[i+1] = build_binary32_float(signbit, exponent, 1529 mantissa); 1530 1531 binary16_float_vsxargs[i] = build_binary16_float(signbit, exponent, 1532 mantissa); 1533 1534 binary16_float_vsxargs[i+1] = build_binary16_float(signbit, exponent, 1535 mantissa); 1536 i += 2; 1537 } 1538 } 1539 } 1540 nb_float_vsxargs = i; 1541 } 1542 1543 /* Display entries stored in the float_vsx table. These are used as 1544 * quad/double/singles, stored as quads. */ 1545 void dump_float_vsx_table (void) { 1546 int i; 1547 1548 printf("Float VSX Table:"); 1549 printf("128-bit (quad):\n"); 1550 1551 for (i = 0; i < nb_float_vsxargs; i += 2) { 1552 printf("i =: %2d ", i); 1553 dissect_binary128_float(binary128_float_vsxargs[i]); 1554 } 1555 1556 printf("64-bit (double):\n"); 1557 1558 for (i = 0; i< nb_float_vsxargs; i += 2) { 1559 printf("i = %2d ", i); 1560 dissect_binary64_float(binary64_float_vsxargs[i]); 1561 } 1562 1563 printf("32-bit (single):\n"); 1564 1565 for (i = 0; i < nb_float_vsxargs; i += 2) { 1566 printf("i = %2d ", i); 1567 dissect_binary32_float(binary32_float_vsxargs[i]); 1568 } 1569 1570 printf("16-bit (half):\n"); 1571 1572 for (i = 0; i < nb_float_vsxargs; i += 2) { 1573 printf("i =% 2d ", i); 1574 dissect_binary16_float(binary16_float_vsxargs[i]); 1575 } 1576 1577 printf("\n"); 1578 } 1579 1580 static void print_dcmx_field(unsigned long local_dcmx) { 1581 /* Note - this splats out the local_dxmc field from the form used to 1582 * globally pass it, with a single set bit, into the functions that use 1583 * it. The actual DCMX field is a bit-field from 0x00 to 0x3f. If 1584 * multiple bits are ever set, this function and the way it is passed 1585 * into the users will need to be updated. This does not handle 1586 * multiple bits being set. 1587 */ 1588 1589 printf(" DCMX=["); 1590 1591 switch(local_dcmx) { 1592 case 0: printf("ALL"); break; 1593 case 1: printf("NaN"); break; 1594 case 2: printf("+inf"); break; 1595 case 3: printf("-inf"); break; 1596 case 4: printf("+zero"); break; 1597 case 5: printf("-zero"); break; 1598 case 6: printf("+denormal"); break; 1599 case 7: printf("-denormal"); break; 1600 default: printf("other"); break; 1601 } 1602 1603 if (verbose > 3) 1604 printf(" %lx", local_dcmx); 1605 1606 printf("] "); 1607 } 1608 1609 #define MAX_CHAR_ARGS_ARRAY_SIZE 128 1610 1611 static unsigned char * char_args; 1612 unsigned long nb_char_args; 1613 1614 static void build_char_table(void) { 1615 long i = 0; 1616 char ichar; 1617 1618 char_args = memalign(32, MAX_CHAR_ARGS_ARRAY_SIZE * sizeof(char)); 1619 1620 #ifdef EXHAUSTIVE_TESTS 1621 for (ichar = 'a'; ichar <= 'z'; ichar++) { char_args[i++] = ichar; } 1622 for (ichar = '0'; ichar <= '9'; ichar++) { char_args[i++] = ichar; } 1623 for (ichar = 'A'; ichar <= 'Z'; ichar++) { char_args[i++] = ichar; } 1624 #else 1625 for (ichar = 'a'; ichar <= 'z'; ichar+=6) { char_args[i++] = ichar; } 1626 for (ichar = '0'; ichar <= '9'; ichar+=6) { char_args[i++] = ichar; } 1627 for (ichar = 'A'; ichar <= 'Z'; ichar+=6) { char_args[i++] = ichar; } 1628 #endif 1629 1630 char_args[i++] = ' '; 1631 char_args[i++] = '+'; 1632 char_args[i++] = '-'; 1633 char_args[i++] = '/'; 1634 char_args[i++] = '['; 1635 char_args[i++] = ']'; 1636 char_args[i++] = '`'; 1637 char_args[i++] = '_'; 1638 nb_char_args = i; 1639 } 1640 1641 static void dump_char_table() { 1642 int i; 1643 1644 printf("Char Table:"); 1645 1646 for (i = 0; i<nb_char_args; i++) 1647 printf("%c ", char_args[i]); 1648 1649 printf("\n"); 1650 } 1651 1652 #define MAX_CHAR_RANGES_SIZE 128 1653 1654 static unsigned char * char_ranges; 1655 unsigned long nb_char_ranges; 1656 1657 static void build_char_range_table(void) { 1658 /* ... in groups of four. */ 1659 1660 long i = 0; 1661 char char_start, char_end; 1662 1663 char_ranges = memalign(32, MAX_CHAR_RANGES_SIZE * sizeof(char)); 1664 char_start = 'a'; 1665 char_end = 'z'; 1666 char_ranges[i++] = char_start; 1667 char_ranges[i++] = char_end; 1668 1669 char_start = 'A'; 1670 char_end = 'Z'; 1671 char_ranges[i++] = char_start; 1672 char_ranges[i++] = char_end; 1673 1674 char_start = '0'; 1675 char_end = '9'; 1676 char_ranges[i++] = char_start; 1677 char_ranges[i++] = char_end; 1678 1679 char_start = 'f'; 1680 char_end = 'z'; 1681 char_ranges[i++] = char_start; 1682 char_ranges[i++] = char_end; 1683 1684 char_start = 'a'; 1685 char_end = 'e'; 1686 char_ranges[i++] = char_start; 1687 char_ranges[i++] = char_end; 1688 1689 char_start = 'A'; 1690 char_end = 'E'; 1691 char_ranges[i++] = char_start; 1692 char_ranges[i++] = char_end; 1693 1694 nb_char_ranges = i; 1695 } 1696 1697 static void dump_char_range_table() 1698 { 1699 int i; 1700 1701 printf("Char Range Table:"); 1702 1703 for (i = 0; i < nb_char_ranges; i += 4) { 1704 printf(" [ %c-%c %c-%c ] ", 1705 char_ranges[i], char_ranges[i+1], 1706 char_ranges[i+2], char_ranges[i+3] ); 1707 } 1708 1709 printf("\n"); 1710 } 1711 1712 static HWord_t *iargs = NULL; 1713 static int nb_iargs = 0; 1714 1715 static void build_iargs_table (void) { 1716 uint64_t tmp; 1717 int i = 0; 1718 1719 iargs = malloc(20 * sizeof(HWord_t)); 1720 1721 for (tmp = 0; ; tmp = 123456789*tmp + 123456789999) { 1722 if ((long)tmp < 0 ) 1723 tmp = 0xFFFFFFFFFFFFFFFFULL; 1724 1725 iargs[i++] = tmp; 1726 AB_DPRINTF("val %016lx\n", tmp); 1727 1728 if (tmp == 0xFFFFFFFFFFFFFFFFULL) 1729 break; 1730 } 1731 1732 AB_DPRINTF("Registered %d iargs values\n", i); 1733 nb_iargs = i; 1734 } 1735 1736 static unsigned long * vsxargs = NULL; 1737 unsigned long nb_vargs; 1738 1739 #define MAX_VSX_ARRAY_SIZE 42 1740 1741 static void build_vsx_table (void) 1742 { 1743 long i = 0; 1744 // A VSX register is 128-bits wide. 1745 // We build contents here using pairs of 64-bit longs. 1746 // Permutes work against two (non-paired) VSX regs, so these are 1747 // also grouped by twos. 1748 vsxargs = memalign(16, MAX_VSX_ARRAY_SIZE * sizeof(unsigned long)); 1749 #ifdef EXHAUSTIVE_TESTS 1750 vsxargs[i++] = 0x0000000000000000UL; vsxargs[i++] = 0x0000000000000000UL; 1751 vsxargs[i++] = 0x0102030405060708UL; vsxargs[i++] = 0x0102010201020102UL; 1752 1753 vsxargs[i++] = 0xaaaaaaaaaaaaaaaaUL; vsxargs[i++] = 0xaaaaaaaaaaaaaaaaUL; 1754 vsxargs[i++] = 0x5555555555555555UL; vsxargs[i++] = 0x5555555555555555UL; 1755 1756 vsxargs[i++] = 0x08090a0b0c0d0e0fUL; vsxargs[i++] = 0x0102010201020102UL; 1757 vsxargs[i++] = 0xf0f1f2f3f4f5f6f7UL; vsxargs[i++] = 0xf8f9fafbfcfdfeffUL; 1758 1759 vsxargs[i++] = 0x7ea1a5a7abadb0baUL; vsxargs[i++] = 0x070d111d1e555e70UL; 1760 vsxargs[i++] = 0xe5e7ecedeff0f1faUL; vsxargs[i++] = 0xbeb1c0caced0dbdeUL; 1761 1762 vsxargs[i++] = 0x00115e7eadbabec0UL; vsxargs[i++] = 0xced0deede5ecef00UL; 1763 vsxargs[i++] = 0x00111e7ea5abadb1UL; vsxargs[i++] = 0xbecad0deedeffe00UL; 1764 1765 vsxargs[i++] = 0x0011223344556677UL; vsxargs[i++] = 0x8899aabbccddeeffUL; 1766 vsxargs[i++] = 0xf0e0d0c0b0a09080UL; vsxargs[i++] = 0x7060504030201000UL; 1767 #else 1768 vsxargs[i++] = 0x0000000000000000UL; vsxargs[i++] = 0x0000000000000000UL; 1769 vsxargs[i++] = 0x0102030405060708UL; vsxargs[i++] = 0x0102010201020102UL; 1770 1771 vsxargs[i++] = 0x0011223344556677UL; vsxargs[i++] = 0x8899aabbccddeeffUL; 1772 vsxargs[i++] = 0xf0e0d0c0b0a09080UL; vsxargs[i++] = 0x7060504030201000UL; 1773 #endif 1774 1775 // these next three groups are specific for vector rotate tests. 1776 // bits 11:15,19:23,27:31 of each 32-bit word contain mb,me,sh values. 1777 vsxargs[i++] = 0x0000100000001002ULL; vsxargs[i++] = 0x0000100800001010ULL; 1778 vsxargs[i++] = 0x0010100000101002ULL; vsxargs[i++] = 0x0010100800101010ULL; 1779 1780 // vector rotate special... 1781 vsxargs[i++] = 0x00001c0000001c02ULL; vsxargs[i++] = 0x00001c0800001c10ULL; 1782 vsxargs[i++] = 0x00101c0000101c02ULL; vsxargs[i++] = 0x00101c0800101c10ULL; 1783 1784 // vector rotate special... 1785 vsxargs[i++] = 0x00001f0000001f02ULL; vsxargs[i++] = 0x00001f0800001f10ULL; 1786 vsxargs[i++] = 0x00101f0000101f02ULL; vsxargs[i++] = 0x00101f0800101f10ULL; 1787 1788 AB_DPRINTF("Registered %d vargs values\n", i/2); 1789 nb_vargs = i; 1790 } 1791 1792 /* VPCV = Vector Permute Control Vector */ 1793 unsigned long nb_vpcv; 1794 static unsigned long * vpcv = NULL; 1795 1796 #define MAX_VPCV_SIZE 20 1797 1798 static void build_vector_permute_table(void) 1799 { 1800 int i=0; 1801 1802 vpcv = memalign(16, MAX_VPCV_SIZE * sizeof(unsigned long)); 1803 1804 #ifdef EXHAUSTIVE_TESTS 1805 /* These two lines are complementary pairs of each other. */ 1806 vpcv[i++]=0x12021a0817141317ULL; vpcv[i++]=0x100d1b05070f0205ULL; 1807 vpcv[i++]=0x0d1d0517080b0c08ULL; vpcv[i++]=0x0f12041a18101d1cULL; 1808 vpcv[i++]=0x100d1b070f020505ULL; vpcv[i++]=0x0e201f1400130105ULL; 1809 vpcv[i++]=0x0705030a0b01ea0cULL; vpcv[i++]=0x0e0c09010602080dULL; 1810 #else 1811 vpcv[i++]=0x12021a0817141317ULL; vpcv[i++]=0x100d1b05070f0205ULL; 1812 vpcv[i++]=0x0705030a0b01ea0cULL; vpcv[i++]=0x0e0c09010602080dULL; 1813 #endif 1814 nb_vpcv=i; 1815 AB_DPRINTF("Registered %d permute control vectors \n", nb_vpcv); 1816 1817 if (i >= MAX_VPCV_SIZE) 1818 printf("Warning! Exceeded size of table building the vector permute control . \n"); 1819 } 1820 1821 /* Decimal Encodings... 1822 * Packed, National, Zoned decimal content follows. 1823 * Note: Watch the conversions in and out of the 1824 * dwords / vectors for reverses with respect to 1825 * top/bottom low/high 1826 */ 1827 1828 /* Packed Decimals: 1829 * A valid encoding of a packed decimal integer value requires the following 1830 * properties: 1831 * Each of the 31 4-bit digits of the operands magnitude (bits 0:123) 1832 * must be in the range 0-9. 1833 * The sign code (bits 124:127) must be in the range 10-15. (0xa-0xf). 1834 * Source operands with sign codes of 0b1010, 0b1100, 0b1110, and 0b1111 are 1835 * interpreted as positive values. Source operands with sign codes of 1836 * 0b1011 and 0b1101 are interpreted as negative values. 1837 * Positive and zero results are encoded with a either sign code of 1838 * 0b1100 or 0b1111, depending on the preferred sign (indicated as an 1839 * immediate operand). Negative results are encoded with a sign code 1840 * of 0b1101. 1841 * PS - This is the 'preferred sign' bit encoded in some BCD associated 1842 * instructions. 1843 */ 1844 1845 // Note: table content is limited to values encoded, not interpreted. 1846 unsigned int packed_decimal_sign_codes[] = { 1847 /* positive operands */ 1848 0xc, 0xf, // 0b1100, 0b1111 1849 1850 /* negative operands */ 1851 0xd // 0b1101 1852 }; 1853 1854 #define NR_PACKED_DECIMAL_SIGNS 3 1855 #define MAX_PACKED_DECIMAL_TABLE_SIZE 8 * 16 * 2 + 20 1856 1857 static unsigned long * packed_decimal_table; 1858 1859 /* build into a pair of doubles */ 1860 unsigned long nb_packed_decimal_entries; 1861 1862 static void dissect_packed_decimal_sign(unsigned long local_sign) { 1863 switch(local_sign) { 1864 case 0xa: /*0b1010:*/ printf("[ + ]"); break; 1865 case 0xb: /*0b1011:*/ printf("[ - ]"); break; 1866 case 0xc: /*0b1100:*/ printf("(+|0)"); break; 1867 case 0xd: /*0b1101:*/ printf("( - )"); break; 1868 case 0xe: /*0b1110:*/ printf("[ + ]"); break; 1869 case 0xf: /*0b1111:*/ printf("(+|0)"); break; 1870 default: printf("(?%02lx)", local_sign); 1871 } 1872 } 1873 1874 int extract_packed_decimal_sign(unsigned long dword1, unsigned long dword0) { 1875 return (dword1 & 0xf); 1876 } 1877 1878 static void dissect_packed_decimal(unsigned long dword1,unsigned long dword0) 1879 { 1880 int i; 1881 int local_sign; 1882 int nibble; 1883 1884 local_sign = extract_packed_decimal_sign(dword1, dword0); 1885 printf("packed_decimal: ["); 1886 1887 for (i = 60; i >= 0; i -= 4) { 1888 nibble=(dword1 >> (i)) & 0xf; 1889 printf(" %x", nibble); 1890 } 1891 1892 for (i = 60; i >= 0; i -= 4) { 1893 nibble=(dword0 >> (i)) & 0xf; 1894 printf(" %x", nibble); 1895 } 1896 1897 printf(" "); 1898 dissect_packed_decimal_sign(local_sign); 1899 printf(" ] "); 1900 } 1901 1902 static void build_packed_decimal_table(void) 1903 { 1904 long sign_index; 1905 long sign_value; 1906 unsigned long i = 0; 1907 unsigned long value; 1908 #ifdef EXHAUSTIVE_TESTS 1909 int scramble; 1910 #endif 1911 1912 if (verbose) printf("%s\n", __FUNCTION__); 1913 1914 packed_decimal_table = malloc((MAX_PACKED_DECIMAL_TABLE_SIZE + 2) 1915 * sizeof (unsigned long)); 1916 1917 for (sign_index = 0; sign_index < NR_PACKED_DECIMAL_SIGNS; sign_index++) { 1918 sign_value = packed_decimal_sign_codes[sign_index]; 1919 1920 for (value = 0; value <= 9; value++) { 1921 packed_decimal_table[i] = 0x1111111111111111 * value; 1922 packed_decimal_table[i+1] = sign_value; 1923 packed_decimal_table[i+1] += 0x1111111111111110 * value; 1924 1925 if (verbose>3) dissect_packed_decimal(packed_decimal_table[i+1], 1926 packed_decimal_table[i]); 1927 if (verbose>3) printf("\n"); 1928 i+=2; 1929 } 1930 1931 #ifdef EXHAUSTIVE_TESTS 1932 for (scramble = 1; scramble <= 4; scramble++) { 1933 packed_decimal_table[i] = 0x3210321032103210 * scramble; 1934 packed_decimal_table[i+1] = sign_value; 1935 packed_decimal_table[i+1] += 0x0123012301230120 * scramble; 1936 1937 if (verbose>3) dissect_packed_decimal(packed_decimal_table[i+1], 1938 packed_decimal_table[i]); 1939 if (verbose>3) printf("\n"); 1940 i+=2; 1941 } 1942 #endif 1943 1944 /* Add some entries that will provide interesting output from 1945 * the convert TO tests. 1946 */ 1947 packed_decimal_table[i] = 0x0000000000000000; 1948 packed_decimal_table[i+1] = sign_value; 1949 packed_decimal_table[i+1] += 0x0000000012345670; 1950 1951 if (verbose > 3) dissect_packed_decimal(packed_decimal_table[i+1], 1952 packed_decimal_table[i]); 1953 1954 if (verbose>3) printf("\n"); 1955 1956 i += 2; 1957 1958 #ifdef EXHAUSTIVE_TESTS 1959 packed_decimal_table[i] = 0x0000000000000000; 1960 packed_decimal_table[i+1] = sign_value; 1961 packed_decimal_table[i+1] += 0x0000000098765430; 1962 1963 if (verbose > 3) dissect_packed_decimal(packed_decimal_table[i+1], 1964 packed_decimal_table[i]); 1965 1966 if (verbose > 3) printf("\n"); 1967 1968 i += 2; 1969 1970 packed_decimal_table[i] = 0x000000000000000b; 1971 packed_decimal_table[i+1] = sign_value; 1972 packed_decimal_table[i+1] += 0x0000000000000000; 1973 1974 if (verbose > 3) dissect_packed_decimal(packed_decimal_table[i+1], 1975 packed_decimal_table[i]); 1976 1977 if (verbose>3) printf("\n"); 1978 1979 i += 2; 1980 #endif 1981 1982 packed_decimal_table[i] = 0x0030000000000000; 1983 packed_decimal_table[i+1] = sign_value; 1984 packed_decimal_table[i+1] += 0x0000000000000000; 1985 1986 if (verbose > 3) dissect_packed_decimal(packed_decimal_table[i+1], 1987 packed_decimal_table[i]); 1988 1989 if (verbose > 3) printf("\n"); 1990 1991 i += 2; 1992 } 1993 1994 if (verbose>2) printf("\n"); 1995 1996 nb_packed_decimal_entries = i; 1997 } 1998 1999 static void dump_packed_decimal_table(void) { 2000 int i; 2001 2002 printf("packed_decimal_table:\n"); 2003 2004 for (i = 0; i < nb_packed_decimal_entries; i += 2) { 2005 printf("i =: %2d ", i); 2006 dissect_packed_decimal(packed_decimal_table[i+1], 2007 packed_decimal_table[i]); 2008 printf("\n"); 2009 } 2010 } 2011 2012 /* National decimals: 2013 * A valid encoding of a national decimal value requires the following. 2014 * The contents of halfword 7 (sign code) must be 2015 * either 0x002B or 0x002D. 2016 * The contents of halfwords 0 to 6 must be in the 2017 * range 0x0030 to 0x0039. 2018 * National decimal values having a sign code of 0x002B 2019 * are interpreted as positive values. 2020 * National decimal values having a sign code of 0x002D 2021 * are interpreted as negative values. 2022 */ 2023 unsigned int national_decimal_sign_codes[] = { 2024 /* positive */ 0x002b, 2025 /* negative */ 0x002d 2026 }; 2027 2028 #define NR_NATIONAL_DECIMAL_SIGNS 2 2029 2030 unsigned int national_decimal_values[] = { 2031 #ifdef EXHAUSTIVE_TESTS 2032 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 2033 0x0035, 0x0036, 0x0037, 0x0038, 0x0039 2034 #else 2035 0x0030, 0x0031, 2036 0x0035, 0x0039 2037 #endif 2038 }; 2039 2040 #define NR_NATIONAL_DECIMAL_VALUES (sizeof(national_decimal_values) / sizeof(unsigned int)) 2041 2042 static unsigned long * national_decimal_table; 2043 2044 #define MAX_NATIONAL_DECIMAL_TABLE_SIZE 10 * NR_NATIONAL_DECIMAL_VALUES * NR_NATIONAL_DECIMAL_SIGNS 2045 2046 unsigned long nb_national_decimal_entries; 2047 2048 static void dissect_national_decimal_sign(unsigned long local_sign) { 2049 switch(local_sign) { 2050 case 0x002b: 2051 printf("( + )"); 2052 break; 2053 2054 case 0x002d: 2055 printf("( - )"); 2056 break; 2057 2058 default: printf("unhandled sign value: %lx", local_sign); 2059 } 2060 } 2061 2062 int extract_national_decimal_sign(unsigned long dword1, unsigned long dword0) { 2063 return (dword1 & 0x0ff); 2064 } 2065 2066 static void dissect_national_decimal(unsigned long dword1, 2067 unsigned long dword0) 2068 { 2069 int i; 2070 int local_sign; 2071 long hword; 2072 2073 printf("national_decimal: ["); 2074 2075 if (verbose>4) printf("raw: [%016lx %016lx] ", dword1, dword0); 2076 2077 for (i = 48;i >= 0; i -= 16) { 2078 hword = dword1 >> (i) & 0x00ff; 2079 2080 /* validity of national decimal value */ 2081 /* the i>0 clause skips the validity check against the sign value. */ 2082 if (((i > 0) && (hword < 0x30)) || (hword > 0x39)) printf("!"); 2083 2084 printf("%04lx ", hword); 2085 } 2086 2087 for (i = 48; i >= 0; i -= 16) { 2088 hword = dword0 >> (i) & 0x00ff; 2089 2090 if ((hword < 0x30) || (hword > 0x39)) printf("!"); 2091 2092 printf("%04lx ", hword); 2093 } 2094 2095 local_sign = extract_national_decimal_sign(dword1, dword0); 2096 dissect_national_decimal_sign(local_sign); 2097 printf(" ] "); 2098 } 2099 2100 static void build_national_decimal_table(void) 2101 { 2102 long sign_index; 2103 long sign_value; 2104 unsigned long i = 0; 2105 int index; 2106 unsigned long value; 2107 2108 if (verbose) printf("%s\n",__FUNCTION__); 2109 national_decimal_table = malloc(MAX_NATIONAL_DECIMAL_TABLE_SIZE 2110 * sizeof (unsigned long)); 2111 2112 for (sign_index = 0; sign_index < NR_NATIONAL_DECIMAL_SIGNS; sign_index++) { 2113 sign_value = national_decimal_sign_codes[sign_index]; 2114 2115 for (index = 0; index < NR_NATIONAL_DECIMAL_VALUES; index++) { 2116 value = national_decimal_values[index]; 2117 2118 national_decimal_table[i] = 0x0001000100010001 * value; 2119 national_decimal_table[i+1] = 0x0001000100010000 * value; 2120 national_decimal_table[i+1] += sign_value ; 2121 2122 if (verbose > 3) { 2123 dissect_national_decimal(national_decimal_table[i+1], 2124 national_decimal_table[i]); 2125 printf("\n"); 2126 } 2127 i += 2; 2128 } 2129 #ifdef EXHAUSTIVE_TESTS 2130 { /* a few more for fun */ 2131 national_decimal_table[i] = 0x0031003200330034; 2132 national_decimal_table[i+1] = 0x0035003600370000; 2133 national_decimal_table[i+1] += sign_value ; 2134 2135 if (verbose > 3) { 2136 dissect_national_decimal(national_decimal_table[i+1], 2137 national_decimal_table[i]); 2138 printf("\n"); 2139 } 2140 2141 i += 2; 2142 national_decimal_table[i] = 0x0031003200330034; 2143 national_decimal_table[i+1] = 0x0035003600370000; 2144 national_decimal_table[i+1] += sign_value ; 2145 2146 if (verbose > 3) { 2147 dissect_national_decimal(national_decimal_table[i+1], 2148 national_decimal_table[i]); 2149 printf("\n"); 2150 } 2151 i += 2; 2152 } 2153 #endif 2154 } 2155 2156 if (verbose > 2) printf("\n"); 2157 2158 nb_national_decimal_entries = i; 2159 } 2160 2161 static void dump_national_decimal_table(void) { 2162 int i; 2163 2164 printf("national_decimal_table:\n"); 2165 2166 for (i = 0; i < nb_national_decimal_entries; i += 2) { 2167 printf("#%2d ", i); 2168 dissect_national_decimal(national_decimal_table[i+1], 2169 national_decimal_table[i]); 2170 printf("\n"); 2171 } 2172 } 2173 2174 2175 /* Zoned Decimals: 2176 * 2177 * When PS=0, do the following. 2178 * A valid encoding of a zoned decimal value requires the following. 2179 * The contents of bits 0:3 of byte 15 (sign code) can be any 2180 * value in the range 0x0 to 0xF. 2181 * The contents of bits 0:3 of bytes 0 to 14 (zone) must 2182 * be the value 0x3. 2183 * The contents of bits 4:7 of bytes 0 to 15 must 2184 * be a value in the range 0x0 to 0x9. 2185 * Zoned decimal values having a sign code of 0x0, 0x1, 0x2, 0x3, 2186 * 0x8, 0x9, 0xA, or 0xB are interpreted as positive values. 2187 * Zoned decimal values having a sign code of 0x4, 0x5, 0x6, 0x7, 2188 * 0xC, 0xD, 0xE, or 0xF are interpreted as negative values. 2189 :: 0,1,2,3, 8,9,a,b, are interpreted as positive. 2190 :: 4,5,6,7, c,d,e,f are interpreted as negative. 2191 * When PS=1, do the following. 2192 * A valid encoding of a zoned decimal source operand requires the following. 2193 * The contents of bits 0:3 of byte 15 (sign code) must be a value in the 2194 * range 0xA to 0xF. 2195 * The contents of bits 0:3 of bytes 0 to 14 (zone) must be the value 0xF. 2196 * The contents of bits 4:7 of bytes 0 to 15 must be a value in the 2197 * range 0x0 to 0x9. 2198 * Zoned decimal source operands having a sign code of 0xA, 0xC, 0xE, 2199 * or 0xF are interpreted as positive values. 2200 * Zoned decimal source operands having a sign code of 0xB or 0xD are 2201 * interpreted as negative values. 2202 :: a, c, e,f are interpreted as positive. 2203 :: b, d, are interpreted as negative. 2204 */ 2205 2206 /* a valid sign is anything in range 0-9,a-f, 2207 * For coverage that does not overwhelm, we have chosen to use 0,1,4,a,b,f. */ 2208 #define NM_ZONED_DECIMAL_SIGNS 6 2209 #define NM_ZONED_VALUES 5 /* 0,2,4,6,9 */ 2210 #define NM_PS_VALUES 2 /* 0,1 */ 2211 #define NM_ZONED_ADDITIONAL_PATTERNS 4 2212 #define MAX_ZONED_DECIMAL_TABLE_SIZE NM_ZONED_DECIMAL_SIGNS * NM_ZONED_VALUES * NM_ZONED_ADDITIONAL_PATTERNS * NM_PS_VALUES + 10 2213 2214 static unsigned long zoned_decimal_table_[MAX_ZONED_DECIMAL_TABLE_SIZE]; 2215 static unsigned long * zoned_decimal_table; 2216 unsigned long nb_zoned_decimal_entries; 2217 2218 static void dissect_zoned_decimal_sign(unsigned long local_sign, int ps) { 2219 if (ps == 0) { 2220 switch(local_sign) { 2221 case 0x0: case 0x1: case 0x2: case 0x3: 2222 case 0x8: case 0x9: case 0xa: case 0xb: 2223 printf("( + )"); 2224 break; 2225 2226 case 0x4: case 0x5: case 0x6: case 0x7: 2227 case 0xc: case 0xd: case 0xe: case 0xf: 2228 printf("( - )"); 2229 break; 2230 default: printf("zoned decimal (ps=%d). Unhandled sign value: %lx", 2231 ps, local_sign); 2232 } 2233 } 2234 2235 if (ps == 1) { 2236 switch(local_sign) { 2237 case 0xa: case 0xc: case 0xe: case 0xf: 2238 printf("( + )"); 2239 break; 2240 2241 case 0xb: case 0xd: 2242 printf("( - )"); 2243 break; 2244 2245 default: printf("zoned decimal (ps=%d). Unhandled sign value: %lx", 2246 ps, local_sign); 2247 } 2248 } 2249 } 2250 2251 /* Valid byte values within a zoned decimal are in the ranges of 2252 * 0x30..0x39 when PS==0, or 0xf0..0xff when PS==1. 2253 */ 2254 static void check_zoned_byte_validity(int byte, int ps) { 2255 if (ps == 0) { 2256 /* check the zone */ 2257 if (((byte & 0x30) != 0x30)) 2258 printf("!=30"); 2259 2260 } else { /* ps==1 */ 2261 if (((byte & 0xf0) != 0xf0)) 2262 printf("%x !=f0 ", byte ); 2263 } 2264 2265 /* check the numeric value */ 2266 if ((byte & 0x0f) > 0x9) 2267 printf("!(0..9)"); 2268 } 2269 2270 int extract_zoned_decimal_sign(unsigned long dword1, unsigned long dword0) { 2271 return ((dword1 & 0xf0) >> 4); 2272 } 2273 2274 static void dissect_zoned_decimal(unsigned long dword1, unsigned long dword0, 2275 int ps) 2276 { 2277 int i; 2278 int local_sign; 2279 int byte; 2280 2281 printf("zoned_decimal: ["); 2282 2283 for (i = 56; i >= 0; i -= 8) { 2284 byte = (dword1 >> (i)) & 0xff; 2285 check_zoned_byte_validity(byte, ps); 2286 printf(" %02x", byte); 2287 } 2288 2289 for (i = 56; i >= 0; i -= 8) { 2290 byte = (dword0 >> (i)) & 0x00ff; 2291 check_zoned_byte_validity(byte, ps); 2292 2293 if ((byte & 0xf) > 0x9) printf(" !(>9)"); 2294 printf(" %02x", byte); 2295 } 2296 2297 local_sign = extract_zoned_decimal_sign(dword1, dword0); 2298 dissect_zoned_decimal_sign(local_sign, ps); 2299 printf(" ]"); 2300 } 2301 2302 #ifdef EXHAUSTIVE_TESTS 2303 // Randomly chosen exhaustive coverage for k includes values: 0,2,4,7,9 2304 # define SELECTIVE_INCREMENT_ZONED(k) \ 2305 if (k == 7) k = 9; \ 2306 else if (k == 4) k = 7; \ 2307 else if (k == 2) k = 4; \ 2308 else if (k == 0) k = 2; \ 2309 else k++; 2310 // Randomly chosen exhaustive coverage for signs includes values: 0,1,4,a,b,f 2311 # define SELECTIVE_INCREMENT_SIGNS(signs) \ 2312 if (signs == 0x0) signs = 0x1; \ 2313 else if (signs == 0x1) signs = 0x4; \ 2314 else if (signs == 0x4) signs = 0xa; \ 2315 else if (signs == 0xa) signs = 0xb; \ 2316 else if (signs == 0xb) signs = 0xf; \ 2317 else signs++; 2318 #else 2319 // Randomly chosen coverage for k includes values: 0,7,9 2320 # define SELECTIVE_INCREMENT_ZONED(k) \ 2321 if (k == 7) k = 9; \ 2322 else if (k == 0) k = 7; \ 2323 else k++; 2324 // Randomly chosen coverage for signs includes values: 0,4,b,f 2325 # define SELECTIVE_INCREMENT_SIGNS(signs) \ 2326 if (signs == 0x0) signs = 0x4; \ 2327 else if (signs == 0x4) signs = 0xb; \ 2328 else if (signs == 0xb) signs = 0xf; \ 2329 else signs++; 2330 #endif 2331 2332 2333 static void build_zoned_decimal_table(void) 2334 { 2335 unsigned long signs; 2336 unsigned long i; 2337 int k; 2338 int ps; 2339 int signs_start,signs_end; 2340 2341 if (verbose) printf("%s\n", __FUNCTION__); 2342 2343 zoned_decimal_table = zoned_decimal_table_; 2344 i = 0; 2345 2346 for (ps = 0; ps <= 1; ps++) { 2347 if (ps == 0) { 2348 signs_start = 0; 2349 signs_end = 0xf; 2350 2351 } else { 2352 signs_start = 0xa; 2353 signs_end = 0xf; 2354 } 2355 2356 for (signs = signs_start; 2357 signs <= signs_end; /* signs selectively updated below */) { 2358 2359 if (verbose > 2) printf("ps=%d sign:%lx\n", ps, signs); 2360 2361 for (k = 0 ; k < 9; /* k selectively updated below */) { 2362 if (ps == 0) { 2363 zoned_decimal_table[i] = 0x3030303030303030; // set bits 0:3 of bytes 0..7. 2364 zoned_decimal_table[i+1] = 0x3030303030303000; // bits 0:3 of bytes 8..14 must be 0x3 2365 2366 } else { 2367 zoned_decimal_table[i] = 0xf0f0f0f0f0f0f0f0; // set bits 0:3 of bytes 0..7. 2368 zoned_decimal_table[i+1] = 0xf0f0f0f0f0f0f000; // bits 0:3 of bytes 8..14 must be 0x3 2369 } 2370 2371 zoned_decimal_table[i] += 0x010101010101010 * k; // set bits 4..7 of bytes 0..7. 2372 zoned_decimal_table[i+1] += 0x010101010101000 * k; // bits 4:7 of bytes 8..15 must be 0..9. 2373 zoned_decimal_table[i+1] += (signs << 4); // bits 0:3 of byte 15 is the sign. 2374 if (verbose > 3) { 2375 dissect_zoned_decimal(zoned_decimal_table[i+1], 2376 zoned_decimal_table[i], ps); 2377 printf("\n"); 2378 } 2379 i += 2; 2380 SELECTIVE_INCREMENT_ZONED(k) 2381 } 2382 2383 /* add a few more patterns outside of the k patterns. */ 2384 if (ps == 0) { 2385 zoned_decimal_table[i] = 0x3030303030303030; 2386 zoned_decimal_table[i+1] = 0x3030303030303000; 2387 2388 } else { 2389 zoned_decimal_table[i] = 0xf0f0f0f0f0f0f0f0; 2390 zoned_decimal_table[i+1] = 0xf0f0f0f0f0f0f000; 2391 } 2392 2393 zoned_decimal_table[i] += 0x0908070605040302; 2394 zoned_decimal_table[i+1] += 0x0102030405060700; 2395 zoned_decimal_table[i+1] += (signs<<4); // bits 0:3 of byte 15. 2396 2397 if (verbose > 3) { 2398 dissect_zoned_decimal(zoned_decimal_table[i+1], 2399 zoned_decimal_table[i], ps); 2400 printf("\n"); 2401 } 2402 2403 i += 2; 2404 SELECTIVE_INCREMENT_SIGNS(signs) 2405 } /* signs loop */ 2406 } /* ps loop */ 2407 2408 nb_zoned_decimal_entries = i; 2409 } 2410 2411 static void dump_zoned_decimal_table(void) { 2412 int i; 2413 int ps; 2414 2415 for (ps = 0; ps <= 1; ps++) { 2416 printf("zoned_decimal_table ps=%d:\n", ps); 2417 2418 for (i = 0; i < nb_zoned_decimal_entries; i += 2) { 2419 printf("#%2d ", i); 2420 dissect_zoned_decimal(zoned_decimal_table[i+1], 2421 zoned_decimal_table[i], ps); 2422 printf("\n"); 2423 } 2424 } 2425 } 2426 2427 /* Build table containing shift and truncate values */ 2428 #define MAX_DECIMAL_SHIFT_TABLE_SIZE 64 2429 2430 static unsigned long * decimal_shift_table; 2431 unsigned long nb_decimal_shift_entries; 2432 2433 static void build_decimal_shift_table(void) { 2434 unsigned long i = 0; 2435 unsigned long value; 2436 2437 if (verbose) printf("%s\n",__FUNCTION__); 2438 2439 decimal_shift_table = malloc(MAX_DECIMAL_SHIFT_TABLE_SIZE 2440 * sizeof (unsigned long)); 2441 2442 for (value = 0; value <= 31; value++) { 2443 decimal_shift_table[i] = value; 2444 decimal_shift_table[i+1] = 0; 2445 i += 2; 2446 } 2447 2448 if (verbose>2) printf("\n"); 2449 2450 nb_decimal_shift_entries = i; 2451 } 2452 2453 static void dump_decimal_shift_table(void) { 2454 int i; 2455 2456 printf("decimal_shift_table:\n"); 2457 2458 for (i = 0; i < nb_decimal_shift_entries; i += 2) { 2459 printf("i=:%2d ", i); 2460 printf(" 0x%2lx 0x%2lx ", decimal_shift_table[i], 2461 decimal_shift_table[i+1]); 2462 printf("\n"); 2463 } 2464 } 2465
