1  /* This file is part of the dynarmic project.
 2   * Copyright (c) 2018 MerryMage
 3   * SPDX-License-Identifier: 0BSD
 4   */
 5  
 6  #include <tuple>
 7  #include <vector>
 8  
 9  #include <catch2/catch_test_macros.hpp>
10  #include <mcl/stdint.hpp>
11  
12  #include "../rand_int.h"
13  #include "dynarmic/common/fp/fpcr.h"
14  #include "dynarmic/common/fp/fpsr.h"
15  #include "dynarmic/common/fp/unpacked.h"
16  
17  using namespace Dynarmic;
18  using namespace Dynarmic::FP;
19  
20  TEST_CASE("FPUnpack Tests", "[fp]") {
21      const static std::vector<std::tuple<u32, std::tuple<FPType, bool, FPUnpacked>, u32>> test_cases{
22          {0x00000000, {FPType::Zero, false, ToNormalized(false, 0, 0)}, 0},
23          {0x7F800000, {FPType::Infinity, false, ToNormalized(false, 1000000, 1)}, 0},
24          {0xFF800000, {FPType::Infinity, true, ToNormalized(true, 1000000, 1)}, 0},
25          {0x7F800001, {FPType::SNaN, false, ToNormalized(false, 0, 0)}, 0},
26          {0xFF800001, {FPType::SNaN, true, ToNormalized(true, 0, 0)}, 0},
27          {0x7FC00001, {FPType::QNaN, false, ToNormalized(false, 0, 0)}, 0},
28          {0xFFC00001, {FPType::QNaN, true, ToNormalized(true, 0, 0)}, 0},
29          {0x00000001, {FPType::Nonzero, false, ToNormalized(false, -149, 1)}, 0},        // Smallest single precision denormal is 2^-149.
30          {0x3F7FFFFF, {FPType::Nonzero, false, ToNormalized(false, -24, 0xFFFFFF)}, 0},  // 1.0 - epsilon
31      };
32  
33      const FPCR fpcr;
34      for (const auto& [input, expected_output, expected_fpsr] : test_cases) {
35          FPSR fpsr;
36          const auto output = FPUnpack<u32>(input, fpcr, fpsr);
37  
38          INFO("Input: " << std::hex << input);
39          INFO("Output Sign: " << std::get<2>(output).sign);
40          INFO("Output Exponent: " << std::get<2>(output).exponent);
41          INFO("Output Mantissa: " << std::hex << std::get<2>(output).mantissa);
42          INFO("Expected Sign: " << std::get<2>(expected_output).sign);
43          INFO("Expected Exponent: " << std::get<2>(expected_output).exponent);
44          INFO("Expected Mantissa: " << std::hex << std::get<2>(expected_output).mantissa);
45  
46          REQUIRE(output == expected_output);
47          REQUIRE(fpsr.Value() == expected_fpsr);
48      }
49  }
50  
51  TEST_CASE("FPRound Tests", "[fp]") {
52      const static std::vector<std::tuple<u32, std::tuple<FPType, bool, FPUnpacked>, u32>> test_cases{
53          {0x7F800000, {FPType::Infinity, false, ToNormalized(false, 1000000, 1)}, 0x14},
54          {0xFF800000, {FPType::Infinity, true, ToNormalized(true, 1000000, 1)}, 0x14},
55          {0x00000001, {FPType::Nonzero, false, ToNormalized(false, -149, 1)}, 0},            // Smallest single precision denormal is 2^-149.
56          {0x3F7FFFFF, {FPType::Nonzero, false, ToNormalized(false, -24, 0xFFFFFF)}, 0},      // 1.0 - epsilon
57          {0x3F800000, {FPType::Nonzero, false, ToNormalized(false, -28, 0xFFFFFFF)}, 0x10},  // rounds to 1.0
58      };
59  
60      const FPCR fpcr;
61      for (const auto& [expected_output, input, expected_fpsr] : test_cases) {
62          FPSR fpsr;
63          const auto output = FPRound<u32>(std::get<2>(input), fpcr, fpsr);
64  
65          INFO("Expected Output: " << std::hex << expected_output);
66          REQUIRE(output == expected_output);
67          REQUIRE(fpsr.Value() == expected_fpsr);
68      }
69  }
70  
71  TEST_CASE("FPUnpack<->FPRound Round-trip Tests", "[fp]") {
72      const FPCR fpcr;
73      for (size_t count = 0; count < 100000; count++) {
74          FPSR fpsr;
75          const u32 input = RandInt(0, 1) == 0 ? RandInt<u32>(0x00000001, 0x7F800000) : RandInt<u32>(0x80000001, 0xFF800000);
76          const auto intermediate = std::get<2>(FPUnpack<u32>(input, fpcr, fpsr));
77          const u32 output = FPRound<u32>(intermediate, fpcr, fpsr);
78  
79          INFO("Count: " << count);
80          INFO("Intermediate Values: " << std::hex << intermediate.sign << ';' << intermediate.exponent << ';' << intermediate.mantissa);
81          REQUIRE(input == output);
82      }
83  }
84  
85  TEST_CASE("FPRound (near zero, round to posinf)", "[fp]") {
86      const FPUnpacked input = {false, -353, 0x0a98d25ace5b2000};
87  
88      FPSR fpsr;
89      FPCR fpcr;
90      fpcr.RMode(RoundingMode::TowardsPlusInfinity);
91  
92      const u32 output = FPRound<u32>(input, fpcr, fpsr);
93  
94      REQUIRE(output == 0x00000001);
95  }