/* * 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 #include #include #include #include #include #include #include #include #include #include #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); }