1// -*- mode:c++ -*- 2 3// Copyright (c) 2015 RISC-V Foundation 4// Copyright (c) 2017 The University of Virginia 5// All rights reserved. 6// 7// Redistribution and use in source and binary forms, with or without 8// modification, are permitted provided that the following conditions are --- 770 unchanged lines hidden (view full) --- 779 0x10: decode FUNCT2 { 780 0x0: fmadd_s({{ 781 uint32_t temp; 782 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 783 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 784 float fs3 = reinterpret_cast<float&>(temp = Fs3_bits); 785 float fd; 786 |
787 if (std::isnan(fs1) || std::isnan(fs2) || 788 std::isnan(fs3)) { |
789 if (issignalingnan(fs1) || issignalingnan(fs2) 790 || issignalingnan(fs3)) { 791 FFLAGS |= FloatInvalid; 792 } 793 fd = numeric_limits<float>::quiet_NaN(); |
794 } else if (std::isinf(fs1) || std::isinf(fs2) || 795 std::isinf(fs3)) { |
796 if (signbit(fs1) == signbit(fs2) |
797 && !std::isinf(fs3)) { |
798 fd = numeric_limits<float>::infinity(); 799 } else if (signbit(fs1) != signbit(fs2) |
800 && !std::isinf(fs3)) { |
801 fd = -numeric_limits<float>::infinity(); 802 } else { // Fs3_sf is infinity 803 fd = fs3; 804 } 805 } else { 806 fd = fs1*fs2 + fs3; 807 } 808 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 809 }}, FloatMultOp); 810 0x1: fmadd_d({{ |
811 if (std::isnan(Fs1) || std::isnan(Fs2) || 812 std::isnan(Fs3)) { |
813 if (issignalingnan(Fs1) || issignalingnan(Fs2) 814 || issignalingnan(Fs3)) { 815 FFLAGS |= FloatInvalid; 816 } 817 Fd = numeric_limits<double>::quiet_NaN(); |
818 } else if (std::isinf(Fs1) || std::isinf(Fs2) || 819 std::isinf(Fs3)) { |
820 if (signbit(Fs1) == signbit(Fs2) |
821 && !std::isinf(Fs3)) { |
822 Fd = numeric_limits<double>::infinity(); 823 } else if (signbit(Fs1) != signbit(Fs2) |
824 && !std::isinf(Fs3)) { |
825 Fd = -numeric_limits<double>::infinity(); 826 } else { 827 Fd = Fs3; 828 } 829 } else { 830 Fd = Fs1*Fs2 + Fs3; 831 } 832 }}, FloatMultOp); 833 } 834 0x11: decode FUNCT2 { 835 0x0: fmsub_s({{ 836 uint32_t temp; 837 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 838 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 839 float fs3 = reinterpret_cast<float&>(temp = Fs3_bits); 840 float fd; 841 |
842 if (std::isnan(fs1) || std::isnan(fs2) || 843 std::isnan(fs3)) { |
844 if (issignalingnan(fs1) || issignalingnan(fs2) 845 || issignalingnan(fs3)) { 846 FFLAGS |= FloatInvalid; 847 } 848 fd = numeric_limits<float>::quiet_NaN(); |
849 } else if (std::isinf(fs1) || std::isinf(fs2) || 850 std::isinf(fs3)) { |
851 if (signbit(fs1) == signbit(fs2) |
852 && !std::isinf(fs3)) { |
853 fd = numeric_limits<float>::infinity(); 854 } else if (signbit(fs1) != signbit(fs2) |
855 && !std::isinf(fs3)) { |
856 fd = -numeric_limits<float>::infinity(); 857 } else { // Fs3_sf is infinity 858 fd = -fs3; 859 } 860 } else { 861 fd = fs1*fs2 - fs3; 862 } 863 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 864 }}, FloatMultOp); 865 0x1: fmsub_d({{ |
866 if (std::isnan(Fs1) || std::isnan(Fs2) || 867 std::isnan(Fs3)) { |
868 if (issignalingnan(Fs1) || issignalingnan(Fs2) 869 || issignalingnan(Fs3)) { 870 FFLAGS |= FloatInvalid; 871 } 872 Fd = numeric_limits<double>::quiet_NaN(); |
873 } else if (std::isinf(Fs1) || std::isinf(Fs2) || 874 std::isinf(Fs3)) { |
875 if (signbit(Fs1) == signbit(Fs2) |
876 && !std::isinf(Fs3)) { |
877 Fd = numeric_limits<double>::infinity(); 878 } else if (signbit(Fs1) != signbit(Fs2) |
879 && !std::isinf(Fs3)) { |
880 Fd = -numeric_limits<double>::infinity(); 881 } else { 882 Fd = -Fs3; 883 } 884 } else { 885 Fd = Fs1*Fs2 - Fs3; 886 } 887 }}, FloatMultOp); 888 } 889 0x12: decode FUNCT2 { 890 0x0: fnmsub_s({{ 891 uint32_t temp; 892 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 893 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 894 float fs3 = reinterpret_cast<float&>(temp = Fs3_bits); 895 float fd; 896 |
897 if (std::isnan(fs1) || std::isnan(fs2) || 898 std::isnan(fs3)) { |
899 if (issignalingnan(fs1) || issignalingnan(fs2) 900 || issignalingnan(fs3)) { 901 FFLAGS |= FloatInvalid; 902 } 903 fd = numeric_limits<float>::quiet_NaN(); |
904 } else if (std::isinf(fs1) || std::isinf(fs2) || 905 std::isinf(fs3)) { |
906 if (signbit(fs1) == signbit(fs2) |
907 && !std::isinf(fs3)) { |
908 fd = -numeric_limits<float>::infinity(); 909 } else if (signbit(fs1) != signbit(fs2) |
910 && !std::isinf(fs3)) { |
911 fd = numeric_limits<float>::infinity(); 912 } else { // Fs3_sf is infinity 913 fd = fs3; 914 } 915 } else { 916 fd = -(fs1*fs2 - fs3); 917 } 918 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 919 }}, FloatMultOp); 920 0x1: fnmsub_d({{ |
921 if (std::isnan(Fs1) || std::isnan(Fs2) || 922 std::isnan(Fs3)) { |
923 if (issignalingnan(Fs1) || issignalingnan(Fs2) 924 || issignalingnan(Fs3)) { 925 FFLAGS |= FloatInvalid; 926 } 927 Fd = numeric_limits<double>::quiet_NaN(); |
928 } else if (std::isinf(Fs1) || std::isinf(Fs2) 929 || std::isinf(Fs3)) { |
930 if (signbit(Fs1) == signbit(Fs2) |
931 && !std::isinf(Fs3)) { |
932 Fd = -numeric_limits<double>::infinity(); 933 } else if (signbit(Fs1) != signbit(Fs2) |
934 && !std::isinf(Fs3)) { |
935 Fd = numeric_limits<double>::infinity(); 936 } else { 937 Fd = Fs3; 938 } 939 } else { 940 Fd = -(Fs1*Fs2 - Fs3); 941 } 942 }}, FloatMultOp); 943 } 944 0x13: decode FUNCT2 { 945 0x0: fnmadd_s({{ 946 uint32_t temp; 947 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 948 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 949 float fs3 = reinterpret_cast<float&>(temp = Fs3_bits); 950 float fd; 951 |
952 if (std::isnan(fs1) || std::isnan(fs2) || 953 std::isnan(fs3)) { |
954 if (issignalingnan(fs1) || issignalingnan(fs2) 955 || issignalingnan(fs3)) { 956 FFLAGS |= FloatInvalid; 957 } 958 fd = numeric_limits<float>::quiet_NaN(); |
959 } else if (std::isinf(fs1) || std::isinf(fs2) || 960 std::isinf(fs3)) { |
961 if (signbit(fs1) == signbit(fs2) |
962 && !std::isinf(fs3)) { |
963 fd = -numeric_limits<float>::infinity(); 964 } else if (signbit(fs1) != signbit(fs2) |
965 && !std::isinf(fs3)) { |
966 fd = numeric_limits<float>::infinity(); 967 } else { // Fs3_sf is infinity 968 fd = -fs3; 969 } 970 } else { 971 fd = -(fs1*fs2 + fs3); 972 } 973 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 974 }}, FloatMultOp); 975 0x1: fnmadd_d({{ |
976 if (std::isnan(Fs1) || std::isnan(Fs2) || 977 std::isnan(Fs3)) { |
978 if (issignalingnan(Fs1) || issignalingnan(Fs2) 979 || issignalingnan(Fs3)) { 980 FFLAGS |= FloatInvalid; 981 } 982 Fd = numeric_limits<double>::quiet_NaN(); |
983 } else if (std::isinf(Fs1) || std::isinf(Fs2) || 984 std::isinf(Fs3)) { |
985 if (signbit(Fs1) == signbit(Fs2) |
986 && !std::isinf(Fs3)) { |
987 Fd = -numeric_limits<double>::infinity(); 988 } else if (signbit(Fs1) != signbit(Fs2) |
989 && !std::isinf(Fs3)) { |
990 Fd = numeric_limits<double>::infinity(); 991 } else { 992 Fd = -Fs3; 993 } 994 } else { 995 Fd = -(Fs1*Fs2 + Fs3); 996 } 997 }}, FloatMultOp); 998 } 999 0x14: decode FUNCT7 { 1000 0x0: fadd_s({{ 1001 uint32_t temp; 1002 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1003 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1004 float fd; 1005 |
1006 if (std::isnan(fs1) || std::isnan(fs2)) { |
1007 if (issignalingnan(fs1) || issignalingnan(fs2)) { 1008 FFLAGS |= FloatInvalid; 1009 } 1010 fd = numeric_limits<float>::quiet_NaN(); 1011 } else { 1012 fd = fs1 + fs2; 1013 } 1014 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 1015 }}, FloatAddOp); 1016 0x1: fadd_d({{ |
1017 if (std::isnan(Fs1) || std::isnan(Fs2)) { |
1018 if (issignalingnan(Fs1) || issignalingnan(Fs2)) { 1019 FFLAGS |= FloatInvalid; 1020 } 1021 Fd = numeric_limits<double>::quiet_NaN(); 1022 } else { 1023 Fd = Fs1 + Fs2; 1024 } 1025 }}, FloatAddOp); 1026 0x4: fsub_s({{ 1027 uint32_t temp; 1028 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1029 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1030 float fd; 1031 |
1032 if (std::isnan(fs1) || std::isnan(fs2)) { |
1033 if (issignalingnan(fs1) || issignalingnan(fs2)) { 1034 FFLAGS |= FloatInvalid; 1035 } 1036 fd = numeric_limits<float>::quiet_NaN(); 1037 } else { 1038 fd = fs1 - fs2; 1039 } 1040 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 1041 }}, FloatAddOp); 1042 0x5: fsub_d({{ |
1043 if (std::isnan(Fs1) || std::isnan(Fs2)) { |
1044 if (issignalingnan(Fs1) || issignalingnan(Fs2)) { 1045 FFLAGS |= FloatInvalid; 1046 } 1047 Fd = numeric_limits<double>::quiet_NaN(); 1048 } else { 1049 Fd = Fs1 - Fs2; 1050 } 1051 }}, FloatAddOp); 1052 0x8: fmul_s({{ 1053 uint32_t temp; 1054 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1055 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1056 float fd; 1057 |
1058 if (std::isnan(fs1) || std::isnan(fs2)) { |
1059 if (issignalingnan(fs1) || issignalingnan(fs2)) { 1060 FFLAGS |= FloatInvalid; 1061 } 1062 fd = numeric_limits<float>::quiet_NaN(); 1063 } else { 1064 fd = fs1*fs2; 1065 } 1066 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 1067 }}, FloatMultOp); 1068 0x9: fmul_d({{ |
1069 if (std::isnan(Fs1) || std::isnan(Fs2)) { |
1070 if (issignalingnan(Fs1) || issignalingnan(Fs2)) { 1071 FFLAGS |= FloatInvalid; 1072 } 1073 Fd = numeric_limits<double>::quiet_NaN(); 1074 } else { 1075 Fd = Fs1*Fs2; 1076 } 1077 }}, FloatMultOp); 1078 0xc: fdiv_s({{ 1079 uint32_t temp; 1080 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1081 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1082 float fd; 1083 |
1084 if (std::isnan(fs1) || std::isnan(fs2)) { |
1085 if (issignalingnan(fs1) || issignalingnan(fs2)) { 1086 FFLAGS |= FloatInvalid; 1087 } 1088 fd = numeric_limits<float>::quiet_NaN(); 1089 } else { 1090 fd = fs1/fs2; 1091 } 1092 Fd_bits = (uint64_t)reinterpret_cast<uint32_t&>(fd); 1093 }}, FloatDivOp); 1094 0xd: fdiv_d({{ |
1095 if (std::isnan(Fs1) || std::isnan(Fs2)) { |
1096 if (issignalingnan(Fs1) || issignalingnan(Fs2)) { 1097 FFLAGS |= FloatInvalid; 1098 } 1099 Fd = numeric_limits<double>::quiet_NaN(); 1100 } else { 1101 Fd = Fs1/Fs2; 1102 } 1103 }}, FloatDivOp); --- 167 unchanged lines hidden (view full) --- 1271 Fd = sqrt(Fs1); 1272 }}, FloatSqrtOp); 1273 0x50: decode ROUND_MODE { 1274 0x0: fle_s({{ 1275 uint32_t temp; 1276 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1277 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1278 |
1279 if (std::isnan(fs1) || std::isnan(fs2)) { |
1280 FFLAGS |= FloatInvalid; 1281 Rd = 0; 1282 } else { 1283 Rd = fs1 <= fs2 ? 1 : 0; 1284 } 1285 }}, FloatCmpOp); 1286 0x1: flt_s({{ 1287 uint32_t temp; 1288 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1289 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1290 |
1291 if (std::isnan(fs1) || std::isnan(fs2)) { |
1292 FFLAGS |= FloatInvalid; 1293 Rd = 0; 1294 } else { 1295 Rd = fs1 < fs2 ? 1 : 0; 1296 } 1297 }}, FloatCmpOp); 1298 0x2: feq_s({{ 1299 uint32_t temp; 1300 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1301 float fs2 = reinterpret_cast<float&>(temp = Fs2_bits); 1302 1303 if (issignalingnan(fs1) || issignalingnan(fs2)) { 1304 FFLAGS |= FloatInvalid; 1305 } 1306 Rd = fs1 == fs2 ? 1 : 0; 1307 }}, FloatCmpOp); 1308 } 1309 0x51: decode ROUND_MODE { 1310 0x0: fle_d({{ |
1311 if (std::isnan(Fs1) || std::isnan(Fs2)) { |
1312 FFLAGS |= FloatInvalid; 1313 Rd = 0; 1314 } else { 1315 Rd = Fs1 <= Fs2 ? 1 : 0; 1316 } 1317 }}, FloatCmpOp); 1318 0x1: flt_d({{ |
1319 if (std::isnan(Fs1) || std::isnan(Fs2)) { |
1320 FFLAGS |= FloatInvalid; 1321 Rd = 0; 1322 } else { 1323 Rd = Fs1 < Fs2 ? 1 : 0; 1324 } 1325 }}, FloatCmpOp); 1326 0x2: feq_d({{ 1327 if (issignalingnan(Fs1) || issignalingnan(Fs2)) { 1328 FFLAGS |= FloatInvalid; 1329 } 1330 Rd = Fs1 == Fs2 ? 1 : 0; 1331 }}, FloatCmpOp); 1332 } 1333 0x60: decode CONV_SGN { 1334 0x0: fcvt_w_s({{ 1335 uint32_t temp; 1336 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1337 |
1338 if (std::isnan(fs1)) { |
1339 Rd_sd = numeric_limits<int32_t>::max(); 1340 FFLAGS |= FloatInvalid; 1341 } else { 1342 Rd_sd = (int32_t)fs1; 1343 if (fetestexcept(FE_INVALID)) { 1344 if (signbit(fs1)) { 1345 Rd_sd = numeric_limits<int32_t>::min(); 1346 } else { --- 17 unchanged lines hidden (view full) --- 1364 feclearexcept(FE_INEXACT); 1365 } 1366 } 1367 }}, FloatCvtOp); 1368 0x2: fcvt_l_s({{ 1369 uint32_t temp; 1370 float fs1 = reinterpret_cast<float&>(temp = Fs1_bits); 1371 |
1372 if (std::isnan(fs1)) { |
1373 Rd_sd = numeric_limits<int64_t>::max(); 1374 FFLAGS |= FloatInvalid; 1375 } else { 1376 Rd_sd = (int64_t)fs1; 1377 if (fetestexcept(FE_INVALID)) { 1378 if (signbit(fs1)) { 1379 Rd_sd = numeric_limits<int64_t>::min(); 1380 } else { --- 321 unchanged lines hidden --- |