Simplify how inline math files are included (#1195)

**Issue #:**

* #1155
* #1194

Users are reporting double definition of the math inline functions, when building in scenarios I'm not familiar with...

The [existing ifdef logic](https://github.com/awslabs/aws-c-common/blob/c6f8f8a3b267e2a2229f71ed0d4b087edd780845/include/aws/common/math.inl#L16-L47) is very hard to follow, so it's not surprising there are edge cases.

**Description of changes:**

Simplify how inline math files are included

- Just have 1 big `#ifdef/elif/elif` chain
  - If a branch needs 2 .inl files, then include both from from that branch
  - math.fallback.inl no longer includes math.gcc_builtin.inl in some circumstances. It's the fallback file. Let's keep it simple.
- Stop doing the thing where we don't include the .inl files when building `__cplusplus`.
  - This added too much complexity. Whatever [weird performance edge case](https://github.com/awslabs/aws-c-common/blob/c6f8f8a3b267e2a2229f71ed0d4b087edd780845/include/aws/common/math.inl#L38-L40) we were working around in 2018 is surely fixed in modern compilers.

Author: graebm

include/aws/common/math.fallback.inl

@@ -94,12 +94,6 @@ AWS_STATIC_IMPL int aws_add_u32_checked(uint32_t a, uint32_t b, uint32_t *r) {
     return AWS_OP_SUCCESS;
 }
 
-/*
- * These are pure C implementations of the count leading/trailing zeros calls
- * They should not be necessary unless using a really esoteric compiler with
- * no intrinsics for these functions whatsoever.
- */
-#if !defined(__clang__) && !defined(__GNUC__)
 /**
  * Search from the MSB to LSB, looking for a 1
  */
@@ -144,11 +138,11 @@ AWS_STATIC_IMPL size_t aws_clz_i64(int64_t n) {
 }
 
 AWS_STATIC_IMPL size_t aws_clz_size(size_t n) {
-#    if SIZE_BITS == 64
+#if SIZE_BITS == 64
     return aws_clz_u64(n);
-#    else
+#else
     return aws_clz_u32(n);
-#    endif
+#endif
 }
 
 /**
@@ -193,14 +187,12 @@ AWS_STATIC_IMPL size_t aws_ctz_i64(int64_t n) {
 }
 
 AWS_STATIC_IMPL size_t aws_ctz_size(size_t n) {
-#    if SIZE_BITS == 64
+#if SIZE_BITS == 64
     return aws_ctz_u64(n);
-#    else
+#else
     return aws_ctz_u32(n);
-#    endif
-}
-
 #endif
+}
 
 AWS_EXTERN_C_END
 

include/aws/common/math.gcc_arm64_asm.inl

@@ -109,7 +109,7 @@ AWS_STATIC_IMPL int aws_add_u64_checked(uint64_t a, uint64_t b, uint64_t *r) {
     uint64_t res, flag;
     __asm__("adds %x[res], %x[arga], %x[argb]\n"
             "csinv %x[flag], xzr, xzr, cc\n"
-            : /* inout: res is the result of addition; flag is -1 if carry happened */ 
+            : /* inout: res is the result of addition; flag is -1 if carry happened */
 	      [res]"=&r"(res), [flag] "=r"(flag)
             : /* in: a and b */ [arga] "r"(a), [argb] "r"(b)
             : /* clobbers: cc (cmp clobbers condition codes) */ "cc");

include/aws/common/math.h

@@ -28,63 +28,49 @@ AWS_PUSH_SANE_WARNING_LEVEL
 
 AWS_EXTERN_C_BEGIN
 
-#if defined(AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS) && (defined(__clang__) || !defined(__cplusplus)) ||                 \
-    (defined(__x86_64__) || defined(__aarch64__)) && defined(AWS_HAVE_GCC_INLINE_ASM) ||                               \
-    defined(AWS_HAVE_MSVC_INTRINSICS_X64) || defined(CBMC) || !defined(AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS)
-/* In all these cases, we can use fast static inline versions of this code */
-#    define AWS_COMMON_MATH_API AWS_STATIC_IMPL
-#else
-/*
- * We got here because we are building in C++ mode but we only support overflow extensions
- * in C mode. Because the fallback is _slow_ (involving a division), we'd prefer to make a
- * non-inline call to the fast C intrinsics.
- */
-#    define AWS_COMMON_MATH_API AWS_COMMON_API
-#endif
-
 /**
  * Multiplies a * b. If the result overflows, returns 2^64 - 1.
  */
-AWS_COMMON_MATH_API uint64_t aws_mul_u64_saturating(uint64_t a, uint64_t b);
+AWS_STATIC_IMPL uint64_t aws_mul_u64_saturating(uint64_t a, uint64_t b);
 
 /**
  * If a * b overflows, returns AWS_OP_ERR; otherwise multiplies
  * a * b, returns the result in *r, and returns AWS_OP_SUCCESS.
  */
-AWS_COMMON_MATH_API int aws_mul_u64_checked(uint64_t a, uint64_t b, uint64_t *r);
+AWS_STATIC_IMPL int aws_mul_u64_checked(uint64_t a, uint64_t b, uint64_t *r);
 
 /**
  * Multiplies a * b. If the result overflows, returns 2^32 - 1.
  */
-AWS_COMMON_MATH_API uint32_t aws_mul_u32_saturating(uint32_t a, uint32_t b);
+AWS_STATIC_IMPL uint32_t aws_mul_u32_saturating(uint32_t a, uint32_t b);
 
 /**
  * If a * b overflows, returns AWS_OP_ERR; otherwise multiplies
  * a * b, returns the result in *r, and returns AWS_OP_SUCCESS.
  */
-AWS_COMMON_MATH_API int aws_mul_u32_checked(uint32_t a, uint32_t b, uint32_t *r);
+AWS_STATIC_IMPL int aws_mul_u32_checked(uint32_t a, uint32_t b, uint32_t *r);
 
 /**
  * Adds a + b.  If the result overflows returns 2^64 - 1.
  */
-AWS_COMMON_MATH_API uint64_t aws_add_u64_saturating(uint64_t a, uint64_t b);
+AWS_STATIC_IMPL uint64_t aws_add_u64_saturating(uint64_t a, uint64_t b);
 
 /**
  * If a + b overflows, returns AWS_OP_ERR; otherwise adds
  * a + b, returns the result in *r, and returns AWS_OP_SUCCESS.
  */
-AWS_COMMON_MATH_API int aws_add_u64_checked(uint64_t a, uint64_t b, uint64_t *r);
+AWS_STATIC_IMPL int aws_add_u64_checked(uint64_t a, uint64_t b, uint64_t *r);
 
 /**
  * Adds a + b. If the result overflows returns 2^32 - 1.
  */
-AWS_COMMON_MATH_API uint32_t aws_add_u32_saturating(uint32_t a, uint32_t b);
+AWS_STATIC_IMPL uint32_t aws_add_u32_saturating(uint32_t a, uint32_t b);
 
 /**
  * If a + b overflows, returns AWS_OP_ERR; otherwise adds
  * a + b, returns the result in *r, and returns AWS_OP_SUCCESS.
  */
-AWS_COMMON_MATH_API int aws_add_u32_checked(uint32_t a, uint32_t b, uint32_t *r);
+AWS_STATIC_IMPL int aws_add_u32_checked(uint32_t a, uint32_t b, uint32_t *r);
 
 /**
  * Subtracts a - b. If the result overflows returns 0.

include/aws/common/math.inl

@@ -13,37 +13,36 @@
 #include <limits.h>
 #include <stdlib.h>
 
-#if defined(AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS) && (defined(__clang__) || !defined(__cplusplus))
-/*
- * GCC and clang have these super convenient overflow checking builtins...
- * but (in the case of GCC) they're only available when building C source.
- * We'll fall back to one of the other inlinable variants (or a non-inlined version)
- * if we are building this header on G++.
- */
+#ifndef __has_builtin
+#    define __has_builtin(x) 0
+#endif
+
+/* CBMC is its own thing */
+#if defined(CBMC)
+#    include <aws/common/math.cbmc.inl>
+
+/* Prefer GCC-style overflow builtins */
+#elif defined(AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS) || __has_builtin(__builtin_add_overflow)
+#    include <aws/common/math.gcc_builtin.inl>
 #    include <aws/common/math.gcc_overflow.inl>
+
+/* Fall back on GCC-style assembly, and ancient builtins available in all versions of GCC and Clang we support */
 #elif defined(__x86_64__) && defined(AWS_HAVE_GCC_INLINE_ASM)
+#    include <aws/common/math.gcc_builtin.inl>
 #    include <aws/common/math.gcc_x64_asm.inl>
+
+/* Fall back on GCC-style assembly, and ancient builtins available in all versions of GCC and Clang we support */
 #elif defined(__aarch64__) && defined(AWS_HAVE_GCC_INLINE_ASM)
 #    include <aws/common/math.gcc_arm64_asm.inl>
+#    include <aws/common/math.gcc_builtin.inl>
+
+/* On MSVC, use intrinsics */
 #elif defined(AWS_HAVE_MSVC_INTRINSICS_X64)
-#    include <aws/common/math.msvc.inl>
-#elif defined(CBMC)
-#    include <aws/common/math.cbmc.inl>
-#else
-#    ifndef AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS
-/* Fall back to the pure-C implementations */
-#        include <aws/common/math.fallback.inl>
-#    else
-/*
- * We got here because we are building in C++ mode but we only support overflow extensions
- * in C mode. Because the fallback is _slow_ (involving a division), we'd prefer to make a
- * non-inline call to the fast C intrinsics.
- */
-#    endif /*  AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS */
-#endif     /*  defined(AWS_HAVE_GCC_OVERFLOW_MATH_EXTENSIONS) && (defined(__clang__) || !defined(__cplusplus)) */
+#    include <aws/common/math.msvc_x64.inl>
 
-#if defined(__clang__) || defined(__GNUC__)
-#    include <aws/common/math.gcc_builtin.inl>
+/* Fall back to pure C implementation */
+#else
+#    include <aws/common/math.fallback.inl>
 #endif
 
 AWS_EXTERN_C_BEGIN