kc3-lang/angle/src/tests/compiler_tests/FloatLex_test.cpp

• Show log

  Commit

• Hash : d27a1fd0
  Author :
  Date : 2025-04-03T19:59:20
  

  Compiler: Allow denorm float values in the lexer
  
  This adds an option to preserve denorm values in the lexer,
  skipping the explicit zero conversions for below range floats.
  
  There are applications in the wild that expect to be able to
  use denorm float values. They are typically immediately converted
  to integer values, not used in floating point operations.
  
  The option is only enabled for Vulkan backends.
  
  Test: FloatLexTest, DenormFloatsToIntValues, app traces
  Bug: b/406827038
  Change-Id: Iab5a1a69a540b78ccbce8ea90b532d2d4976e29e
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/6432237
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Geoff Lang <geofflang@chromium.org>
  Commit-Queue: Cody Northrop <cnorthrop@google.com>
  

Download

• src/tests/compiler_tests/FloatLex_test.cpp

• //
  // Copyright 2016 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  // FloatLex_test.cpp:
  // Tests for parsing floats in GLSL source.
  //
  
  #include <sstream>
  #include <string>
  
  #include "common/debug.h"
  #include "common/mathutil.h"
  #include "compiler/translator/util.h"
  #include "gtest/gtest.h"
  
  namespace
  {
  
  class StrtofClampParser
  {
    public:
      static float Parse(std::string str)
      {
          float value;
          sh::strtof_clamp(str, &value, true);
          return value;
      }
  };
  
  class NumericLexFloatParser
  {
    public:
      static float Parse(std::string str)
      {
          return sh::NumericLexFloat32OutOfRangeToInfinity(str, true);
      }
  };
  
  }  // anonymous namespace
  
  template <typename T>
  class FloatLexTest : public ::testing::Test
  {
    public:
      FloatLexTest() {}
  
    protected:
      void SetUp() override {}
  
      void TearDown() override {}
  
      static bool ParsedMatches(std::string str, float expected)
      {
          return (T::Parse(str) == expected);
      }
  
      static bool IsInfinity(std::string str)
      {
          float f = T::Parse(str);
          return gl::isInf(f);
      }
  
      static std::string Zeros(size_t count) { return std::string(count, '0'); }
  };
  
  typedef ::testing::Types<StrtofClampParser, NumericLexFloatParser> FloatParserTypes;
  TYPED_TEST_SUITE(FloatLexTest, FloatParserTypes);
  
  TYPED_TEST(FloatLexTest, One)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1.0", 1.0f));
  }
  
  TYPED_TEST(FloatLexTest, Ten)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("10.0", 10.0f));
  }
  
  TYPED_TEST(FloatLexTest, TenScientific)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1.0e1", 10.0f));
  }
  
  TYPED_TEST(FloatLexTest, ScientificWithSmallMantissa)
  {
      std::stringstream ss;
      ss << "0." << TestFixture::Zeros(100) << "125e102";
      ASSERT_TRUE(TestFixture::ParsedMatches(ss.str(), 12.5f));
  }
  
  TYPED_TEST(FloatLexTest, ScientificWithLargeMantissa)
  {
      std::stringstream ss;
      ss << "9" << TestFixture::Zeros(100) << ".0e-100";
      ASSERT_TRUE(TestFixture::ParsedMatches(ss.str(), 9.0f));
  }
  
  TYPED_TEST(FloatLexTest, ScientificWithVerySmallMantissa)
  {
      std::stringstream ss;
      ss << "0." << TestFixture::Zeros(5000) << "125e5002";
      ASSERT_TRUE(TestFixture::ParsedMatches(ss.str(), 12.5f));
  }
  
  TYPED_TEST(FloatLexTest, ScientificWithVeryLargeMantissa)
  {
      std::stringstream ss;
      ss << "9" << TestFixture::Zeros(5000) << ".0e-5000";
      ASSERT_TRUE(TestFixture::ParsedMatches(ss.str(), 9.0f));
  }
  
  TYPED_TEST(FloatLexTest, StartWithDecimalDot)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches(".125", 0.125f));
  }
  
  TYPED_TEST(FloatLexTest, EndWithDecimalDot)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("123.", 123.0f));
  }
  
  TYPED_TEST(FloatLexTest, NoDecimalDot)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("125e-2", 1.25f));
  }
  
  TYPED_TEST(FloatLexTest, EndStartWithDecimalDotScientific)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches(".625e-1", 0.0625f));
  }
  
  TYPED_TEST(FloatLexTest, EndWithDecimalDotScientific)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("102400.e-2", 1024.0f));
  }
  
  TYPED_TEST(FloatLexTest, UppercaseE)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("125E-2", 1.25f));
  }
  
  TYPED_TEST(FloatLexTest, PlusInExponent)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1E+2", 100.0f));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyAboveMaxFloat)
  {
      ASSERT_TRUE(TestFixture::IsInfinity("3.4029e38"));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyBelowMaxFloat)
  {
      ASSERT_FALSE(TestFixture::IsInfinity("3.4028e38"));
      ASSERT_TRUE(TestFixture::ParsedMatches("3.4028e38", 3.4028e38f));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyAboveMaxFloatLargerMantissa)
  {
      ASSERT_TRUE(TestFixture::IsInfinity("34.029e37"));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyBelowMaxFloatLargerMantissa)
  {
      ASSERT_FALSE(TestFixture::IsInfinity("34.028e37"));
      ASSERT_TRUE(TestFixture::ParsedMatches("34.028e37", 3.4028e38f));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyAboveMaxFloatSmallerMantissa)
  {
      ASSERT_TRUE(TestFixture::IsInfinity("0.34029e39"));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyBelowMaxFloatSmallerMantissa)
  {
      ASSERT_FALSE(TestFixture::IsInfinity("0.34028e39"));
      ASSERT_TRUE(TestFixture::ParsedMatches("0.34028e39", 3.4028e38f));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyBelowMinSubnormalFloat)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1.0e-48", 0.0f));
  }
  
  TYPED_TEST(FloatLexTest, SlightlyAboveMinNormalFloat)
  {
      ASSERT_FALSE(TestFixture::ParsedMatches("1.1754943E-38", 0.0f));
  }
  
  TYPED_TEST(FloatLexTest, ManySignificantDigits)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1.23456789", 1.23456789f));
  }
  
  TYPED_TEST(FloatLexTest, MantissaBitAboveMaxUint)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("4294967299.", 4294967299.0f));
  }
  
  TYPED_TEST(FloatLexTest, ExponentBitAboveMaxInt)
  {
      ASSERT_TRUE(TestFixture::IsInfinity("1.0e2147483649"));
  }
  
  TYPED_TEST(FloatLexTest, ExponentBitBelowMaxIntAndLargeMantissa)
  {
      std::stringstream ss;
      ss << "1" << TestFixture::Zeros(32) << ".0e2147483640";
      ASSERT_TRUE(TestFixture::IsInfinity(ss.str()));
  }
  
  TYPED_TEST(FloatLexTest, ExponentBitAboveMinIntAndSmallMantissa)
  {
      std::stringstream ss;
      ss << "0." << TestFixture::Zeros(32) << "1e-2147483640";
      ASSERT_TRUE(TestFixture::ParsedMatches(ss.str(), 0.0f));
  }
  
  // Ensure the smallest possible denorm float value is preserved
  TYPED_TEST(FloatLexTest, SmallestPossibleDenormFloat)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1.40129846e-45", 1.40129846e-45f));
  }
  
  // Ensure the largest possible denorm float value is preserved
  TYPED_TEST(FloatLexTest, LargestPossibleDenormFloat)
  {
      ASSERT_TRUE(TestFixture::ParsedMatches("1.1754942107e-38", 1.1754942107e-38f));
  }
  

Download