IVGCVSW-5306 Add floating point type checks to NumericCast.hpp

 * Added Unit Tests to capture all combinations.

Signed-off-by: Matthew Sloyan <matthew.sloyan@arm.com>
Change-Id: I04db920a5f5f485dc00b2f16582cf7e0bbef3ef2

1 files changed, 146 insertions, 20 deletions

diff --git a/include/armnn/utility/NumericCast.hpp b/include/armnn/utility/NumericCast.hpp
index af34013c30..cdbfd89638 100644
--- a/include/armnn/utility/NumericCast.hpp
+++ b/include/armnn/utility/NumericCast.hpp
@@ -22,14 +22,16 @@ namespace armnn
 #if defined(ARMNN_NUMERIC_CAST_TESTABLE)
 #   define ARMNN_NUMERIC_CAST_CHECK(cond, msg) ConditionalThrow<std::bad_cast>(cond)
 #else
-#   define ARMNN_NUMERIC_CAST_CHECK(cond, msg) ARMNN_ASSERT_MSG(cond, msg)
+#define ARMNN_NUMERIC_CAST_CHECK(cond, msg) ARMNN_ASSERT_MSG(cond, msg)
 #endif
 
+// Unsigned to Unsigned
+
 template<typename Dest, typename Source>
 typename std::enable_if_t<
     std::is_unsigned<Source>::value &&
-    std::is_unsigned<Dest>::value
-    , Dest>
+    std::is_unsigned<Dest>::value,
+    Dest>
 numeric_cast(Source source)
 {
 #if ENABLE_NUMERIC_CAST_CHECKS
@@ -43,26 +45,53 @@ numeric_cast(Source source)
     return static_cast<Dest>(source);
 }
 
+// Signed to Signed
+
+// numeric cast from signed integral to signed integral types, checked for narrowing overflows
 template<typename Dest, typename Source>
 typename std::enable_if_t<
     std::is_signed<Source>::value &&
-    std::is_signed<Dest>::value
-    , Dest>
+    std::is_integral<Source>::value &&
+    std::is_signed<Dest>::value &&
+    std::is_integral<Dest>::value,
+    Dest>
 numeric_cast(Source source)
 {
-    static_assert(!std::is_floating_point<Source>::value && !std::is_floating_point<Dest>::value,
-        "numeric_cast doesn't cast float.");
+#if ENABLE_NUMERIC_CAST_CHECKS
+    if (source > std::numeric_limits<Dest>::max())
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed integral type to narrower signed type. "
+                                        "Overflow detected.");
+    }
+
+    if (source < std::numeric_limits<Dest>::lowest())
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed integral type to narrower signed type. "
+                                        "Underflow detected.");
+    }
+#endif // ENABLE_NUMERIC_CAST_CHECKS
+
+    return static_cast<Dest>(source);
+}
 
+// numeric cast from floating point to floating point types, checked for narrowing overflows
+template<typename Dest, typename Source>
+typename std::enable_if_t<
+    std::is_floating_point<Source>::value &&
+    std::is_floating_point<Dest>::value,
+    Dest>
+numeric_cast(Source source)
+{
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (source > std::numeric_limits<Dest>::max())
     {
-        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to narrower signed type. "
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting floating point type to narrower signed type. "
                                         "Overflow detected.");
     }
 
     if (source < std::numeric_limits<Dest>::lowest())
     {
-        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to narrower signed type. "
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting floating point type to narrower signed type. "
                                         "Underflow detected.");
     }
 #endif // ENABLE_NUMERIC_CAST_CHECKS
@@ -70,16 +99,71 @@ numeric_cast(Source source)
     return static_cast<Dest>(source);
 }
 
-// numeric cast from unsigned to signed checked for narrowing overflows
+// numeric cast from floating point types (signed) to signed integral types, checked for narrowing overflows
 template<typename Dest, typename Source>
 typename std::enable_if_t<
+    std::is_floating_point<Source>::value &&
     std::is_signed<Dest>::value &&
-    std::is_unsigned<Source>::value
-    , Dest>
-numeric_cast(Source sValue)
+    std::is_integral<Dest>::value,
+    Dest>
+numeric_cast(Source source)
 {
-    static_assert(!std::is_floating_point<Dest>::value, "numeric_cast doesn't cast to float.");
+#if ENABLE_NUMERIC_CAST_CHECKS
+    if (source > static_cast<Source>(std::numeric_limits<Dest>::max()))
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting floating point type to narrower signed type. "
+                                        "Overflow detected.");
+    }
+
+    if (source < static_cast<Source>(std::numeric_limits<Dest>::lowest()))
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting floating point type to narrower signed type. "
+                                        "Underflow detected.");
+    }
+#endif // ENABLE_NUMERIC_CAST_CHECKS
+
+    return static_cast<Dest>(source);
+}
+
+// numeric cast from signed integral types to floating point types (signed), checked for narrowing overflows
+template<typename Dest, typename Source>
+typename std::enable_if_t<
+    std::is_signed<Source>::value &&
+    std::is_integral<Source>::value &&
+    std::is_floating_point<Dest>::value,
+    Dest>
+numeric_cast(Source source)
+{
+#if ENABLE_NUMERIC_CAST_CHECKS
+    Dest sourceConverted = static_cast<Dest>(source);
+
+    if (sourceConverted > std::numeric_limits<Dest>::max())
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to narrower floating point type. "
+                                        "Overflow detected.");
+    }
+
+    if (sourceConverted < std::numeric_limits<Dest>::lowest())
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to narrower floating point type. "
+                                        "Underflow detected.");
+    }
+#endif // ENABLE_NUMERIC_CAST_CHECKS
+
+    return static_cast<Dest>(source);
+}
+
+// Unsigned to Signed
 
+// numeric cast from unsigned integral type to signed integral type, checked for narrowing overflows
+template<typename Dest, typename Source>
+typename std::enable_if_t<
+    std::is_signed<Dest>::value &&
+    std::is_integral<Dest>::value &&
+    std::is_unsigned<Source>::value,
+    Dest>
+numeric_cast(Source sValue)
+{
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (sValue > static_cast< typename std::make_unsigned<Dest>::type >(std::numeric_limits<Dest>::max()))
     {
@@ -91,17 +175,36 @@ numeric_cast(Source sValue)
     return static_cast<Dest>(sValue);
 }
 
-// numeric cast from signed to unsigned checked for underflows and narrowing overflows
+// numeric cast from unsigned integral type to floating point (signed), checked for narrowing overflows
 template<typename Dest, typename Source>
 typename std::enable_if_t<
-    std::is_unsigned<Dest>::value &&
-    std::is_signed<Source>::value
-    , Dest>
+    std::is_floating_point<Dest>::value &&
+    std::is_unsigned<Source>::value,
+    Dest>
 numeric_cast(Source sValue)
 {
-    static_assert(!std::is_floating_point<Source>::value && !std::is_floating_point<Dest>::value,
-        "numeric_cast doesn't cast floats.");
+#if ENABLE_NUMERIC_CAST_CHECKS
+    if (static_cast<Dest>(sValue) > std::numeric_limits<Dest>::max())
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting unsigned type to floating point type. "
+                                        "Overflow detected.");
+    }
+#endif // ENABLE_NUMERIC_CAST_CHECKS
+
+    return static_cast<Dest>(sValue);
+}
+
+// Signed to Unsigned
 
+// numeric cast from signed integral types to unsigned integral type, checked for underflows and narrowing overflows
+template<typename Dest, typename Source>
+typename std::enable_if_t<
+    std::is_unsigned<Dest>::value &&
+    std::is_signed<Source>::value &&
+    std::is_integral<Source>::value,
+    Dest>
+numeric_cast(Source sValue)
+{
 #if ENABLE_NUMERIC_CAST_CHECKS
     if (sValue < 0)
     {
@@ -114,7 +217,30 @@ numeric_cast(Source sValue)
         ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting signed type to unsigned type. "
                                         "Overflow detected.");
     }
+#endif // ENABLE_NUMERIC_CAST_CHECKS
+    return static_cast<Dest>(sValue);
+}
 
+// numeric cast from floating point (signed) to unsigned integral type, checked for underflows and narrowing overflows
+template<typename Dest, typename Source>
+typename std::enable_if_t<
+    std::is_unsigned<Dest>::value &&
+    std::is_floating_point<Source>::value,
+    Dest>
+numeric_cast(Source sValue)
+{
+#if ENABLE_NUMERIC_CAST_CHECKS
+    if (sValue < 0)
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting negative value to unsigned type. "
+                                        "Underflow detected.");
+    }
+
+    if (sValue > static_cast<Source>(std::numeric_limits<Dest>::max()))
+    {
+        ARMNN_NUMERIC_CAST_CHECK(false, "numeric_cast failed casting floating point type to unsigned type. "
+                                        "Overflow detected.");
+    }
 #endif // ENABLE_NUMERIC_CAST_CHECKS
     return static_cast<Dest>(sValue);
 }