| /* Copyright (C) 2012 IBM |
| |
| Author: Maynard Johnson <maynardj@us.ibm.com> |
| |
| This program is free software; you can redistribute it and/or |
| modify it under the terms of the GNU General Public License as |
| published by the Free Software Foundation; either version 2 of the |
| License, or (at your option) any later version. |
| |
| This program is distributed in the hope that it will be useful, but |
| WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| General Public License for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with this program; if not, write to the Free Software |
| Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA |
| 02111-1307, USA. |
| |
| The GNU General Public License is contained in the file COPYING. |
| */ |
| |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <stdint.h> |
| #include <string.h> |
| |
| #if defined(HAS_DFP) |
| |
| register double f14 __asm__ ("fr14"); |
| register double f15 __asm__ ("fr15"); |
| register double f16 __asm__ ("fr16"); |
| register double f17 __asm__ ("fr17"); |
| register double f18 __asm__ ("fr18"); |
| register double f19 __asm__ ("fr19"); |
| |
| |
| typedef unsigned char Bool; |
| #define True 1 |
| #define False 0 |
| |
| |
| #define ALLCR "cr0","cr1","cr2","cr3","cr4","cr5","cr6","cr7" |
| |
| #define SET_CR(_arg) \ |
| __asm__ __volatile__ ("mtcr %0" : : "b"(_arg) : ALLCR ); |
| |
| #define SET_XER(_arg) \ |
| __asm__ __volatile__ ("mtxer %0" : : "b"(_arg) : "xer" ); |
| |
| #define GET_CR(_lval) \ |
| __asm__ __volatile__ ("mfcr %0" : "=b"(_lval) ) |
| |
| #define GET_XER(_lval) \ |
| __asm__ __volatile__ ("mfxer %0" : "=b"(_lval) ) |
| |
| #define GET_CR_XER(_lval_cr,_lval_xer) \ |
| do { GET_CR(_lval_cr); GET_XER(_lval_xer); } while (0) |
| |
| #define SET_CR_ZERO \ |
| SET_CR(0) |
| |
| #define SET_XER_ZERO \ |
| SET_XER(0) |
| |
| #define SET_CR_XER_ZERO \ |
| do { SET_CR_ZERO; SET_XER_ZERO; } while (0) |
| |
| #define SET_FPSCR_ZERO \ |
| do { double _d = 0.0; \ |
| __asm__ __volatile__ ("mtfsf 0xFF, %0" : : "f"(_d) ); \ |
| } while (0) |
| |
| #define GET_FPSCR(_arg) \ |
| __asm__ __volatile__ ("mffs %0" : "=f"(_arg) ) |
| |
| #define SET_FPSCR_DRN \ |
| __asm__ __volatile__ ("mtfsf 1, %0, 0, 1" : : "f"(f14) ) |
| |
| |
| // The assembly-level instructions being tested |
| static void _test_drintx(int R, int RMC) |
| { |
| if (RMC < 0 || RMC > 3 || R < 0 || R > 1) { |
| fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| if (R) |
| __asm__ __volatile__ ("drintx 1, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintx 0, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 1: |
| if (R) |
| __asm__ __volatile__ ("drintx 1, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintx 0, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 2: |
| if (R) |
| __asm__ __volatile__ ("drintx 1, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintx 0, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 3: |
| if (R) |
| __asm__ __volatile__ ("drintx 1, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintx 0, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_drintn(int R, int RMC) |
| { |
| if (RMC < 0 || RMC > 3 || R < 0 || R > 1) { |
| fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| if (R) |
| __asm__ __volatile__ ("drintn 1, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintn 0, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 1: |
| if (R) |
| __asm__ __volatile__ ("drintn 1, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintn 0, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 2: |
| if (R) |
| __asm__ __volatile__ ("drintn 1, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintn 0, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 3: |
| if (R) |
| __asm__ __volatile__ ("drintn 1, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintn 0, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| |
| static void _test_diex(int a __attribute__((unused)), int b __attribute__((unused))) |
| { |
| __asm__ __volatile__ ("diex %0, %1, %2" : "=f" (f18) : "f" (f14),"f" (f16)); |
| } |
| |
| static void _test_dxex(int a __attribute__((unused)), int b __attribute__((unused))) |
| { |
| __asm__ __volatile__ ("dxex %0, %1" : "=f" (f18) : "f" (f16)); |
| } |
| |
| static void _test_dcmpo(int BF, int x __attribute__((unused))) |
| { |
| if (BF < 0 || BF > 7) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", BF); |
| return; |
| } |
| switch (BF) { |
| case 0: |
| __asm__ __volatile__ ("dcmpo 0, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("dcmpo 1, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("dcmpo 2, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("dcmpo 3, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 4: |
| __asm__ __volatile__ ("dcmpo 4, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dcmpo 5, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 6: |
| __asm__ __volatile__ ("dcmpo 6, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 7: |
| __asm__ __volatile__ ("dcmpo 7, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_dcmpu(int BF, int x __attribute__((unused))) |
| { |
| if (BF < 0 || BF > 7) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", BF); |
| return; |
| } |
| switch (BF) { |
| case 0: |
| __asm__ __volatile__ ("dcmpu 0, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("dcmpu 1, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("dcmpu 2, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("dcmpu 3, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 4: |
| __asm__ __volatile__ ("dcmpu 4, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dcmpu 5, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 6: |
| __asm__ __volatile__ ("dcmpu 6, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 7: |
| __asm__ __volatile__ ("dcmpu 7, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| // Quad instruction testing |
| static void _test_drintxq(int R, int RMC) |
| { |
| if (RMC < 0 || RMC > 3 || R < 0 || R > 1) { |
| fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| if (R) |
| __asm__ __volatile__ ("drintxq 1, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintxq 0, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 1: |
| if (R) |
| __asm__ __volatile__ ("drintxq 1, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintxq 0, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 2: |
| if (R) |
| __asm__ __volatile__ ("drintxq 1, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintxq 0, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 3: |
| if (R) |
| __asm__ __volatile__ ("drintxq 1, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintxq 0, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_drintnq(int R, int RMC) |
| { |
| if (RMC < 0 || RMC > 3 || R < 0 || R > 1) { |
| fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", R, RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| if (R) |
| __asm__ __volatile__ ("drintnq 1, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintnq 0, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 1: |
| if (R) |
| __asm__ __volatile__ ("drintnq 1, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintnq 0, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 2: |
| if (R) |
| __asm__ __volatile__ ("drintnq 1, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintnq 0, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 3: |
| if (R) |
| __asm__ __volatile__ ("drintnq 1, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| else |
| __asm__ __volatile__ ("drintnq 0, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_diexq(int a __attribute__((unused)), int b __attribute__((unused))) |
| { |
| __asm__ __volatile__ ("diexq %0, %1, %2" : "=f" (f18) : "f" (f14),"f" (f16)); |
| } |
| |
| static void _test_dxexq(int a __attribute__((unused)), int b __attribute__((unused))) |
| { |
| __asm__ __volatile__ ("dxexq %0, %1" : "=f" (f18) : "f" (f16)); |
| } |
| |
| static void _test_dcmpoq(int BF, int x __attribute__((unused))) |
| { |
| if (BF < 0 || BF > 7) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", BF ); |
| return; |
| } |
| switch (BF) { |
| case 0: |
| __asm__ __volatile__ ("dcmpoq 0, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("dcmpoq 1, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("dcmpoq 2, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("dcmpoq 3, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 4: |
| __asm__ __volatile__ ("dcmpoq 4, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dcmpoq 5, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 6: |
| __asm__ __volatile__ ("dcmpoq 6, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 7: |
| __asm__ __volatile__ ("dcmpoq 7, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_dcmpuq(int BF, int x __attribute__((unused))) |
| { |
| if (BF < 0 || BF > 7) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", BF); |
| return; |
| } |
| switch (BF) { |
| case 0: |
| __asm__ __volatile__ ("dcmpuq 0, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("dcmpuq 1, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("dcmpuq 2, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("dcmpuq 3, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 4: |
| __asm__ __volatile__ ("dcmpuq 4, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dcmpuq 5, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 6: |
| __asm__ __volatile__ ("dcmpuq 6, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| case 7: |
| __asm__ __volatile__ ("dcmpuq 7, %0, %1" : : "f" (f14),"f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_drrnd(int x __attribute__((unused)), int RMC) |
| { |
| if (RMC < 0 || RMC > 31) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| __asm__ __volatile__ ("drrnd %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("drrnd %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("drrnd %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("drrnd %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_drrndq(int x __attribute__((unused)), int RMC) |
| { |
| if (RMC < 0 || RMC > 3) { |
| fprintf(stderr, "Invalid input to asm test: a=%dn", RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| __asm__ __volatile__ ("drrndq %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("drrndq %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("drrndq %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("drrndq %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_dqua(int x __attribute__((unused)), int RMC) |
| { |
| if (RMC < 0 || RMC > 3) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| __asm__ __volatile__ ("dqua %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("dqua %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("dqua %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("dqua %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_dquaq(int x __attribute__((unused)), int RMC) |
| { |
| if (RMC < 0 || RMC > 3) { |
| fprintf(stderr, "Invalid input to asm test: a=%d\n", RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| __asm__ __volatile__ ("dquaq %0, %1, %2, 0" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 1: |
| __asm__ __volatile__ ("dquaq %0, %1, %2, 1" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 2: |
| __asm__ __volatile__ ("dquaq %0, %1, %2, 2" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| case 3: |
| __asm__ __volatile__ ("dquaq %0, %1, %2, 3" : "=f" (f18) : "f" (f14), "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static int TE_vals[] = { -16, -2, 0, 5}; |
| #define TE_VAL_LEN sizeof(TE_vals)/sizeof(int) |
| static Bool __is_TE_val(int x) |
| { |
| int i; |
| for (i = 0; i < TE_VAL_LEN; i++) { |
| if (x==TE_vals[i]) |
| return True; |
| } |
| return False; |
| } |
| |
| static void _test_dquai(int TE, int RMC) |
| { |
| if (RMC < 0 || RMC > 3 || !__is_TE_val(TE)) { |
| fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", TE, RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquai -16, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquai -2, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquai 0, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquai 5, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 1: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquai -16, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquai -2, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquai 0, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquai 5, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 2: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquai -16, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquai -2, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquai 0, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquai 5, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 3: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquai -16, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquai -2, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquai 0, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquai 5, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| static void _test_dquaiq(int TE, int RMC) |
| { |
| if (RMC < 0 || RMC > 3 || !__is_TE_val(TE)) { |
| fprintf(stderr, "Invalid inputs to asm test: a=%d, b=%d\n", TE, RMC); |
| return; |
| } |
| switch (RMC) { |
| case 0: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquaiq -16, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquaiq -2, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquaiq 0, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquaiq 5, %0, %1, 0" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 1: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquaiq -16, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquaiq -2, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquaiq 0, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquaiq 5, %0, %1, 1" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 2: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquaiq -16, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquaiq -2, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquaiq 0, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquaiq 5, %0, %1, 2" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| case 3: |
| switch (TE) { |
| case -16: |
| __asm__ __volatile__ ("dquaiq -16, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| case -2: |
| __asm__ __volatile__ ("dquaiq -2, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| case 0: |
| __asm__ __volatile__ ("dquaiq 0, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| case 5: |
| __asm__ __volatile__ ("dquaiq 5, %0, %1, 3" : "=f" (f18) : "f" (f16)); |
| break; |
| default: |
| break; |
| } |
| break; |
| default: |
| break; |
| } |
| } |
| |
| |
| typedef void (*test_func_t)(int a, int b); |
| typedef void (*test_driver_func_t)(void); |
| typedef struct test_table |
| { |
| test_driver_func_t test_category; |
| char * name; |
| } test_table_t; |
| |
| /* |
| * 345.0DD (0x2207c00000000000 0xe50) |
| * 1.2300e+5DD (0x2207c00000000000 0x14c000) |
| * -16.0DD (0xa207c00000000000 0xe0) |
| * 0.00189DD (0x2206c00000000000 0xcf) |
| * -4.1235DD (0xa205c00000000000 0x10a395bcf) |
| * 9.8399e+20DD (0x2209400000000000 0x253f1f534acdd4) |
| * 0DD (0x2208000000000000 0x0) |
| * 0DD (0x2208000000000000 0x0) |
| * infDD (0x7800000000000000 0x0) |
| * nanDD (0x7c00000000000000 0x0 |
| */ |
| static unsigned long long dfp128_vals[] = { |
| // Some finite numbers |
| 0x2207c00000000000ULL, 0x0000000000000e50ULL, |
| 0x2207c00000000000ULL, 0x000000000014c000ULL, |
| 0xa207c00000000000ULL, 0x00000000000000e0ULL, |
| 0x2206c00000000000ULL, 0x00000000000000cfULL, |
| 0xa205c00000000000ULL, 0x000000010a395bcfULL, |
| 0x6209400000fd0000ULL, 0x00253f1f534acdd4ULL, // huge number |
| 0x000400000089b000ULL, 0x0a6000d000000049ULL, // very small number |
| // flavors of zero |
| 0x2208000000000000ULL, 0x0000000000000000ULL, |
| 0xa208000000000000ULL, 0x0000000000000000ULL, // negative |
| 0xa248000000000000ULL, 0x0000000000000000ULL, |
| // flavors of NAN |
| 0x7c00000000000000ULL, 0x0000000000000000ULL, // quiet |
| 0xfc00000000000000ULL, 0xc00100035b007700ULL, |
| 0x7e00000000000000ULL, 0xfe000000d0e0a0d0ULL, // signaling |
| // flavors of Infinity |
| 0x7800000000000000ULL, 0x0000000000000000ULL, |
| 0xf800000000000000ULL, 0x0000000000000000ULL, // negative |
| 0xf900000000000000ULL, 0x0000000000000000ULL |
| }; |
| |
| static unsigned long long dfp64_vals[] = { |
| // various finite numbers |
| 0x2234000000000e50ULL, |
| 0x223400000014c000ULL, |
| 0xa2340000000000e0ULL,// negative |
| 0x22240000000000cfULL, |
| 0xa21400010a395bcfULL,// negative |
| 0x6e4d3f1f534acdd4ULL,// huge number |
| 0x000400000089b000ULL,// very small number |
| // flavors of zero |
| 0x2238000000000000ULL, |
| 0xa238000000000000ULL, |
| 0x4248000000000000ULL, |
| // flavors of NAN |
| 0x7e34000000000111ULL, |
| 0xfe000000d0e0a0d0ULL,//signaling |
| 0xfc00000000000000ULL,//quiet |
| // flavors of Infinity |
| 0x7800000000000000ULL, |
| 0xf800000000000000ULL,//negative |
| 0x7a34000000000000ULL, |
| }; |
| |
| // Both Long and Quad arrays of DFP values should have the same length. |
| // If that length is changed, t |
| #define NUM_DFP_VALS (sizeof(dfp64_vals)/8) |
| |
| typedef struct dfp_test_args { |
| int fra_idx; |
| int frb_idx; |
| } dfp_test_args_t; |
| |
| |
| // Index pairs from dfp64_vals array to be used with dfp_two_arg_tests |
| static dfp_test_args_t dfp_2args_x1[] = { |
| {0, 1}, |
| {2, 1}, |
| {3, 4}, |
| {0, 6}, |
| {2, 4}, |
| {5, 1}, |
| {5, 2}, |
| {7, 1}, |
| {7, 2}, |
| {8, 0}, |
| {8, 1}, |
| {8, 2}, |
| {7, 8}, |
| {12, 14}, |
| {12, 1}, |
| {12, 13}, |
| {12, 12}, |
| {12, 11}, |
| {11, 14}, |
| {11, 0}, |
| {11, 13}, |
| {11, 11}, |
| {14, 14}, |
| {14, 3}, |
| {14, 15}, |
| }; |
| |
| typedef enum { |
| LONG_TEST, |
| QUAD_TEST |
| } precision_type_t; |
| |
| typedef struct dfp_test |
| { |
| test_func_t test_func; |
| const char * name; |
| dfp_test_args_t * targs; |
| int num_tests; |
| precision_type_t precision; |
| const char * op; |
| } dfp_test_t; |
| |
| typedef struct dfp_one_arg_test |
| { |
| test_func_t test_func; |
| const char * name; |
| precision_type_t precision; |
| const char * op; |
| } dfp_one_arg_test_t; |
| |
| |
| static dfp_one_arg_test_t |
| dfp_quai_tests[] = { |
| { &_test_dquai, "dquai", LONG_TEST, "[QI]"}, |
| { &_test_dquaiq, "dquaiq", QUAD_TEST, "[QI]"}, |
| { NULL, NULL, 0, NULL} |
| }; |
| |
| static void test_dfp_quai_ops(void) |
| { |
| test_func_t func; |
| unsigned long long u0, u0x; |
| double res, d0, *d0p, d0x, *d0xp; |
| |
| int k = 0; |
| u0 = u0x = 0; |
| d0p = &d0; |
| d0xp = &d0x; |
| |
| while ((func = dfp_quai_tests[k].test_func)) { |
| int i; |
| dfp_one_arg_test_t test_def = dfp_quai_tests[k]; |
| |
| for (i = 0; i < NUM_DFP_VALS; i++) { |
| int TE, RMC; |
| |
| if (test_def.precision == LONG_TEST) { |
| u0 = dfp64_vals[i]; |
| } else { |
| u0 = dfp128_vals[i * 2]; |
| u0x = dfp128_vals[(i * 2) + 1]; |
| } |
| *(unsigned long long *)d0p = u0; |
| f16 = d0; |
| if (test_def.precision == QUAD_TEST) { |
| *(unsigned long long *)d0xp = u0x; |
| f17 = d0x; |
| } |
| |
| for (TE = 0; TE < TE_VAL_LEN; TE++) { |
| for (RMC = 0; RMC < 4; RMC++) { |
| (*func)(TE_vals[TE], RMC); |
| res = f18; |
| printf("%s (RMC=%2d, TE=%3d) %s %016llx", test_def.name, RMC, |
| TE_vals[TE], test_def.op, u0); |
| if (test_def.precision == LONG_TEST) { |
| printf(" => %016llx\n", |
| *((unsigned long long *)(&res))); |
| } else { |
| double resx = f19; |
| printf(" %016llx ==> %016llx %016llx\n", |
| u0x, *((unsigned long long *)(&res)), *((unsigned long long *)(&resx))); |
| } |
| } |
| } |
| } |
| k++; |
| printf( "\n" ); |
| } |
| } |
| |
| |
| static dfp_test_t |
| dfp_qua_tests[] = { |
| { &_test_dqua, "dqua", dfp_2args_x1, 25, LONG_TEST, "[Q]"}, |
| { &_test_dquaq, "dquaq", dfp_2args_x1, 25, QUAD_TEST, "[Q]"}, |
| { NULL, NULL, NULL, 0, 0, NULL} |
| }; |
| |
| static void test_dfp_qua_ops(void) |
| { |
| test_func_t func; |
| unsigned long long u0, u0x, u1, u1x; |
| double res, d0, d1, *d0p, *d1p; |
| double d0x, d1x, *d0xp, *d1xp; |
| int k = 0; |
| u0x = u1x = 0; |
| d0p = &d0; |
| d0xp = &d0x; |
| d1p = &d1; |
| d1xp = &d1x; |
| |
| while ((func = dfp_qua_tests[k].test_func)) { |
| int i, RMC; |
| dfp_test_t test_def = dfp_qua_tests[k]; |
| |
| for (i = 0; i < test_def.num_tests; i++) { |
| if (test_def.precision == LONG_TEST) { |
| u0 = dfp64_vals[test_def.targs[i].fra_idx]; |
| u1 = dfp64_vals[test_def.targs[i].frb_idx]; |
| } else { |
| u0 = dfp128_vals[test_def.targs[i].fra_idx * 2]; |
| u0x = dfp128_vals[(test_def.targs[i].fra_idx * 2) + 1]; |
| u1 = dfp128_vals[test_def.targs[i].frb_idx * 2]; |
| u1x = dfp128_vals[(test_def.targs[i].frb_idx * 2) + 1]; |
| } |
| *(unsigned long long *)d0p = u0; |
| *(unsigned long long *)d1p = u1; |
| f14 = d0; |
| f16 = d1; |
| if (test_def.precision == QUAD_TEST) { |
| *(unsigned long long *)d0xp = u0x; |
| *(unsigned long long *)d1xp = u1x; |
| f15 = d0x; |
| f17 = d1x; |
| } |
| for (RMC = 0; RMC < 4; RMC++) { |
| (*func)(-1, RMC); |
| res = f18; |
| printf("%s (RMC=%2d) %s %016llx", test_def.name, RMC, test_def.op, u0); |
| if (test_def.precision == LONG_TEST) { |
| printf(", %016llx => %016llx\n", u1, *((unsigned long long *)(&res))); |
| } else { |
| double resx = f19; |
| printf(" %016llx, %016llx %016llx ==> %016llx %016llx\n",u0x, u1, u1x, |
| *((unsigned long long *)(&res)), *((unsigned long long *)(&resx))); |
| } |
| } |
| } |
| k++; |
| printf( "\n" ); |
| } |
| } |
| |
| |
| static dfp_one_arg_test_t |
| dfp_rrnd_tests[] = { |
| { &_test_drrnd, "drrnd", LONG_TEST, "[RR]"}, |
| { &_test_drrndq, "drrndq", QUAD_TEST, "[RR]"}, |
| { NULL, NULL, 0, NULL} |
| }; |
| |
| static void test_dfp_rrnd_ops(void) |
| { |
| test_func_t func; |
| unsigned long long u0, u0x; |
| double res, d0, *d0p, d0x, *d0xp, reference_sig, *reference_sig_p; |
| long long reference_sig_vals[] = {0ULL, 2ULL, 6ULL, 63ULL}; |
| int num_reference_sig_vals = sizeof(reference_sig_vals)/sizeof(long long); |
| |
| int k = 0; |
| u0 = u0x = 0; |
| d0p = &d0; |
| d0xp = &d0x; |
| reference_sig_p = &reference_sig; |
| |
| while ((func = dfp_rrnd_tests[k].test_func)) { |
| int i, j; |
| dfp_one_arg_test_t test_def = dfp_rrnd_tests[k]; |
| |
| for (i = 0; i < NUM_DFP_VALS; i++) { |
| int RMC; |
| |
| if (test_def.precision == LONG_TEST) { |
| u0 = dfp64_vals[i]; |
| } else { |
| u0 = dfp128_vals[i * 2]; |
| u0x = dfp128_vals[(i * 2) + 1]; |
| } |
| *(unsigned long long *)d0p = u0; |
| f16 = d0; |
| if (test_def.precision == QUAD_TEST) { |
| *(unsigned long long *)d0xp = u0x; |
| f17 = d0x; |
| } |
| |
| for (j = 0; j < num_reference_sig_vals; j++) { |
| *(long long *)reference_sig_p = reference_sig_vals[j]; |
| f14 = reference_sig; |
| for (RMC = 0; RMC < 4; RMC++) { |
| (*func)(-1, RMC); |
| res = f18; |
| printf("%s (RMC=%d, ref sig=%d) %s%016llx", test_def.name, RMC, |
| (int)reference_sig_vals[j], test_def.op, u0); |
| if (test_def.precision == LONG_TEST) { |
| printf(" => %016llx\n", |
| *((unsigned long long *)(&res))); |
| } else { |
| double resx = f19; |
| printf(" %016llx ==> %016llx %016llx\n", |
| u0x, *((unsigned long long *)(&res)), *((unsigned long long *)(&resx))); |
| } |
| } |
| } |
| } |
| k++; |
| printf( "\n" ); |
| } |
| } |
| |
| |
| static dfp_one_arg_test_t |
| dfp_xiex_tests[] = { |
| { &_test_diex, "diex", LONG_TEST, ">>"}, |
| { &_test_diexq, "diexq", QUAD_TEST, ">>"}, |
| { &_test_dxex, "dxex", LONG_TEST, "<<"}, |
| { &_test_dxexq, "dxexq", QUAD_TEST, "<<"}, |
| { NULL, NULL, 0, NULL} |
| }; |
| |
| static void test_dfp_xiex_ops(void) |
| { |
| test_func_t func; |
| unsigned long long u0, u0x; |
| double res, d0, *d0p, d0x, *d0xp, target_exp, *target_exp_p; |
| /* The first two positions are placeholders and will be filled in later, |
| * based on the precision of the DFP argument. |
| */ |
| long long target_exp_vals[] = {0ULL, 0ULL, 0ULL, -1ULL, -2ULL, -3ULL, -4ULL, -5ULL}; |
| int num_exp_vals = sizeof(target_exp_vals)/sizeof(long long); |
| int k = 0; |
| u0 = u0x = 0; |
| d0p = &d0; |
| d0xp = &d0x; |
| target_exp_p = &target_exp; |
| |
| while ((func = dfp_xiex_tests[k].test_func)) { |
| int i; |
| Bool insert_insn = False; |
| dfp_one_arg_test_t test_def = dfp_xiex_tests[k]; |
| |
| if (!strncmp(test_def.name, "di", 2)) |
| insert_insn = True; |
| |
| if (test_def.precision == QUAD_TEST) { |
| target_exp_vals[0] = 12288ULL; // > max biased exponent |
| target_exp_vals[1] = 5235ULL; |
| } else { |
| target_exp_vals[0] = 768ULL; // > max biased exponent |
| target_exp_vals[1] = 355ULL; |
| } |
| |
| for (i = 0; i < NUM_DFP_VALS; i++) { |
| unsigned int j; |
| |
| if (test_def.precision == QUAD_TEST) { |
| u0 = dfp128_vals[i * 2]; |
| u0x = dfp128_vals[(i * 2) + 1]; |
| } else { |
| u0 = dfp64_vals[i]; |
| } |
| *(unsigned long long *)d0p = u0; |
| f16 = d0; |
| if (test_def.precision == QUAD_TEST) { |
| *(unsigned long long *)d0xp = u0x; |
| f17 = d0x; |
| } |
| |
| if (!insert_insn) { |
| // This is just for extract insns (dexex[q]) |
| (*func)(0, 0); |
| res = f18; |
| printf("%s %s ", test_def.name, test_def.op); |
| if (test_def.precision == LONG_TEST) { |
| printf("%016llx => %016llx\n", u0, |
| *((unsigned long long *)(&res))); |
| } else { |
| double resx = f19; |
| printf("%016llx %016llx ==> %016llx %016llx\n", u0, u0x, |
| *((unsigned long long *)(&res)), *((unsigned long long *)(&resx))); |
| } |
| continue; |
| } |
| // The following for-loop is just for insert insns (diex[q]) |
| for (j = 0; j < num_exp_vals; j++) { |
| *(long long *)target_exp_p = target_exp_vals[j]; |
| f14 = target_exp; |
| (*func)(0, 0); |
| res = f18; |
| printf("%s %s %5d, ", test_def.name, test_def.op, (int)target_exp_vals[j]); |
| |
| if (test_def.precision == LONG_TEST) { |
| printf("%016llx => %016llx\n", u0, |
| *((unsigned long long *)(&res))); |
| } else { |
| double resx = f19; |
| printf("%016llx %016llx ==> %016llx %016llx\n", u0, u0x, |
| *((unsigned long long *)(&res)), *((unsigned long long *)(&resx))); |
| } |
| } |
| } |
| k++; |
| printf( "\n" ); |
| } |
| } |
| |
| static dfp_one_arg_test_t |
| dfp_rint_tests[] = { |
| { &_test_drintn, "drintn", LONG_TEST, "~"}, |
| { &_test_drintnq, "drintnq", QUAD_TEST, "~"}, |
| { &_test_drintx, "drintx", LONG_TEST, "~"}, |
| { &_test_drintxq, "drintxq", QUAD_TEST, "~"}, |
| { NULL, NULL, 0, NULL} |
| }; |
| |
| static void test_dfp_rint_ops(void) |
| { |
| test_func_t func; |
| unsigned long long u0, u0x; |
| double res, d0, *d0p, d0x, *d0xp; |
| int k = 0; |
| u0 = u0x = 0; |
| d0p = &d0; |
| d0xp = &d0x; |
| |
| while ((func = dfp_rint_tests[k].test_func)) { |
| int i; |
| dfp_one_arg_test_t test_def = dfp_rint_tests[k]; |
| |
| for (i = 0; i < NUM_DFP_VALS; i++) { |
| int R, RMC; |
| |
| if (test_def.precision == LONG_TEST) { |
| u0 = dfp64_vals[i]; |
| } else { |
| u0 = dfp128_vals[i * 2]; |
| u0x = dfp128_vals[(i * 2) + 1]; |
| } |
| *(unsigned long long *)d0p = u0; |
| f16 = d0; |
| if (test_def.precision == QUAD_TEST) { |
| *(unsigned long long *)d0xp = u0x; |
| f17 = d0x; |
| } |
| |
| for (R = 0; R < 2; R++) { |
| for (RMC = 0; RMC < 4; RMC++) { |
| (*func)(R, RMC); |
| res = f18; |
| printf("%s (RM=%d) %s%016llx", test_def.name, (RMC + (R << 2)), test_def.op, u0); |
| if (test_def.precision == LONG_TEST) { |
| printf(" => %016llx\n", |
| *((unsigned long long *)(&res))); |
| } else { |
| double resx = f19; |
| printf(" %016llx ==> %016llx %016llx\n", |
| u0x, *((unsigned long long *)(&res)), *((unsigned long long *)(&resx))); |
| } |
| } |
| } |
| } |
| k++; |
| printf( "\n" ); |
| } |
| } |
| |
| static dfp_test_t |
| dfp_cmp_tests[] = { |
| { &_test_dcmpo, "dcmpo", dfp_2args_x1, 25, LONG_TEST, "<>"}, |
| { &_test_dcmpoq, "dcmpoq", dfp_2args_x1, 25, QUAD_TEST, "<>"}, |
| { &_test_dcmpu, "dcmpu", dfp_2args_x1, 25, LONG_TEST, "<>"}, |
| { &_test_dcmpuq, "dcmpuq", dfp_2args_x1, 25, QUAD_TEST, "<>"}, |
| { NULL, NULL, NULL, 0, 0, NULL} |
| }; |
| |
| static void test_dfp_cmp_ops(void) |
| { |
| test_func_t func; |
| unsigned long long u0, u0x, u1, u1x; |
| double d0, d1, *d0p, *d1p; |
| double d0x, d1x, *d0xp, *d1xp; |
| /* BF is a 3-bit instruction field that indicates the CR field in which the |
| * result of the compare should be placed. We won't iterate through all |
| * 8 possible BF values since storing compare results to a given field is |
| * a well-tested mechanism in VEX. But we will test two BF values, just as |
| * a sniff-test. |
| */ |
| int k = 0, BF; |
| u0x = u1x = 0; |
| d0p = &d0; |
| d0xp = &d0x; |
| d1p = &d1; |
| d1xp = &d1x; |
| |
| while ((func = dfp_cmp_tests[k].test_func)) { |
| int i, repeat = 1; |
| dfp_test_t test_def = dfp_cmp_tests[k]; |
| BF = 0; |
| |
| again: |
| for (i = 0; i < test_def.num_tests; i++) { |
| unsigned int condreg; |
| unsigned int flags; |
| |
| if (test_def.precision == LONG_TEST) { |
| u0 = dfp64_vals[test_def.targs[i].fra_idx]; |
| u1 = dfp64_vals[test_def.targs[i].frb_idx]; |
| } else { |
| u0 = dfp128_vals[test_def.targs[i].fra_idx * 2]; |
| u0x = dfp128_vals[(test_def.targs[i].fra_idx * 2) + 1]; |
| u1 = dfp128_vals[test_def.targs[i].frb_idx * 2]; |
| u1x = dfp128_vals[(test_def.targs[i].frb_idx * 2) + 1]; |
| } |
| *(unsigned long long *)d0p = u0; |
| *(unsigned long long *)d1p = u1; |
| f14 = d0; |
| f16 = d1; |
| if (test_def.precision == QUAD_TEST) { |
| *(unsigned long long *)d0xp = u0x; |
| *(unsigned long long *)d1xp = u1x; |
| f15 = d0x; |
| f17 = d1x; |
| } |
| |
| SET_FPSCR_ZERO; |
| SET_CR_XER_ZERO; |
| (*func)(BF, 0); |
| GET_CR(flags); |
| |
| condreg = ((flags >> (4 * (7-BF)))) & 0xf; |
| printf("%s %016llx", test_def.name, u0); |
| if (test_def.precision == LONG_TEST) { |
| printf(" %s %016llx => %x (BF=%d)\n", |
| test_def.op, u1, condreg, BF); |
| } else { |
| printf(" %016llx %s %016llx %016llx ==> %x (BF=%d)\n", |
| u0x, test_def.op, u1, u1x, |
| condreg, BF); |
| } |
| } |
| if (repeat) { |
| repeat = 0; |
| BF = 5; |
| goto again; |
| } |
| k++; |
| printf( "\n" ); |
| } |
| } |
| |
| |
| static test_table_t |
| all_tests[] = |
| { |
| { &test_dfp_cmp_ops, |
| "Test DFP compare instructions"}, |
| { &test_dfp_rint_ops, |
| "Test DFP round instructions"}, |
| { &test_dfp_xiex_ops, |
| "Test DFP insert/extract instructions"}, |
| { &test_dfp_rrnd_ops, |
| "Test DFP reround instructions"}, |
| { &test_dfp_qua_ops, |
| "Test DFP quantize instructions"}, |
| { &test_dfp_quai_ops, |
| "Test DFP quantize immediate instructions"}, |
| { NULL, NULL } |
| }; |
| #endif // HAS_DFP |
| |
| int main() { |
| #if defined(HAS_DFP) |
| |
| test_table_t aTest; |
| test_driver_func_t func; |
| int i = 0; |
| |
| while ((func = all_tests[i].test_category)) { |
| aTest = all_tests[i]; |
| printf( "%s\n", aTest.name ); |
| (*func)(); |
| i++; |
| } |
| |
| #endif // HAS_DFP |
| return 0; |
| } |
