diff options
Diffstat (limited to 'usr/src/cmd/fps/fptest/fputest.c')
| -rw-r--r-- | usr/src/cmd/fps/fptest/fputest.c | 4385 |
1 files changed, 0 insertions, 4385 deletions
diff --git a/usr/src/cmd/fps/fptest/fputest.c b/usr/src/cmd/fps/fptest/fputest.c deleted file mode 100644 index 8cd66644f0..0000000000 --- a/usr/src/cmd/fps/fptest/fputest.c +++ /dev/null @@ -1,4385 +0,0 @@ -/* - * CDDL HEADER START - * - * The contents of this file are subject to the terms of the - * Common Development and Distribution License (the "License"). - * You may not use this file except in compliance with the License. - * - * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE - * or http://www.opensolaris.org/os/licensing. - * See the License for the specific language governing permissions - * and limitations under the License. - * - * When distributing Covered Code, include this CDDL HEADER in each - * file and include the License file at usr/src/OPENSOLARIS.LICENSE. - * If applicable, add the following below this CDDL HEADER, with the - * fields enclosed by brackets "[]" replaced with your own identifying - * information: Portions Copyright [yyyy] [name of copyright owner] - * - * CDDL HEADER END - */ - -/* - * Copyright 2008 Sun Microsystems, Inc. All rights reserved. - * Use is subject to license terms. - */ - -#pragma ident "%Z%%M% %I% %E% SMI" - -#include <sys/types.h> -#include <sys/file.h> -#include <signal.h> -#include <ucontext.h> -#include <stdio.h> -#include <floatingpoint.h> -#include <locale.h> -#include <unistd.h> -#include <fp.h> -#include <externs.h> -#include <fps_ereport.h> - -#define FPU_ID_MASK 0xCFF02FFF - -extern int FPU_cpu; -static int check_conv(); -uint_t trap_flag = 0x0; -unsigned long fsr_at_trap; - -extern unsigned long long_float_d(unsigned long); -extern unsigned long float_long_d(unsigned long); -int fpu_sysdiag(struct fps_test_ereport *report); -int restore_signals(); -static int addition_test_dp(struct fps_test_ereport *report); -static int addition_test_sp(struct fps_test_ereport *report); -static int branching(struct fps_test_ereport *report); -static int chain_dp_test(struct fps_test_ereport *report); -static int chain_sp_test(struct fps_test_ereport *report); -static int check_conv(struct fps_test_ereport *report); -static int compare_dp(struct fps_test_ereport *report); -static int compare_dp_except(struct fps_test_ereport *report); -static int compare_sp(struct fps_test_ereport *report); -static int compare_sp_except(struct fps_test_ereport *report); -static int data_path_dp(struct fps_test_ereport *report); -static int data_path_sp(struct fps_test_ereport *report); -static int division_test_dp(struct fps_test_ereport *report); -static int division_test_sp(struct fps_test_ereport *report); -static int double_sing(struct fps_test_ereport *report); -static int fabs_ins_dp(struct fps_test_ereport *report); -static int fabs_ins_sp(struct fps_test_ereport *report); -static int float_to_integer_dp(struct fps_test_ereport *report); -static int float_to_integer_sp(struct fps_test_ereport *report); -static int float_to_long_dp(struct fps_test_ereport *report); -static int float_to_long_sp(struct fps_test_ereport *report); -static int get_negative_value_pn_dp(struct fps_test_ereport *report); -static int get_negative_value_pn_sp(struct fps_test_ereport *report); -static int get_negative_value_np_dp(struct fps_test_ereport *report); -static int get_negative_value_np_sp(struct fps_test_ereport *report); -static int fmovs_ins(struct fps_test_ereport *report); -static int integer_to_float_dp(struct fps_test_ereport *report); -static int integer_to_float_sp(struct fps_test_ereport *report); -static int long_to_float_dp(struct fps_test_ereport *report); -static int long_to_float_sp(struct fps_test_ereport *report); -static int multiplication_test_dp(struct fps_test_ereport *report); -static int multiplication_test_sp(struct fps_test_ereport *report); -static int no_branching(struct fps_test_ereport *report); -static int registers_four(struct fps_test_ereport *report); -static int registers_four_dp(struct fps_test_ereport *report); -static int registers_one(struct fps_test_ereport *report); -static int registers_one_dp(struct fps_test_ereport *report); -static int registers_two(struct fps_test_ereport *report); -static int registers_two_dp(struct fps_test_ereport *report); -static int single_doub(struct fps_test_ereport *report); -static int squareroot_test_dp(struct fps_test_ereport *report); -static int squareroot_test_sp(struct fps_test_ereport *report); -static int subtraction_test_dp(struct fps_test_ereport *report); -static int subtraction_test_sp(struct fps_test_ereport *report); -static int timing_test(struct fps_test_ereport *report); -static void fail_trap(struct fps_test_ereport *report, int flag_num); - -/* SIGFPE */ -static void sigfpe_handler(int, siginfo_t *, ucontext_t *); -static struct sigaction oldfpe, newfpe; - -/* SIGSEGV */ -static void sigsegv_handler(int, siginfo_t *, ucontext_t *); -static struct sigaction oldsegv, newsegv; - -/* SIGILL */ -static void sigill_handler(int, siginfo_t *, ucontext_t *); -static struct sigaction oldill, newill; - -/* SIGBUS */ -static void sigbus_handler(int, siginfo_t *, ucontext_t *); -static struct sigaction oldbus, newbus; - -static unsigned int pat[] = { - 0x00000000, - 0x55555555, - 0xAAAAAAAA, - 0xCCCCCCCC, - 0x33333333, - 0xFFFFFFFF, - 0xA5A5A5A5, - 0x3C3C3C3C, - 0xF0F0F0F0, - 0xEEEEEEEE, - 0xDDDDDDDD, - 0xBBBBBBBB, - 0x77777777, - 0x11111111, - 0x22222222, - 0x44444444, - 0x88888888, - 0x66666666, - 0x99999999, - 0x00FF00FF, - 0xFF00FF00, - 0xFFFF0000, - 0x0000FFFF, - -}; - -#define PAT_NUM (sizeof (pat)/sizeof (*pat)) - -/* - * Double precision patterns - */ -static uint64_t pat_dp[] = { - 0x0000000000000000UL, - 0x5555555555555555UL, - 0xAAAAAAAAAAAAAAAAUL, - 0xCCCCCCCCCCCCCCCCUL, - 0x3333333333333333UL, - 0xFFFFFFFFFFFFFFFFUL, - 0xA5A5A5A5A5A5A5A5UL, - 0x3C3C3C3C3C3C3C3CUL, - 0xF0F0F0F0F0F0F0F0UL, - 0xEEEEEEEEEEEEEEEEUL, - 0xDDDDDDDDDDDDDDDDUL, - 0xBBBBBBBBBBBBBBBBUL, - 0x7777777777777777UL, - 0x1111111111111111UL, - 0x2222222222222222UL, - 0x4444444444444444UL, - 0x8888888888888888UL, - 0x6666666666666666UL, - 0x9999999999999999UL, - 0x00000000FFFFFFFFUL, - 0xFFFFFFFF00000000UL, - 0x0000FFFF0000FFFFUL, - 0xFFFF0000FFFF0000UL -}; - -#define PAT_DP_NUM (sizeof (pat_dp)/sizeof (*pat_dp)) - -struct value { - unsigned long floatsingle; - uint64_t floatdouble; - uint64_t floatquad_u; - uint64_t floatquad_l; -}; - -#define N_VALS (sizeof (val)/sizeof (*val)) - -static struct value val[] = { - 0, 0, 0, 0, - 0x3F800000, 0x3FF0000000000000, 0x3FFF000000000000, 0, - 0x40000000, 0x4000000000000000, 0x4000000000000000, 0, - 0x40400000, 0x4008000000000000, 0x4000800000000000, 0, - 0x40800000, 0x4010000000000000, 0x4001000000000000, 0, - 0x40A00000, 0x4014000000000000, 0x4001400000000000, 0, - 0x40C00000, 0x4018000000000000, 0x4001800000000000, 0, - 0x40E00000, 0x401C000000000000, 0x4001C00000000000, 0, - 0x41000000, 0x4020000000000000, 0x4002000000000000, 0, - 0x41100000, 0x4022000000000000, 0x4002200000000000, 0, - 0x41200000, 0x4024000000000000, 0x4002400000000000, 0, - 0x41300000, 0x4026000000000000, 0x4002600000000000, 0, - 0x41400000, 0x4028000000000000, 0x4002800000000000, 0, - 0x41500000, 0x402A000000000000, 0x4002A00000000000, 0, - 0x41600000, 0x402C000000000000, 0x4002C00000000000, 0, - 0x41700000, 0x402E000000000000, 0x4002E00000000000, 0, - 0x41800000, 0x4030000000000000, 0x4003000000000000, 0, - 0x41880000, 0x4031000000000000, 0x4003100000000000, 0, - 0x41900000, 0x4032000000000000, 0x4003200000000000, 0, - 0x41980000, 0x4033000000000000, 0x4003300000000000, 0, - 0x41a00000, 0x4034000000000000, 0x4003400000000000, 0, - 0x41a80000, 0x4035000000000000, 0x4003500000000000, 0, - 0x41b00000, 0x4036000000000000, 0x4003600000000000, 0, - 0x41b80000, 0x4037000000000000, 0x4003700000000000, 0, - 0x41c00000, 0x4038000000000000, 0x4003800000000000, 0, - 0x41c80000, 0x4039000000000000, 0x4003900000000000, 0, - 0x41d00000, 0x403a000000000000, 0x4003a00000000000, 0, - 0x41d80000, 0x403b000000000000, 0x4003b00000000000, 0, - 0x41e00000, 0x403c000000000000, 0x4003c00000000000, 0, - 0x41e80000, 0x403d000000000000, 0x4003d00000000000, 0, - 0x41f00000, 0x403e000000000000, 0x4003e00000000000, 0, - 0x41f80000, 0x403f000000000000, 0x4003f00000000000, 0, - 0x42000000, 0x4040000000000000, 0x4004000000000000, 0, - 0x42040000, 0x4040800000000000, 0x4004080000000000, 0, - 0x42080000, 0x4041000000000000, 0x4004100000000000, 0, - 0x420c0000, 0x4041800000000000, 0x4004180000000000, 0, - 0x42100000, 0x4042000000000000, 0x4004200000000000, 0, - 0x42140000, 0x4042800000000000, 0x4004280000000000, 0, - 0x42180000, 0x4043000000000000, 0x4004300000000000, 0, - 0x421c0000, 0x4043800000000000, 0x4004380000000000, 0, - 0x42200000, 0x4044000000000000, 0x4004400000000000, 0, - 0x42240000, 0x4044800000000000, 0x4004480000000000, 0, - 0x42280000, 0x4045000000000000, 0x4004500000000000, 0, - 0x422c0000, 0x4045800000000000, 0x4004580000000000, 0, - 0x42300000, 0x4046000000000000, 0x4004600000000000, 0, - 0x42340000, 0x4046800000000000, 0x4004680000000000, 0, - 0x42380000, 0x4047000000000000, 0x4004700000000000, 0, - 0x423c0000, 0x4047800000000000, 0x4004780000000000, 0, - 0x42400000, 0x4048000000000000, 0x4004800000000000, 0, - 0x42440000, 0x4048800000000000, 0x4004880000000000, 0, - 0x42480000, 0x4049000000000000, 0x4004900000000000, 0, - 0x424c0000, 0x4049800000000000, 0x4004980000000000, 0, - 0x42500000, 0x404a000000000000, 0x4004a00000000000, 0, - 0x42540000, 0x404a800000000000, 0x4004a80000000000, 0, - 0x42580000, 0x404b000000000000, 0x4004b00000000000, 0, - 0x425c0000, 0x404b800000000000, 0x4004b80000000000, 0, - 0x42600000, 0x404c000000000000, 0x4004c00000000000, 0, - 0x42640000, 0x404c800000000000, 0x4004c80000000000, 0, - 0x42680000, 0x404d000000000000, 0x4004d00000000000, 0, - 0x426c0000, 0x404d800000000000, 0x4004d80000000000, 0, - 0x42700000, 0x404e000000000000, 0x4004e00000000000, 0, - 0x42740000, 0x404e800000000000, 0x4004e80000000000, 0, - 0x42780000, 0x404f000000000000, 0x4004f00000000000, 0, - 0x427c0000, 0x404f800000000000, 0x4004f80000000000, 0, - 0x42800000, 0x4050000000000000, 0x4005000000000000, 0, - 0x42820000, 0x4050400000000000, 0x4005040000000000, 0, - 0x42840000, 0x4050800000000000, 0x4005080000000000, 0, - 0x42860000, 0x4050c00000000000, 0x40050c0000000000, 0, - 0x42880000, 0x4051000000000000, 0x4005100000000000, 0, - 0x428a0000, 0x4051400000000000, 0x4005140000000000, 0, - 0x428c0000, 0x4051800000000000, 0x4005180000000000, 0, - 0x428e0000, 0x4051c00000000000, 0x40051c0000000000, 0, - 0x42900000, 0x4052000000000000, 0x4005200000000000, 0, - 0x42920000, 0x4052400000000000, 0x4005240000000000, 0, - 0x42940000, 0x4052800000000000, 0x4005280000000000, 0, - 0x42960000, 0x4052c00000000000, 0x40052c0000000000, 0, - 0x42980000, 0x4053000000000000, 0x4005300000000000, 0, - 0x429a0000, 0x4053400000000000, 0x4005340000000000, 0, - 0x429c0000, 0x4053800000000000, 0x4005380000000000, 0, - 0x429e0000, 0x4053c00000000000, 0x40053c0000000000, 0, - 0x42a00000, 0x4054000000000000, 0x4005400000000000, 0, - 0x42a20000, 0x4054400000000000, 0x4005440000000000, 0, - 0x42a40000, 0x4054800000000000, 0x4005480000000000, 0, - 0x42a60000, 0x4054c00000000000, 0x40054c0000000000, 0, - 0x42a80000, 0x4055000000000000, 0x4005500000000000, 0, - 0x42aa0000, 0x4055400000000000, 0x4005540000000000, 0, - 0x42ac0000, 0x4055800000000000, 0x4005580000000000, 0, - 0x42ae0000, 0x4055c00000000000, 0x40055c0000000000, 0, - 0x42b00000, 0x4056000000000000, 0x4005600000000000, 0, - 0x42b20000, 0x4056400000000000, 0x4005640000000000, 0, - 0x42b40000, 0x4056800000000000, 0x4005680000000000, 0, - 0x42b60000, 0x4056c00000000000, 0x40056c0000000000, 0, - 0x42b80000, 0x4057000000000000, 0x4005700000000000, 0, - 0x42ba0000, 0x4057400000000000, 0x4005740000000000, 0, - 0x42bc0000, 0x4057800000000000, 0x4005780000000000, 0, - 0x42be0000, 0x4057c00000000000, 0x40057c0000000000, 0, - 0x42c00000, 0x4058000000000000, 0x4005800000000000, 0, - 0x42c20000, 0x4058400000000000, 0x4005840000000000, 0, - 0x42c40000, 0x4058800000000000, 0x4005880000000000, 0, - 0x42c60000, 0x4058c00000000000, 0x40058c0000000000, 0, - 0x42c80000, 0x4059000000000000, 0x4005900000000000, 0, - 0x42ca0000, 0x4059400000000000, 0x4005940000000000, 0, - 0x42cc0000, 0x4059800000000000, 0x4005980000000000, 0, - 0x42ce0000, 0x4059c00000000000, 0x40059c0000000000, 0, - 0x42d00000, 0x405a000000000000, 0x4005a00000000000, 0, - 0x42d20000, 0x405a400000000000, 0x4005a40000000000, 0, - 0x42d40000, 0x405a800000000000, 0x4005a80000000000, 0, - 0x42d60000, 0x405ac00000000000, 0x4005ac0000000000, 0, - 0x42d80000, 0x405b000000000000, 0x4005b00000000000, 0, - 0x42da0000, 0x405b400000000000, 0x4005b40000000000, 0, - 0x42dc0000, 0x405b800000000000, 0x4005b80000000000, 0, - 0x42de0000, 0x405bc00000000000, 0x4005bc0000000000, 0, - 0x42e00000, 0x405c000000000000, 0x4005c00000000000, 0, - 0x42e20000, 0x405c400000000000, 0x4005c40000000000, 0, - 0x42e40000, 0x405c800000000000, 0x4005c80000000000, 0, - 0x42e60000, 0x405cc00000000000, 0x4005cc0000000000, 0, - 0x42e80000, 0x405d000000000000, 0x4005d00000000000, 0, - 0x42ea0000, 0x405d400000000000, 0x4005d40000000000, 0, - 0x42ec0000, 0x405d800000000000, 0x4005d80000000000, 0, - 0x42ee0000, 0x405dc00000000000, 0x4005dc0000000000, 0, - 0x42f00000, 0x405e000000000000, 0x4005e00000000000, 0, - 0x42f20000, 0x405e400000000000, 0x4005e40000000000, 0, - 0x42f40000, 0x405e800000000000, 0x4005e80000000000, 0, - 0x42f60000, 0x405ec00000000000, 0x4005ec0000000000, 0, - 0x42f80000, 0x405f000000000000, 0x4005f00000000000, 0, - 0x42fa0000, 0x405f400000000000, 0x4005f40000000000, 0, - 0x42fc0000, 0x405f800000000000, 0x4005f80000000000, 0, - 0x42fe0000, 0x405fc00000000000, 0x4005fc0000000000, 0, - 0x43000000, 0x4060000000000000, 0x4006000000000000, 0, - 0x43010000, 0x4060200000000000, 0x4006020000000000, 0, - 0x43020000, 0x4060400000000000, 0x4006040000000000, 0, - 0x43030000, 0x4060600000000000, 0x4006060000000000, 0, - 0x43040000, 0x4060800000000000, 0x4006080000000000, 0, - 0x43050000, 0x4060a00000000000, 0x40060a0000000000, 0, - 0x43060000, 0x4060c00000000000, 0x40060c0000000000, 0, - 0x43070000, 0x4060e00000000000, 0x40060e0000000000, 0, - 0x43080000, 0x4061000000000000, 0x4006100000000000, 0, - 0x43090000, 0x4061200000000000, 0x4006120000000000, 0, - 0x430a0000, 0x4061400000000000, 0x4006140000000000, 0, - 0x430b0000, 0x4061600000000000, 0x4006160000000000, 0, - 0x430c0000, 0x4061800000000000, 0x4006180000000000, 0, - 0x430d0000, 0x4061a00000000000, 0x40061a0000000000, 0, - 0x430e0000, 0x4061c00000000000, 0x40061c0000000000, 0, - 0x430f0000, 0x4061e00000000000, 0x40061e0000000000, 0, - 0x43100000, 0x4062000000000000, 0x4006200000000000, 0, - 0x43110000, 0x4062200000000000, 0x4006220000000000, 0, - 0x43120000, 0x4062400000000000, 0x4006240000000000, 0, - 0x43130000, 0x4062600000000000, 0x4006260000000000, 0, - 0x43140000, 0x4062800000000000, 0x4006280000000000, 0, - 0x43150000, 0x4062a00000000000, 0x40062a0000000000, 0, - 0x43160000, 0x4062c00000000000, 0x40062c0000000000, 0, - 0x43170000, 0x4062e00000000000, 0x40062e0000000000, 0, - 0x43180000, 0x4063000000000000, 0x4006300000000000, 0, - 0x43190000, 0x4063200000000000, 0x4006320000000000, 0, - 0x431a0000, 0x4063400000000000, 0x4006340000000000, 0, - 0x431b0000, 0x4063600000000000, 0x4006360000000000, 0, - 0x431c0000, 0x4063800000000000, 0x4006380000000000, 0, - 0x431d0000, 0x4063a00000000000, 0x40063a0000000000, 0, - 0x431e0000, 0x4063c00000000000, 0x40063c0000000000, 0, - 0x431f0000, 0x4063e00000000000, 0x40063e0000000000, 0, - 0x43200000, 0x4064000000000000, 0x4006400000000000, 0, - 0x43210000, 0x4064200000000000, 0x4006420000000000, 0, - 0x43220000, 0x4064400000000000, 0x4006440000000000, 0, - 0x43230000, 0x4064600000000000, 0x4006460000000000, 0, - 0x43240000, 0x4064800000000000, 0x4006480000000000, 0, - 0x43250000, 0x4064a00000000000, 0x40064a0000000000, 0, - 0x43260000, 0x4064c00000000000, 0x40064c0000000000, 0, - 0x43270000, 0x4064e00000000000, 0x40064e0000000000, 0, - 0x43280000, 0x4065000000000000, 0x4006500000000000, 0, - 0x43290000, 0x4065200000000000, 0x4006520000000000, 0, - 0x432a0000, 0x4065400000000000, 0x4006540000000000, 0, - 0x432b0000, 0x4065600000000000, 0x4006560000000000, 0, - 0x432c0000, 0x4065800000000000, 0x4006580000000000, 0, - 0x432d0000, 0x4065a00000000000, 0x40065a0000000000, 0, - 0x432e0000, 0x4065c00000000000, 0x40065c0000000000, 0, - 0x432f0000, 0x4065e00000000000, 0x40065e0000000000, 0, - 0x43300000, 0x4066000000000000, 0x4006600000000000, 0, - 0x43310000, 0x4066200000000000, 0x4006620000000000, 0, - 0x43320000, 0x4066400000000000, 0x4006640000000000, 0, - 0x43330000, 0x4066600000000000, 0x4006660000000000, 0, - 0x43340000, 0x4066800000000000, 0x4006680000000000, 0, - 0x43350000, 0x4066a00000000000, 0x40066a0000000000, 0, - 0x43360000, 0x4066c00000000000, 0x40066c0000000000, 0, - 0x43370000, 0x4066e00000000000, 0x40066e0000000000, 0, - 0x43380000, 0x4067000000000000, 0x4006700000000000, 0, - 0x43390000, 0x4067200000000000, 0x4006720000000000, 0, - 0x433a0000, 0x4067400000000000, 0x4006740000000000, 0, - 0x433b0000, 0x4067600000000000, 0x4006760000000000, 0, - 0x433c0000, 0x4067800000000000, 0x4006780000000000, 0, - 0x433d0000, 0x4067a00000000000, 0x40067a0000000000, 0, - 0x433e0000, 0x4067c00000000000, 0x40067c0000000000, 0, - 0x433f0000, 0x4067e00000000000, 0x40067e0000000000, 0, - 0x43400000, 0x4068000000000000, 0x4006800000000000, 0, - 0x43410000, 0x4068200000000000, 0x4006820000000000, 0, - 0x43420000, 0x4068400000000000, 0x4006840000000000, 0, - 0x43430000, 0x4068600000000000, 0x4006860000000000, 0, - 0x43440000, 0x4068800000000000, 0x4006880000000000, 0, - 0x43450000, 0x4068a00000000000, 0x40068a0000000000, 0, - 0x43460000, 0x4068c00000000000, 0x40068c0000000000, 0, - 0x43470000, 0x4068e00000000000, 0x40068e0000000000, 0, - 0x43480000, 0x4069000000000000, 0x4006900000000000, 0, - 0x43490000, 0x4069200000000000, 0x4006920000000000, 0, - 0x434a0000, 0x4069400000000000, 0x4006940000000000, 0, - 0x434b0000, 0x4069600000000000, 0x4006960000000000, 0, - 0x434c0000, 0x4069800000000000, 0x4006980000000000, 0, - 0x434d0000, 0x4069a00000000000, 0x40069a0000000000, 0, - 0x434e0000, 0x4069c00000000000, 0x40069c0000000000, 0, - 0x434f0000, 0x4069e00000000000, 0x40069e0000000000, 0, - 0x43500000, 0x406a000000000000, 0x4006a00000000000, 0, - 0x43510000, 0x406a200000000000, 0x4006a20000000000, 0, - 0x43520000, 0x406a400000000000, 0x4006a40000000000, 0, - 0x43530000, 0x406a600000000000, 0x4006a60000000000, 0, - 0x43540000, 0x406a800000000000, 0x4006a80000000000, 0, - 0x43550000, 0x406aa00000000000, 0x4006aa0000000000, 0, - 0x43560000, 0x406ac00000000000, 0x4006ac0000000000, 0, - 0x43570000, 0x406ae00000000000, 0x4006ae0000000000, 0, - 0x43580000, 0x406b000000000000, 0x4006b00000000000, 0, - 0x43590000, 0x406b200000000000, 0x4006b20000000000, 0, - 0x435a0000, 0x406b400000000000, 0x4006b40000000000, 0, - 0x435b0000, 0x406b600000000000, 0x4006b60000000000, 0, - 0x435c0000, 0x406b800000000000, 0x4006b80000000000, 0, - 0x435d0000, 0x406ba00000000000, 0x4006ba0000000000, 0, - 0x435e0000, 0x406bc00000000000, 0x4006bc0000000000, 0, - 0x435f0000, 0x406be00000000000, 0x4006be0000000000, 0, - 0x43600000, 0x406c000000000000, 0x4006c00000000000, 0, - 0x43610000, 0x406c200000000000, 0x4006c20000000000, 0, - 0x43620000, 0x406c400000000000, 0x4006c40000000000, 0, - 0x43630000, 0x406c600000000000, 0x4006c60000000000, 0, - 0x43640000, 0x406c800000000000, 0x4006c80000000000, 0, - 0x43650000, 0x406ca00000000000, 0x4006ca0000000000, 0, - 0x43660000, 0x406cc00000000000, 0x4006cc0000000000, 0, - 0x43670000, 0x406ce00000000000, 0x4006ce0000000000, 0, - 0x43680000, 0x406d000000000000, 0x4006d00000000000, 0, - 0x43690000, 0x406d200000000000, 0x4006d20000000000, 0, - 0x436a0000, 0x406d400000000000, 0x4006d40000000000, 0, - 0x436b0000, 0x406d600000000000, 0x4006d60000000000, 0, - 0x436c0000, 0x406d800000000000, 0x4006d80000000000, 0, - 0x436d0000, 0x406da00000000000, 0x4006da0000000000, 0, - 0x436e0000, 0x406dc00000000000, 0x4006dc0000000000, 0, - 0x436f0000, 0x406de00000000000, 0x4006de0000000000, 0, - 0x43700000, 0x406e000000000000, 0x4006e00000000000, 0, - 0x43710000, 0x406e200000000000, 0x4006e20000000000, 0, - 0x43720000, 0x406e400000000000, 0x4006e40000000000, 0, - 0x43730000, 0x406e600000000000, 0x4006e60000000000, 0, - 0x43740000, 0x406e800000000000, 0x4006e80000000000, 0, - 0x43750000, 0x406ea00000000000, 0x4006ea0000000000, 0, - 0x43760000, 0x406ec00000000000, 0x4006ec0000000000, 0, - 0x43770000, 0x406ee00000000000, 0x4006ee0000000000, 0, - 0x43780000, 0x406f000000000000, 0x4006f00000000000, 0, - 0x43790000, 0x406f200000000000, 0x4006f20000000000, 0, - 0x437a0000, 0x406f400000000000, 0x4006f40000000000, 0, - 0x437b0000, 0x406f600000000000, 0x4006f60000000000, 0, - 0x437c0000, 0x406f800000000000, 0x4006f80000000000, 0, - 0x437d0000, 0x406fa00000000000, 0x4006fa0000000000, 0, - 0x437e0000, 0x406fc00000000000, 0x4006fc0000000000, 0, - 0x437f0000, 0x406fe00000000000, 0x4006fe0000000000, 0, -}; - -/* -ve of the values in val[] above */ -static unsigned long neg_val_sp[N_VALS]; -static uint64_t neg_val_dp[N_VALS]; - -/* - * data_path_sp(struct fps_test_ereport *report)checks the data path - * between registers and memory, between memory and an floating - * registers, and between floating registers and the weitek chips. - * All the bits are covered including the sign bit. If an error is - * found, all relevant data is stored in report. - */ -#ifndef i86pc -static int -data_path_sp(struct fps_test_ereport *report) -{ - int i; - int j; - int k; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long result; - unsigned long value; - - prev_fsr = get_fsr(); - init_regs(0); - - for (i = 0; i < 2; i++) { - for (j = 1; j < 255; j++) { - for (k = 0; k < 23; k++) { - value = (i << 31) | (j << 23) | (1 << k); - - if (result = datap_add(value)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct( - NO_EREPORT_INFO, - report, 6217, &observed, - &expected, 1, 1); - - return (-1); - } - if (result = datap_mult(value)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct( - NO_EREPORT_INFO, - report, 6218, &observed, - &expected, 1, 1); - - return (-1); - } - } - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * data_path_dp(struct fps_test_ereport *report) performs the - * same function as data_path_sp except it's double precision - * instead of single. If an error is found, all relevant data - * is stored in report. - */ -static int -data_path_dp(struct fps_test_ereport *report) -{ - int i; - int j; - int k; - int l; - uint64_t observed[2]; - uint64_t expected[2]; - unsigned long prev_fsr; - unsigned long result_lsw = 0; - unsigned long result_msw = 0; - unsigned long value_lsw; - unsigned long value_msw; - - prev_fsr = get_fsr(); - init_regs(0); - - for (i = 0; i < 2; i++) { - for (j = 1; j < 2047; j++) { - for (k = 0; k < 52; k++) { - value_lsw = (1 << k); - - if (k > 32) - l = k - 32; - else - l = 32; - - value_msw = (i << 31) | (j << 20) | (1 << l); - - if (datap_add_dp(value_msw, value_lsw)) { - observed[0] = (uint64_t)result_msw; - observed[1] = (uint64_t)result_lsw; - expected[0] = (uint64_t)value_msw; - expected[1] = (uint64_t)value_lsw; - setup_fps_test_struct( - NO_EREPORT_INFO, report, - 6219, observed, expected, - 2, 2); - - return (-1); - } - - if (datap_mult_dp(value_msw, value_lsw)) { - observed[0] = (uint64_t)result_msw; - observed[1] = (uint64_t)result_lsw; - expected[0] = (uint64_t)value_msw; - expected[1] = (uint64_t)value_lsw; - setup_fps_test_struct( - NO_EREPORT_INFO, report, - 6220, observed, expected, - 2, 2); - - return (-1); - } - } - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * timing_test(struct fps_test_ereport *report) does 10 add - * operations continuously and 10 multiply operations - * continusously. If an error is found, relevant data is - * stored in report. - */ -static int -timing_test(struct fps_test_ereport *report) -{ - int i; - uint64_t expected; - uint64_t observed; - unsigned long result; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - for (i = 0; i < 1000; i++) { - init_regs(0); - if (result = timing_add_sp()) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6221, &observed, &expected, 1, 1); - - return (-1); - } - - init_regs(0); - - if (result = timing_mult_sp()) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6222, &observed, &expected, 1, 1); - - return (-1); - } - - init_regs(0); - - if (result = timing_add_dp()) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6223, &observed, &expected, 1, 1); - - return (-1); - } - - init_regs(0); - - if (result = timing_mult_dp()) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6224, &observed, &expected, 1, 1); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * chain_sp_test(struct fps_test_ereport *report) - * performs a series of single precision chaining - * tests. If an error is found, relevant data is - * stored in report. - */ -static int -chain_sp_test(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t result; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - init_regs(0); - set_fsr(0); - - for (i = 1; i < 60; i++) { - if ((result = chain_sp(i)) != (unsigned long) i) { - observed = (uint64_t)result; - expected = (uint64_t)i; - (void) snprintf(err_data, sizeof (err_data), - "\nExpected: %d\nObserved: %d", i, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6225, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * chain_dp_test(struct fps_test_ereport *report) - * performs a series of double precision chaining - * tests. If an error is found, relevant data is - * stored in report. - */ -static int -chain_dp_test(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t result; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - init_regs(0); - set_fsr(0); - - for (i = 1; i < 60; i++) { - if ((result = chain_dp(i)) != (unsigned long) i) { - observed = (uint64_t)result; - expected = (uint64_t)i; - (void) snprintf(err_data, sizeof (err_data), - "\nExpected: %d\nObserved: %d", i, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6226, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * integer_to_float_sp(struct fps_test_ereport *report) - * does continuous integer to float, single precision - * conversions. If an error is found, relevant data is stored - * in report. - */ -static int -integer_to_float_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long result; - - prev_fsr = get_fsr(); - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = int_float_s(i); - if (result != val[i].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, val[i].floatsingle, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6227, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * integer_to_float_dp(struct fps_test_ereport *report) - * does continuous integer to float, double precision - * conversions. If an error is found, relevant data is stored - * in report. - */ -static int -integer_to_float_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long result; - - prev_fsr = get_fsr(); - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = int_float_d(i); - if (result != val[i].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %lld" - "\nObserved: %lld", i, val[i].floatdouble, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6228, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * long_to_float_sp(struct fps_test_ereport *report) - * performs continuous, single precision, unsigned - * long to float conversions. If an error is found, - * relevant data is stored in report. - */ -static int -long_to_float_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t expected; - uint64_t observed; - unsigned long i; - unsigned long prev_fsr; - unsigned long result; - - prev_fsr = get_fsr(); - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = long_float_s(i); - if (result != val[i].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, val[i].floatdouble, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6353, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * long_to_float_dp(struct fps_test_ereport *report) - * performs continuous, double precision, unsigned - * long to float conversions. If an error is found, - * relevant data is stored in report. - */ -static int -long_to_float_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t expected; - uint64_t observed; - unsigned long i; - unsigned long prev_fsr; - unsigned long res1; - - prev_fsr = get_fsr(); - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - res1 = long_float_d(i); - if (res1 != val[i].floatdouble) { - observed = (uint64_t)res1; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %lld" - "\nObserved: %lld", i, val[i].floatdouble, - res1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6354, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * float_to_integer_sp(struct fps_test_ereport *report) - * performs continuous, single precision float to - * integer conversions. If an error is found, relevant - * data is stored in report. - */ -static int -float_to_integer_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t i; - unsigned long prev_fsr; - unsigned long result; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = float_int_s(val[i].floatsingle); - if (result != i) { - observed = (uint64_t)result; - expected = (uint64_t)i; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, i, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6229, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - /* - * Value greater than highest representable value in int has to raise - * an invalid exception. - * - * Highest possible value in int (assume uint) is 2^32; Use 2^33 for a - * value greater. - */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - - /* Set trap flag to solicited */ - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_s(0x50000000); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstoi max value exception not raised, " - "fp val=%lx, fsr=%lx", - 0x50000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5307, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstoi max value exception not raised, " - "fp val=%lx, fsr=%lx", - 0x50000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5308, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - /* NaNs should raise an exception when converted */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_s(nan_sp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstoi NaN exception not raised, " - "fp val=%lx, fsr=%lx", - nan_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5309, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstoi NaN exception not raised, " - "fp val=%lx, fsr=%lx", - nan_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5310, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - /* + infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_s(PLUS_INF_SP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstoi +infinity exception not raised, " - "fp val=%lx, fsr=%lx", - PLUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5311, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstoi +infinity exception not raised, " - "fp val=%lx, fsr=%lx", - PLUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5312, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - /* - infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_s(MINUS_INF_SP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstoi -infinity exception not raised, " - "fp val=%lx, fsr=%lx", - MINUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5313, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstoi -infinity exception not raised, " - "fp val=%lx, fsr=%lx", - MINUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5314, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - /* Check for inexact exception raised because of fractions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NX); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_s(pi_sp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstoi inexact exception not raised, " - "fp val=%lx, fsr=%lx", - pi_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5315, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NX) != FSR_CEXC_NX) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NX; - expected = (uint64_t)FSR_CEXC_NX; - (void) snprintf(err_data, sizeof (err_data), - "fstoi inexact exception not raised, " - "fp val=%lx, fsr=%lx", - pi_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5316, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * float_to_integer_dp(struct fps_test_ereport *report) - * performs continuous, double precision float to - * integer conversions. If an error is found, relevant - * data is stored in report. - */ -static int -float_to_integer_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long res1; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 0; i < N_VALS; i++) { - res1 = float_int_d(val[i].floatdouble); - - if (res1 != i) { - observed = (uint64_t)res1; - expected = (uint64_t)i; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, i, - res1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6230, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - /* - * Value greater than highest representable value in int has to raise - * an invalid exception. - * - * Highest possible value in int (assume uint) is 2^32; Use 2^33 for a - * value greater. - */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_d(0x4200000000000000); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi max value exception not raised, " - "fp val=%llx, fsr=%lx", - 0x4200000000000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5317, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi max value exception not raised, " - "fp val=%llx, fsr=%lx", - 0x4200000000000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5318, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* NaNs should raise an exception when converted */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_d(nan_dp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi NaN exception not raised, " - "fp val=%llx, fsr=%lx", - nan_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5319, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi NaN exception not raised, " - "fp val=%llx, fsr=%lx", - nan_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5320, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* + infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_d(PLUS_INF_DP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi +infinity exception not raised, " - "fp val=%llx, fsr=%lx", - PLUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5321, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi +infinity exception not raised, " - "fp val=%llx, fsr=%lx", - PLUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5322, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* - infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_d(MINUS_INF_DP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi -infinity exception not raised, " - "fp val=%llx, fsr=%lx", - MINUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5323, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi -infinity exception not raised, " - "fp val=%llx, fsr=%lx", - MINUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5324, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* Check for inexact exception raised because of fractions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NX); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_d(pi_dp); - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi inexact exception not raised, " - "fp val=%llx, fsr=%lx", - pi_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5325, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NX) != FSR_CEXC_NX) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NX; - expected = (uint64_t)FSR_CEXC_NX; - (void) snprintf(err_data, sizeof (err_data), - "fdtoi inexact exception not raised, " - "fp val=%llx, fsr=%lx", - pi_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5326, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * float_to_long_sp(struct fps_test_ereport *report) - * does continuous, single precision, float to long - * conversions. If an error is found, relevant data - * is stored in report. - */ -static int -float_to_long_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long result; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = float_long_s(val[i].floatsingle); - - if (result != i) { - observed = (uint64_t)result; - expected = (uint64_t)i; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, i, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6352, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - /* - * Value greater than highest representable value in int has to raise - * an invalid exception. - * - * Highest possible value in int (assume uint) is 2^64; Use 2^65 for a - * value greater. - */ - - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_s(0x60000000); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstox max value exception not raised, " - "fp val=%lx, fsr=%lx", - 0x60000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5327, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstox max value exception not raised, " - "fp val=%lx, fsr=%lx", - 0x50000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5328, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* NaNs should raise an exception when converted */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_s(nan_sp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstox NaN exception not raised, " - "fp val=%lx, fsr=%lx", - nan_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5329, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstox NaN exception not raised, " - "fp val=%lx, fsr=%lx", - nan_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5330, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - /* + infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_s(PLUS_INF_SP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstox +infinity exception not raised, " - "fp val=%lx, fsr=%lx", - PLUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5331, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstox +infinity exception not raised, " - "fp val=%lx, fsr=%lx", - PLUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5332, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* - infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_s(MINUS_INF_SP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstox -infinity exception not raised, " - "fp val=%lx, fsr=%lx", - MINUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5333, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fstox -infinity exception not raised, " - "fp val=%lx, fsr=%lx", - MINUS_INF_SP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5334, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* Check for inexact exception raised because of fractions */ - - set_fsr(prev_fsr | FSR_ENABLE_TEM_NX); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_int_s(pi_sp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fstox inexact exception not raised, " - "fp val=%lx, fsr=%lx", - pi_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5335, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NX) != FSR_CEXC_NX) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NX; - expected = (uint64_t)FSR_CEXC_NX; - (void) snprintf(err_data, sizeof (err_data), - "fstox inexact exception not raised, " - "fp val=%lx, fsr=%lx", - pi_sp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5336, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * float_to_long_dp(struct fps_test_ereport *report) - * does continuous, double precision, float to long - * conversions. If an error is found, relevant data - * is stored in report. - */ -static int -float_to_long_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long res1; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - res1 = float_long_d(val[i].floatdouble); - - if (res1 != i) { - observed = (uint64_t)res1; - expected = (uint64_t)i; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, i, - res1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6351, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - /* - * Value greater than highest representable value in long has to - * raise an invalid exception. - * - * Highest possible value in long (assume ulong) is 2^64; Use 2^65 for a - * value greater. - */ - - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_d(0x4400000000000000); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtox max value exception not raised, " - "fp val=%lx, fsr=%lx", - 0x4400000000000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5337, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtox max value exception not raised, " - "fp val=%lx, fsr=%lx", - 0x4200000000000000, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5338, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* NaNs should raise an exception when converted */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_d(nan_dp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtox NaN exception not raised, " - "fp val=%lx, fsr=%lx", - nan_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5339, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtox NaN exception not raised, " - "fp val=%lx, fsr=%lx", - nan_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5340, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* + infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_d(PLUS_INF_DP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtox +infinity exception not raised, " - "fp val=%lx, fsr=%lx", - PLUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5341, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtox +infinity exception not raised, " - "fp val=%lx, fsr=%lx", - PLUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5342, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* - infinity exceptions */ - set_fsr(prev_fsr | FSR_ENABLE_TEM_NV); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_d(MINUS_INF_DP); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtox -infinity exception not raised, " - "fp val=%lx, fsr=%lx", - MINUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5343, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fdtox -infinity exception not raised, " - "fp val=%lx, fsr=%lx", - MINUS_INF_DP, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5344, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - /* Check for inexact exception raised because of fractions */ - - set_fsr(prev_fsr | FSR_ENABLE_TEM_NX); - trap_flag = trap_flag | TRAP_SOLICITED; - - (void) float_long_d(pi_dp); - - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fdtox inexact exception not raised, " - "fp val=%lx, fsr=%lx", - pi_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5345, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - if ((fsr_at_trap & FSR_CEXC_NX) != FSR_CEXC_NX) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NX; - expected = (uint64_t)FSR_CEXC_NX; - (void) snprintf(err_data, sizeof (err_data), - "fdtox inexact exception not raised, " - "fp val=%lx, fsr=%lx", - pi_dp, fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5346, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * single_doub(struct fps_test_ereport *report) - * does continues single to double conversion. - * If an error is found, relevant data is stored - * in report. - */ -static int -single_doub(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long result; - - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = convert_sp_dp(val[i].floatsingle); - - if (result != val[i].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %lld" - "\nObserved: %lld", i, - val[i].floatdouble, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6231, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - - return (0); -} - -/* - * double_sing(struct fps_test_ereport *report) - * does continues double to single conversion. - * If an error is found, relevant data is stored - * in report. - */ -static int -double_sing(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long result; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = convert_dp_sp(val[i].floatdouble); - - if (result != val[i].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, - val[i].floatsingle, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6232, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * fmovs_ins(struct fps_test_ereport *report) - * moves a value through the floating point - * registers. If an error is found, relevant - * data is stored - * in report. - */ -static int -fmovs_ins(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - uint64_t observed; - uint64_t expected; - unsigned long result; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - - if ((result = move_regs(0x3F800000)) != 0x3F800000) { - observed = (uint64_t)result; - expected = (uint64_t)0x3F800000; - (void) snprintf(err_data, sizeof (err_data), - "Wrote to f0, read from f31"); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6233, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * get_negative_value_pn_sp(struct fps_test_ereport *report) - * converts single precision postive to negative values. - * If an error is found, relevant data is stored - * in report. - */ -static int -get_negative_value_pn_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t observed; - uint64_t expected; - unsigned long prev_fsr; - unsigned long result; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = negate_value_sp(val[i].floatsingle); - if (result != neg_val_sp[i]) { - observed = (uint64_t)result; - expected = (uint64_t)neg_val_sp[i]; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, neg_val_sp[i], - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6234, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * get_negative_value_pn_dp(struct fps_test_ereport *report) - * converts double precision postive to negative values. - * If an error is found, relevant data is stored - * in report. - */ -static int -get_negative_value_pn_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - uint64_t result; - - init_regs_dp(0); - - for (i = 0; i < N_VALS; i++) { - result = negate_value_dp(val[i].floatdouble); - if (result != neg_val_dp[i]) { - observed = (uint64_t)result; - expected = (uint64_t)neg_val_dp[i]; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %lld" - "\nObserved: %lld", i, neg_val_dp[i], - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6362, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - return (0); -} - -/* - * get_negative_value_np_sp(struct fps_test_ereport *report) - * converts single precision negative to positive values. - * If an error is found, relevant data is stored - * in report. - */ -static int -get_negative_value_np_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t observed; - uint64_t expected; - unsigned long result; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < N_VALS; i++) { - result = negate_value_sp(neg_val_sp[i]); - - if (result != val[i].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, val[i].floatsingle, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6235, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * get_negative_value_np_dp(struct fps_test_ereport *report) - * converts double precision negative to positive values. - * If an error is found, relevant data is stored - * in report. - */ -static int -get_negative_value_np_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - uint64_t result; - - init_regs_dp(0); - - for (i = 0; i < N_VALS; i++) { - result = negate_value_dp(neg_val_dp[i]); - - if (result != val[i].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %lld" - "\nObserved: %lld", i, val[i].floatdouble, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6363, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - return (0); -} - -/* - * fabs_ins_sp(struct fps_test_ereport *report) - * does single precision absolute value testing. - * If an error is found, relevant data is stored - * in report. - */ -static int -fabs_ins_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long result; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 0; i < N_VALS; i++) { - result = absolute_value_sp(neg_val_sp[i]); - if (result != val[i].floatsingle) { - observed = *(uint64_t *)&result; - expected = *(uint64_t *)&(val[i].floatsingle); - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %d" - "\nObserved: %d", i, val[i].floatsingle, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6236, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * fabs_ins_dp(struct fps_test_ereport *report) - * does double precision absolute value testing. - * If an error is found, relevant data is stored - * in report. - */ -static int -fabs_ins_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - uint64_t result; - - init_regs_dp(0); - - for (i = 0; i < N_VALS; i++) { - result = absolute_value_dp(neg_val_dp[i]); - - if (result != val[i].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d]\nExpected: %lld" - "\nObserved: %lld", i, val[i].floatdouble, - result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6361, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - return (0); -} - -/* - * addition_test_sp(struct fps_test_ereport *report) - * tests single precision addition using floating - * point registers (f4=f0+f2). - * If an error is found, relevant data is stored - * in report. - */ -static int -addition_test_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 0; i < (N_VALS - 1); i++) { - result = add_sp(val[i].floatsingle, val[1].floatsingle); - - if (result != (val[i + 1].floatsingle)) { - - observed = (uint64_t)result; - expected = (uint64_t)val[i + 1].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0+f2" - "\nExpected: %d\nObserved: %d", - i, val[i + 1].floatsingle, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6237, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * addition_test_dp(struct fps_test_ereport *report) - * tests double precision addition using floating - * point registers (f4=f0+f2). - * If an error is found, relevant data is stored - * in report. - */ -static int -addition_test_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 0; i < (N_VALS - 1); i++) { - result = add_dp(val[i].floatdouble, val[1].floatdouble); - - if (result != (val[i + 1].floatdouble)) { - observed = (uint64_t)result; - expected = (uint64_t)val[i + 1].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0+f2" - "\nExpected: %lld\nObserved: %lld", - i, val[i + 1].floatdouble, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6238, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * subtraction_test_sp(struct fps_test_ereport *report) - * tests single precision subtaction using floating - * point registers (f4=f0-f2). - * If an error is found, relevant data is stored - * in report. - */ -static int -subtraction_test_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 1; i < N_VALS; i++) { - result = sub_sp(val[i].floatsingle, val[i - 1].floatsingle); - - if (result != val[1].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[1].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0-f2" - "\nExpected: %d\nObserved: %d", - i, val[1].floatsingle, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6239, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * subtraction_test_dp(struct fps_test_ereport *report) - * tests double precision subtaction using floating - * point registers (f4=f0-f2). - * If an error is found, relevant data is stored - * in report. - */ -static int -subtraction_test_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 1; i < N_VALS; i++) { - result = sub_dp(val[i].floatdouble, val[i - 1].floatdouble); - - if (result != val[1].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[1].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0-f2" - "\nExpected: %lld\nObserved: %lld", - i, val[1].floatdouble, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6240, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * squareroot_test_sp(struct fps_test_ereport *report) - * tests single precision squareroot. - * If an error is found, relevant data is stored - * in report. - */ -static int -squareroot_test_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t observed; - uint64_t expected; - unsigned long result, workvalue; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 1; i < N_VALS; i++) { - workvalue = val[i].floatsingle; - result = sqrt_sp(mult_sp(workvalue, workvalue)); - if (result != workvalue) { - observed = (uint64_t)result; - expected = (uint64_t)workvalue; - (void) snprintf(err_data, sizeof (err_data), - "\nExpected: %d\nObserved: %d", workvalue, - result); - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6241, &observed, &expected, 1, 1); - - return (-1); - } - } - - /* fsqrt(x), where x>0, should be positive */ - result = sqrt_sp(half_sp); - - if (result & SIGN_FLAG_SP) { - observed = (uint64_t)result & SIGN_FLAG_SP; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 8241, &observed, &expected, 1, 1); - - return (-1); - } - - /* fsqrt(-0)=-0. */ - result = sqrt_sp(MINUS_ZERO_SP); - - if (!(result & MINUS_ZERO_SP)) { - observed = (uint64_t)0; - expected = (uint64_t)1; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 8242, &observed, &expected, 1, 1); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * squareroot_test_dp(struct fps_test_ereport *report) - * tests double precision squareroot. - * If an error is found, relevant data is stored - * in report. - */ -static int -squareroot_test_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t observed; - uint64_t expected; - unsigned long half_dp; - unsigned long result; - unsigned long workvalue; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - - for (i = 1; i < N_VALS; i++) { - workvalue = val[i].floatdouble; - result = sqrt_dp(mult_dp(workvalue, workvalue)); - - if (result != workvalue) { - observed = (uint64_t)result; - expected = (uint64_t)workvalue; - (void) snprintf(err_data, sizeof (err_data), - "\nExpected: %lld\nObserved: %lld", workvalue, - result); - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6242, &observed, &expected, 1, 1); - - return (-1); - } - } - - /* fsqrt(x), where x>0, should be positive */ - workvalue = half_msw; - half_dp = workvalue << 32; - half_dp = half_dp | half_lsw; - result = sqrt_dp(half_dp); - - if (result & SIGN_FLAG_DP) { - observed = (uint64_t)result & SIGN_FLAG_DP; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 8243, &observed, &expected, 1, 1); - - return (-1); - } - - /* fsqrt(-0)=-0 */ - result = sqrt_dp(MINUS_ZERO_DP); - - if (!(result & MINUS_ZERO_DP)) { - observed = (uint64_t)0; - expected = (uint64_t)1; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 8244, &observed, &expected, 1, 1); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * division_test_sp(struct fps_test_ereport *report) - * tests single precision division through registers. - * (reg f4=f0/f2). If an error is found, relevant data - * is stored in report. - */ -static int -division_test_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 1; i < N_VALS; i++) { - result = div_sp(val[i].floatsingle, val[1].floatsingle); - - if (result != val[i].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0/f2" - "\nExpected: %d\nObserved: %d", - i, val[i].floatsingle, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6243, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * division_test_dp(struct fps_test_ereport *report) - * tests double precision division through registers. - * (reg f4=f0/f2). If an error is found, relevant data - * is stored in report. - */ -static int -division_test_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 1; i < N_VALS; i++) { - result = div_dp(val[i].floatdouble, val[1].floatdouble); - - if (result != val[i].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0/f2" - "\nExpected: %lld\nObserved: %lld", - i, val[i].floatdouble, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6244, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * multiplication_test_sp(struct fps_test_ereport *report) - * tests single precision multiplication through registers. - * (reg f4=f0*f2). If an error is found, relevant data - * is stored in report. - */ -static int -multiplication_test_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 0; i < N_VALS; i++) { - result = mult_sp(val[i].floatsingle, val[1].floatsingle); - - if (result != val[i].floatsingle) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatsingle; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0*f2" - "\nExpected: %d\nObserved: %d", - i, val[i].floatsingle, result); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6245, &observed, &expected, 1, 1, err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * multiplication_test_dp(struct fps_test_ereport *report) - * tests double precision multiplication through registers. - * (reg f4=f0*f2). If an error is found, relevant data - * is stored in report. - */ -static int -multiplication_test_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t observed; - uint64_t expected; - unsigned long result; - unsigned long prev_fsr; - - prev_fsr = get_fsr(); - - init_regs(0); - for (i = 0; i < N_VALS; i++) { - result = mult_dp(val[i].floatdouble, val[1].floatdouble); - - if (result != val[i].floatdouble) { - observed = (uint64_t)result; - expected = (uint64_t)val[i].floatdouble; - (void) snprintf(err_data, sizeof (err_data), - "Val Entry[%d], reg f4=f0*f2" - "\nExpected: %lld\nObserved: %lld", - i, val[i].floatdouble, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6246, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * compare_sp(struct fps_test_ereport *report) - * performs single precision comparison tests. - * If an error is found, relevant data is stored - * in report. - */ -static int -compare_sp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long prev_fsr; - unsigned long result = 0; - - prev_fsr = get_fsr(); - set_fsr(prev_fsr & FSR_DISABLE_TEM); - init_regs(0); - - for (i = 0; i < (N_VALS - 1); i++) { -#ifndef __lint - result = fcmps_fcc(val[i].floatsingle, val[i].floatsingle, 0); -#endif - - if ((result & 0xc00) != 0) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6247, &observed, &expected, 1, 1, err_data); - - return (-1); - } - -#ifndef __lint - result = fcmps_fcc(val[i].floatsingle, - val[i + 1].floatsingle, 0); -#endif - if ((result & 0xc00) != 0x400) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0x400; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6248, &observed, &expected, 1, 1, err_data); - - return (-1); - } - -#ifndef __lint - result = fcmps_fcc(val[i + 1].floatsingle, - val[i].floatsingle, 0); -#endif - - if ((result & 0xc00) != 0x800) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0x800; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6249, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr & FSR_DISABLE_TEM); -#ifndef __lint - result = fcmps_fcc(val[i].floatsingle, 0x7f800400, 0); -#endif - - if ((result & 0xc00) != 0xc00) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0xc00; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= NaN", i); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6250, &observed, &expected, 1, 1, err_data); - - return (-1); - } - } - - /* Compare +/-zero and check if the comparision is okay */ - - result = fcmps_fcc(MINUS_ZERO_SP, PLUS_ZERO_SP, 0); - - if (result & 0xc00) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", +0, -0); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 8251, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * compare_dp(struct fps_test_ereport *report) - * performs double precision comparison tests. - * If an error is found, relevant data is stored - * in report. - */ -static int -compare_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_fsr; - uint64_t observed; - uint64_t expected; - - prev_fsr = get_fsr(); - set_fsr(prev_fsr & FSR_DISABLE_TEM); - - init_regs(0); - - for (i = 0; i < (N_VALS - 1); i++) { - result = fcmpd_fcc(val[i].floatdouble, val[i].floatdouble, 0); - if ((result & 0xc00) != 0) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6251, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - result = fcmpd_fcc(val[i].floatdouble, - val[i + 1].floatdouble, 0); - - if ((result & 0xc00) != 0x400) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0x400; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6252, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - result = fcmpd_fcc(val[i + 1].floatdouble, - val[i].floatdouble, 0); - - if ((result & 0xc00) != 0x800) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0x800; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6253, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr & FSR_DISABLE_TEM); - result = fcmpd_fcc(val[i].floatdouble, 0x7ff0008000000000, 0); - - if ((result & 0xc00) != 0xc00) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0xc00; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2=NaN", i); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6254, &observed, &expected, 1, 1, err_data); - - return (-1); - } - } - /* Compare +/-zero and check if the comparision is okay */ - - result = fcmpd_fcc(MINUS_ZERO_DP, PLUS_ZERO_DP, 0); - - if (result & 0xc00) { - observed = (uint64_t)result & 0xc00; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "f0= %d, f2= %d", +0, -0); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 8252, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - set_fsr(prev_fsr); - return (0); -} - -/* - * branching(struct fps_test_ereport *report) - * performs branch testing. If an error is found, - * relevant data is stored in report. - */ -static int -branching(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_status; - uint64_t observed; - uint64_t expected; - - prev_status = get_fsr(); - init_regs(0); - result = get_fsr(); - result = result & 0xC0400000; /* set all exception bits to zero */ - set_fsr(result); - - for (i = 0; i < 64; i++) { - if (result = branches(0, val[i].floatsingle, 0x7f800400)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6255, &observed, &expected, 1, 1); - - return (-1); - } - - if (result = branches(1, val[i + 1].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6256, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(2, val[i].floatsingle, 0x7f800400)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6257, &observed, &expected, 1, 1); - - return (-1); - } - - if (result = branches(2, val[i + 1].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6258, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(3, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d and f2= %d ", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6259, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(4, val[i].floatsingle, 0x7f800400)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6260, &observed, &expected, 1, 1); - - return (-1); - } - - if (result = branches(4, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6261, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(5, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6262, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(5, val[i + 1].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6263, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(6, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6264, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(7, val[i].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6265, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(8, val[i].floatsingle, 0x7f800400)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6266, &observed, &expected, 1, 1); - - return (-1); - } - - if (result = branches(8, val[i].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6267, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - if (result = branches(9, val[i].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6268, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - if (result = branches(9, val[i + 1].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6269, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(10, val[i].floatsingle, 0x7f800400)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6270, &observed, &expected, 1, 1); - - return (-1); - } - - if (result = branches(10, val[i].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6271, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(10, val[i + 1].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6272, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(11, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6273, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(11, val[i].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6274, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(12, val[i].floatsingle, 0x7f800400)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6275, &observed, &expected, 1, 1); - - return (-1); - } - - if (result = branches(12, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6276, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(12, val[i].floatsingle, - val[i].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6277, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(13, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6278, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(14, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6279, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (result = branches(15, val[i].floatsingle, - val[i + 1].floatsingle)) { - observed = (uint64_t)result; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d ", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6280, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_status); - return (0); - -} - -/* - * branching(struct fps_test_ereport *report) - * performs negative branch testing. If an error is found, - * relevant data is stored in report. - */ -static int -no_branching(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t observed; - uint64_t expected; - unsigned long result; - unsigned long prev_status; - - prev_status = get_fsr(); - init_regs(0); - result = get_fsr(); - result = result & 0xC0400000; /* set all exception bits to zero */ - set_fsr(result); - - for (i = 0; i < 64; i++) { - if (!(branches(0, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6281, &observed, &expected, 1, 1); - - return (-1); - } - - if (!(branches(1, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6282, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(2, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6283, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(3, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6284, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(4, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6285, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(5, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6286, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(6, val[i].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6287, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(7, val[i + 1].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6288, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(8, val[i + 1].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6289, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(9, val[i].floatsingle, - val[i + 1].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6290, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(10, val[i].floatsingle, - val[i + 1].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i, i+1); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6291, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(11, val[i + 1].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6292, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(branches(12, val[i + 1].floatsingle, - val[i].floatsingle))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - (void) snprintf(err_data, sizeof (err_data), - "reg f0= %d, f2= %d", i+1, i); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6293, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - - if (!(result = branches(13, val[i].floatsingle, 0x7f800400))) { - observed = (uint64_t)0; - expected = (uint64_t)1; - setup_fps_test_struct(NO_EREPORT_INFO, - report, 6294, &observed, &expected, 1, 1); - - return (-1); - } - - } - - set_fsr(prev_status); - - return (0); -} - -/* - * compare_sp_except(struct fps_test_ereport *report) - * does single precision exception testing. - * If an error is found, relevant data is stored - * in report. - */ -static int -compare_sp_except(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_status; - uint64_t observed; - uint64_t expected; - - prev_status = get_fsr(); - init_regs(0); - result = get_fsr(); - result = result | FSR_ENABLE_TEM_NV; - - set_fsr(result); - - for (i = 0; i < N_VALS; i++) { - - trap_flag = trap_flag | TRAP_SOLICITED; - result = cmp_s_ex(val[i].floatsingle, 0x7fbfffff); - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fcmpxs exception did not occur, fsr=%lo", - fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6295, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fcmpxs exception did not occur, fsr=%lo", - fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6296, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_status); - return (0); -} - -/* - * compare_dp_except(struct fps_test_ereport *report) - * does double precision exception testing. - * If an error is found, relevant data is stored - * in report. - */ -static int -compare_dp_except(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned long result; - unsigned long prev_status; - uint64_t observed; - uint64_t expected; - - prev_status = get_fsr(); - init_regs(0); - result = get_fsr(); - result = result | FSR_ENABLE_TEM_NV; - set_fsr(result); - - for (i = 0; i < 199; i++) { - - trap_flag = trap_flag | TRAP_SOLICITED; - result = cmp_d_ex(val[i].floatdouble, 0x7ff0008000000000); - if (trap_flag) { - observed = (uint64_t)trap_flag; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "fcmpxd exception did not occur, fsr=%lo", - fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6297, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - if ((fsr_at_trap & FSR_CEXC_NV) != FSR_CEXC_NV) { - observed = (uint64_t)fsr_at_trap & FSR_CEXC_NV; - expected = (uint64_t)FSR_CEXC_NV; - (void) snprintf(err_data, sizeof (err_data), - "fcmpxd exception did not occur, fsr=%lo", - fsr_at_trap); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6298, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - set_fsr(prev_status); - return (0); -} - -/* - * Patterns used in the registers functions that are. - * loaded into all registers. - */ - -#define ALLZEROES_DP 0x0000000000000000UL -#define ALLZEROES_SP 0x00000000U -#define ALLONES_DP 0xFFFFFFFFFFFFFFFFUL -#define ALLONES_SP 0xFFFFFFFFU - -/* - * registers_four(struct fps_test_ereport *report) - * loads each nibble with 0xf on all the available FP - * registers in single precision. - * If an error is found, relevant data is stored - * in report. - */ -static int -registers_four(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - unsigned int result = 0; - uint64_t observed; - uint64_t expected; - -#define ARB_VAL 4 - - for (i = 0; i < ARB_VAL; i++) { - init_regs(ALLZEROES_SP); - init_regs(ALLONES_SP); - } - - init_regs(ALLZEROES_SP); - for (i = 0; i < 32; i++) { - read_fpreg(&result, i); - if (result != ALLZEROES_SP) { - observed = (uint64_t)result; - expected = (uint64_t)ALLZEROES_SP; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %d\nObserved: %d", - i, ALLZEROES_SP, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6345, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - init_regs(ALLONES_SP); - - for (i = 0; i < 32; i++) { - read_fpreg(&result, i); - if (result != ALLONES_SP) { - observed = (uint64_t)result; - expected = (uint64_t)ALLONES_SP; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %d\nObserved: %d", - i, ALLONES_SP, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 8345, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - return (0); -} - -/* - * registers_four_dp(struct fps_test_ereport *report) - * loads each nibble with 0xf on all the available FP - * registers in double precision. - * If an error is found, relevant data is stored - * in report. - */ -static int -registers_four_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - uint64_t expected; - uint64_t observed; - unsigned long result; - -#define ARB_VAL 4 - - for (i = 0; i < ARB_VAL; i++) { - init_regs_dp(ALLZEROES_DP); - init_regs_dp(ALLONES_DP); - } - - init_regs_dp(16); - read_fpreg_dp(&result, 2); - init_regs_dp(ALLZEROES_DP); - for (i = 0; i < 64; i = i + 2) { - result = ALLONES_DP; - read_fpreg_dp(&result, i); - if (result != ALLZEROES_DP) { - observed = (uint64_t)result; - expected = (uint64_t)ALLZEROES_DP; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %lld\nObserved: %lld", - i, ALLZEROES_DP, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6346, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - init_regs_dp(ALLONES_DP); - - for (i = 30; i < 64; i = i + 2) { - read_fpreg_dp(&result, i); - if (result != ALLONES_DP) { - observed = (uint64_t)result; - expected = (uint64_t)ALLONES_DP; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %lld\nObserved: %lld", - i, ALLONES_DP, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 8346, &observed, &expected, 1, 1, - err_data); - - return (-1); - } - } - - return (0); -} - -/* - * registers_two(struct fps_test_ereport *report) - * tests single precision rotating ones through the - * floating point registers. If an error is found, - * relevant data is stored in report. - */ -static int -registers_two(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - int j; - uint64_t expected; - uint64_t observed; - unsigned int result; - unsigned int value; - - for (j = 0; j < 32; j++) { - for (i = 0; i < 32; i++) { - value = (1 << i); - if ((result = register_test(j, value)) != value) { - observed = (uint64_t)result; - expected = (uint64_t)value; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %d\nObserved: %d", - j, value, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6301, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - } - - return (0); -} - -/* - * registers_two_dp(struct fps_test_ereport *report) - * tests double precision rotating ones through the - * floating point registers. If an error is found, - * relevant data is stored in report. - */ -static int -registers_two_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - int j; - uint64_t observed; - uint64_t expected; - unsigned long result; - unsigned long value; - - for (j = 0; j < 32; j = j + 2) { - for (i = 0; i < 64; i++) { - value = (1 << i); - result = register_test_dp(j, value); - - if (result != value) { - observed = (*(uint64_t *)&result); - expected = (*(uint64_t *)&value); - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %lld\nObserved: %lld", - j, value, result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5301, &observed, &expected, 1, - 1, err_data); - return (-1); - } - } - } - - return (0); -} - -/* - * registers_one(struct fps_test_ereport *report) - * passes a single precision pattern through the - * floating point registers. If an error is found, - * relevant data is stored in report. - */ -static int -registers_one(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - int j; - unsigned int result; - - uint64_t observed; - uint64_t expected; - - for (i = 0; i < 32; i++) { - for (j = 0; j < PAT_NUM; j++) { - result = register_test(i, pat[j]); - if (result != pat[j]) { - observed = (uint64_t)result; - expected = (uint64_t)pat[j]; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %d\nObserved: %d", - i, pat[j], result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 6302, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - } - - return (0); -} - -/* - * registers_one_dp(struct fps_test_ereport *report) - * passes a double precision pattern through the - * floating point registers. If an error is found, - * relevant data is stored in report. - */ -static int -registers_one_dp(struct fps_test_ereport *report) -{ - char err_data[MAX_INFO_SIZE]; - int i; - int j; - unsigned long result; - - uint64_t observed; - uint64_t expected; - - for (i = 0; i < 64; i = i + 2) { - for (j = 0; j < PAT_DP_NUM; j++) { - result = register_test_dp(i, pat_dp[j]); - if (result != pat_dp[j]) { - observed = (uint64_t)result; - expected = (uint64_t)pat[j]; - (void) snprintf(err_data, sizeof (err_data), - "Reg: %d\nExpected: %lld" - "\nObserved: %lld", - i, pat[j], result); - setup_fps_test_struct(IS_EREPORT_INFO, - report, 5302, &observed, &expected, 1, - 1, err_data); - - return (-1); - } - } - } - - return (0); -} - -/* - * sigsegv_handler(int sig, siginfo_t *sip, ucontext_t *ucp) - * sets up the sigsegv signal handler. If reached during - * non-negative testing, application exits. - */ -/* ARGSUSED */ -static void -sigsegv_handler(int sig, siginfo_t *sip, ucontext_t *ucp) -{ - ucp->uc_mcontext.fpregs.fpu_qcnt = 0; - - fsr_at_trap = ucp->uc_mcontext.fpregs.fpu_fsr; - if (trap_flag == (trap_flag | TRAP_SOLICITED)) { - trap_flag = trap_flag & (~TRAP_SOLICITED); - return; - } - trap_flag = trap_flag | TRAP_UNSOLICITED; - - _exit(FPU_SIG_SEGV); -} - -/* - * sigbus_handler(int sig, siginfo_t *sip, ucontext_t *ucp) - * sets up the sigbus signal handler. If reached during - * non-negative testing, application exits. - */ -/* ARGSUSED */ -static void -sigbus_handler(int sig, siginfo_t *sip, ucontext_t *ucp) -{ - ucp->uc_mcontext.fpregs.fpu_qcnt = 0; - - fsr_at_trap = ucp->uc_mcontext.fpregs.fpu_fsr; - if (trap_flag == (trap_flag | TRAP_SOLICITED)) { - trap_flag = trap_flag & (~TRAP_SOLICITED); - return; - } - trap_flag = trap_flag | TRAP_UNSOLICITED; - - _exit(FPU_SIG_BUS); - -} - -/* - * sigfpe_handler(int sig, siginfo_t *sip, ucontext_t *ucp) - * sets up the sigfpe signal handler. If reached during - * non-negative testing, application exits. - */ -/* ARGSUSED */ -static void -sigfpe_handler(int sig, siginfo_t *sip, ucontext_t *ucp) -{ - ucp->uc_mcontext.fpregs.fpu_qcnt = 0; - - fsr_at_trap = ucp->uc_mcontext.fpregs.fpu_fsr; - if (trap_flag == (trap_flag | TRAP_SOLICITED)) { - trap_flag = trap_flag & (~TRAP_SOLICITED); - return; - } - trap_flag = trap_flag | TRAP_UNSOLICITED; - - _exit(FPU_SIG_FPE); -} - -/* - * sigill_handler(int sig, siginfo_t *sip, ucontext_t *ucp) - * sets up the sigill signal handler. If reached during - * non-negative testing, application exits. - */ -/* ARGSUSED */ -static void -sigill_handler(int sig, siginfo_t *sip, ucontext_t *ucp) -{ - ucp->uc_mcontext.fpregs.fpu_qcnt = 0; - - fsr_at_trap = ucp->uc_mcontext.fpregs.fpu_fsr; - if (trap_flag == (trap_flag | TRAP_SOLICITED)) { - trap_flag = trap_flag & (~TRAP_SOLICITED); - return; - } - trap_flag = trap_flag | TRAP_UNSOLICITED; - - _exit(FPU_SIG_ILL); -} - -/* - * winitfp() sets the signal handlers used - * for negative testing. If sigaction fails, - * the program exits. - */ -int -winitfp() -{ - (void) sigemptyset(&newfpe.sa_mask); - newfpe.sa_flags = SA_SIGINFO; - newfpe.sa_handler = sigfpe_handler; - if (sigaction(SIGFPE, &newfpe, &oldfpe)) { - _exit(FPU_SYSCALL_FAIL); - } - - (void) sigemptyset(&newill.sa_mask); - newill.sa_flags = SA_SIGINFO; - newill.sa_handler = sigill_handler; - if (sigaction(SIGILL, &newill, &oldill)) { - _exit(FPU_SYSCALL_FAIL); - } - - (void) sigemptyset(&newbus.sa_mask); - newbus.sa_flags = SA_SIGINFO; - newbus.sa_handler = sigbus_handler; - if (sigaction(SIGBUS, &newbus, &oldbus)) { - _exit(FPU_SYSCALL_FAIL); - } - - (void) sigemptyset(&newsegv.sa_mask); - newsegv.sa_flags = SA_SIGINFO; - newsegv.sa_handler = sigsegv_handler; - if (sigaction(SIGSEGV, &newsegv, &oldsegv)) { - _exit(FPU_SYSCALL_FAIL); - } - - return (0); -} -#endif - -/* - * restore_signals() turns off the signal - * handlers used by restoring the original - * values. If sigaction fails, the program - * exits. - */ -int -restore_signals() -{ - if (sigaction(SIGSEGV, &oldsegv, &newsegv)) { - _exit(FPU_SYSCALL_FAIL); - } - - if (sigaction(SIGBUS, &oldbus, &newbus)) { - _exit(FPU_SYSCALL_FAIL); - } - - if (sigaction(SIGILL, &oldill, &newill)) { - _exit(FPU_SYSCALL_FAIL); - } - - if (sigaction(SIGFPE, &oldfpe, &newfpe)) { - _exit(FPU_SYSCALL_FAIL); - } - - return (0); - -} - -/* - * fpu_sysdiag(struct fps_test_ereport *report) - * is the main caller of all fpu subtests. It - * does the following tests: normal registers, fsr, - * moving instructions, conversion instructions, - * absolute values, compare, branching, arithmatic, - * chain, datapath, and timing. - * If an error is found, relevant data is stored - * in report. - */ -int -fpu_sysdiag(struct fps_test_ereport *report) -{ - - int i; - -#ifndef i86pc - - /* - * Initialize neg_val_sp[] and neg_val_dp[] with the -ve versions of - * the values in val[] - */ - for (i = 0; i < N_VALS; i++) { - neg_val_sp[i] = val[i].floatsingle | - ((uint32_t)1) << 31; - - neg_val_dp[i] = val[i].floatdouble | - ((uint64_t)1) << 63; - } - - /* Register Testing */ - if (registers_four(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7001); - return (-1); - } - - if (registers_four_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7002); - } - - if (registers_two(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7003); - } - - if (registers_two_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7004); - return (-1); - } - - if (registers_one(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7005); - return (-1); - } - - if (registers_one_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7006); - return (-1); - } - - /* FSR testing */ - if (fsr_test(report)) { - return (-1); - - } - - if (trap_flag) { - fail_trap(report, 7007); - return (-1); - } - - if (fmovs_ins(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7008); - return (-1); - } - - /* Conversion routines */ - if (integer_to_float_sp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7009); - return (-1); - } - - if (integer_to_float_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7010); - return (-1); - } - - if (long_to_float_sp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7011); - return (-1); - } - - if (long_to_float_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7012); - return (-1); - } - - if (float_to_integer_sp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7013); - return (-1); - } - - if (float_to_integer_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7014); - return (-1); - } - - if (float_to_long_dp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7015); - return (-1); - } - - if (float_to_long_sp(report)) { - return (-1); - } - - if (trap_flag) { - fail_trap(report, 7016); - return (-1); - } - - if (single_doub(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7017); - return (-1); - } - if (double_sing(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7018); - return (-1); - } - /* Absolute, -ve instructions */ - if (fabs_ins_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7019); - return (-1); - } - if (fabs_ins_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7020); - return (-1); - } - if (get_negative_value_pn_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7021); - return (-1); - } - if (get_negative_value_pn_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7022); - return (-1); - } - if (get_negative_value_np_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7023); - return (-1); - } - if (get_negative_value_np_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7024); - return (-1); - } - /* Compare and branch instructions */ - if (compare_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7025); - return (-1); - } - if (compare_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7026); - return (-1); - } - if (compare_sp_except(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7027); - return (-1); - } - if (compare_dp_except(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7028); - return (-1); - } - if (branching(report)) { - return (-1); - - } - if (trap_flag) { - fail_trap(report, 7029); - return (-1); - } - if (no_branching(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7030); - return (-1); - } - /* Arithmetic instructions */ - if (addition_test_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7031); - return (-1); - } - if (addition_test_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7032); - return (-1); - } - if (subtraction_test_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7033); - return (-1); - } - if (subtraction_test_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7034); - return (-1); - } - if (multiplication_test_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7035); - return (-1); - } - if (multiplication_test_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7036); - return (-1); - } - if (squareroot_test_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7037); - return (-1); - } - if (squareroot_test_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7038); - return (-1); - } - if (division_test_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7039); - return (-1); - } - if (division_test_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7040); - return (-1); - } - /* chain, datapath, timing tests */ - if (chain_sp_test(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7041); - return (-1); - } - if (chain_dp_test(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7042); - return (-1); - } - if (data_path_sp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7043); - return (-1); - } - if (data_path_dp(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7044); - return (-1); - } - if (timing_test(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7045); - return (-1); - } - if (check_conv(report)) { - return (-1); - } - if (trap_flag) { - fail_trap(report, 7046); - return (-1); - } -#endif /* i86pc */ - -return (0); -} - -#define LLL 64 -#define REP_RXd "1104199269.000000" -#define REP_RXc "1104199269,000000" -#define REP_GCONd "4.5" -#define REP_GCONc "4,5" - -/* - * check_conv(struct fps_test_ereport *report) - * does a series of conversion testing. - * If an error is found, relevant data is stored - * in report. - */ -static int -check_conv(struct fps_test_ereport *report) -{ - char dec_point; - char err_data[MAX_INFO_SIZE]; - double gcon; - char l_buf[LLL]; - char *pREP_RX; - char *pREP_GCON; - double rx; - long double qgcon; - struct lconv *lconv2; - uint64_t observed; - uint64_t expected; - - (void) memset(l_buf, 0, LLL); - - lconv2 = localeconv(); - if (NULL == lconv2) - return (0); - if (NULL == lconv2->decimal_point) - return (0); - - /* expect "." or ",". if not than return */ - if (1 == strlen(lconv2->decimal_point)) - dec_point = lconv2->decimal_point[0]; - else - return (0); - - if (',' == dec_point) { - pREP_RX = REP_RXc; - pREP_GCON = REP_GCONc; - } else if ('.' == dec_point) { - pREP_RX = REP_RXd; - pREP_GCON = REP_GCONd; - } else - return (0); - - rx = 1104199269; - - (void) snprintf(l_buf, LLL - 1, "%f", rx); - if (strncmp(l_buf, pREP_RX, strlen(pREP_RX)) != 0) { - observed = (uint64_t)1; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "\nObserved: %s\nExpected: %s", l_buf, pREP_RX); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6326, &observed, &expected, 1, 1, err_data); - - return (-1); - } - - gcon = 4.5; - (void) memset(l_buf, 0, LLL); - (void) gconvert(gcon, 15, 0, l_buf); - if (strncmp(l_buf, pREP_GCON, strlen(pREP_GCON)) != 0) { - observed = (uint64_t)1; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "\nObserved: %s\nExpected: %s", l_buf, pREP_GCON); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6327, &observed, &expected, 1, 1, err_data); - - return (-2); - } - - qgcon = 4.5; - (void) memset(l_buf, 0, LLL); - (void) qgconvert(&qgcon, 15, 0, l_buf); - if (strncmp(l_buf, pREP_GCON, strlen(pREP_GCON)) != 0) { - observed = (uint64_t)1; - expected = (uint64_t)0; - (void) snprintf(err_data, sizeof (err_data), - "\nObserved: %s\nExpected: %s", l_buf, pREP_GCON); - setup_fps_test_struct(IS_EREPORT_INFO, report, - 6328, &observed, &expected, 1, 1, err_data); - - return (-3); - } - - return (0); -} - -/* - * fail_trap(struct fps_test_ereport *report, int flag_num) - * creates the ereport data if a trap flag is set after a - * successful test when it shouldn't be. - */ -static void -fail_trap(struct fps_test_ereport *report, int flag_num) -{ - uint64_t observed = 1; - uint64_t expected = 0; - - setup_fps_test_struct(NO_EREPORT_INFO, report, - flag_num, &observed, &expected, 1, 1); -} |