Format wasm2c templated code (#1942)

1 files changed, 115 insertions, 90 deletions

diff --git a/wasm2c/examples/fac/fac.c b/wasm2c/examples/fac/fac.c
index 39f20b4a..30f1e9bb 100644
--- a/wasm2c/examples/fac/fac.c
+++ b/wasm2c/examples/fac/fac.c
@@ -13,21 +13,22 @@
 #else
 #define FUNC_PROLOGUE                                            \
   if (++wasm_rt_call_stack_depth > WASM_RT_MAX_CALL_STACK_DEPTH) \
-    TRAP(EXHAUSTION)
+    TRAP(EXHAUSTION);
 
 #define FUNC_EPILOGUE --wasm_rt_call_stack_depth
 #endif
 
 #define UNREACHABLE TRAP(UNREACHABLE)
 
-#define CALL_INDIRECT(table, t, ft, x, ...)          \
-  (LIKELY((x) < table.size && table.data[x].func &&  \
-          table.data[x].func_type == func_types[ft]) \
-       || TRAP(CALL_INDIRECT)                        \
-       , ((t)table.data[x].func)(__VA_ARGS__))
+#define CALL_INDIRECT(table, t, ft, x, ...)             \
+  (LIKELY((x) < table.size && table.data[x].func &&     \
+          table.data[x].func_type == func_types[ft]) || \
+       TRAP(CALL_INDIRECT),                             \
+   ((t)table.data[x].func)(__VA_ARGS__))
 
-#define RANGE_CHECK(mem, offset, len) \
-  if (UNLIKELY(offset + (uint64_t)len > mem->size)) TRAP(OOB)
+#define RANGE_CHECK(mem, offset, len)               \
+  if (UNLIKELY(offset + (uint64_t)len > mem->size)) \
+    TRAP(OOB);
 
 #if WASM_RT_MEMCHECK_SIGNAL_HANDLER
 #define MEMCHECK(mem, a, t)
@@ -36,11 +37,11 @@
 #endif
 
 #if WABT_BIG_ENDIAN
-static inline void load_data(void *dest, const void *src, size_t n) {
+static inline void load_data(void* dest, const void* src, size_t n) {
   size_t i = 0;
-  u8 *dest_chars = dest;
+  u8* dest_chars = dest;
   memcpy(dest, src, n);
-  for (i = 0; i < (n>>1); i++) {
+  for (i = 0; i < (n >> 1); i++) {
     u8 cursor = dest_chars[i];
     dest_chars[i] = dest_chars[n - i - 1];
     dest_chars[n - i - 1] = cursor;
@@ -68,11 +69,12 @@ static inline void load_data(void *dest, const void *src, size_t n) {
                    sizeof(t1));                                         \
   }
 #else
-static inline void load_data(void *dest, const void *src, size_t n) {
+static inline void load_data(void* dest, const void* src, size_t n) {
   memcpy(dest, src, n);
 }
-#define LOAD_DATA(m, o, i, s) do { \
-    RANGE_CHECK((&m), o, s); \
+#define LOAD_DATA(m, o, i, s)      \
+  do {                             \
+    RANGE_CHECK((&m), o, s);       \
     load_data(&(m.data[o]), i, s); \
   } while (0)
 #define DEFINE_LOAD(name, t1, t2, t3)                      \
@@ -129,9 +131,9 @@ static inline int I64_CLZ(unsigned long long v) {
     return 63 - r;
   }
 #else
-  if (_BitScanReverse(&r, (unsigned long) (v >> 32))) {
+  if (_BitScanReverse(&r, (unsigned long)(v >> 32))) {
     return 31 - r;
-  } else if (_BitScanReverse(&r, (unsigned long) v)) {
+  } else if (_BitScanReverse(&r, (unsigned long)v)) {
     return 63 - r;
   }
 #endif
@@ -153,14 +155,14 @@ static inline int I64_CTZ(unsigned long long v) {
   unsigned long r = 0;
 #if defined(_M_AMD64) || defined(_M_ARM)
   _BitScanForward64(&r, v);
-  return (int) r;
+  return (int)r;
 #else
-  if (_BitScanForward(&r, (unsigned int) (v))) {
-    return (int) (r);
+  if (_BitScanForward(&r, (unsigned int)(v))) {
+    return (int)(r);
   }
 
-  _BitScanForward(&r, (unsigned int) (v >> 32));
-  return (int) (r + 32);
+  _BitScanForward(&r, (unsigned int)(v >> 32));
+  return (int)(r + 32);
 #endif
 }
 
@@ -170,15 +172,15 @@ static inline int I32_CTZ(unsigned long v) {
   }
   unsigned long r = 0;
   _BitScanForward(&r, v);
-  return (int) r;
+  return (int)r;
 }
 
-#define POPCOUNT_DEFINE_PORTABLE(f_n, T)                    \
-  static inline u32 f_n(T x) {                              \
-    x = x - ((x >> 1) & (T)~(T)0/3);                        \
-    x = (x & (T)~(T)0/15*3) + ((x >> 2) & (T)~(T)0/15*3);   \
-    x = (x + (x >> 4)) & (T)~(T)0/255*15;                   \
-    return (T)(x * ((T)~(T)0/255)) >> (sizeof(T) - 1) * 8;  \
+#define POPCOUNT_DEFINE_PORTABLE(f_n, T)                            \
+  static inline u32 f_n(T x) {                                      \
+    x = x - ((x >> 1) & (T) ~(T)0 / 3);                             \
+    x = (x & (T) ~(T)0 / 15 * 3) + ((x >> 2) & (T) ~(T)0 / 15 * 3); \
+    x = (x + (x >> 4)) & (T) ~(T)0 / 255 * 15;                      \
+    return (T)(x * ((T) ~(T)0 / 255)) >> (sizeof(T) - 1) * 8;       \
   }
 
 POPCOUNT_DEFINE_PORTABLE(I32_POPCNT, u32)
@@ -197,15 +199,16 @@ POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)
 
 #endif
 
-#define DIV_S(ut, min, x, y)                                 \
-   ((UNLIKELY((y) == 0)) ?                TRAP(DIV_BY_ZERO)  \
-  : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \
-  : (ut)((x) / (y)))
+#define DIV_S(ut, min, x, y)                                      \
+  ((UNLIKELY((y) == 0))                                           \
+       ? TRAP(DIV_BY_ZERO)                                        \
+       : (UNLIKELY((x) == min && (y) == -1)) ? TRAP(INT_OVERFLOW) \
+                                             : (ut)((x) / (y)))
 
-#define REM_S(ut, min, x, y)                                \
-   ((UNLIKELY((y) == 0)) ?                TRAP(DIV_BY_ZERO) \
-  : (UNLIKELY((x) == min && (y) == -1)) ? 0                 \
-  : (ut)((x) % (y)))
+#define REM_S(ut, min, x, y) \
+  ((UNLIKELY((y) == 0))      \
+       ? TRAP(DIV_BY_ZERO)   \
+       : (UNLIKELY((x) == min && (y) == -1)) ? 0 : (ut)((x) % (y)))
 
 #define I32_DIV_S(x, y) DIV_S(u32, INT32_MIN, (s32)x, (s32)y)
 #define I64_DIV_S(x, y) DIV_S(u64, INT64_MIN, (s64)x, (s64)y)
@@ -213,7 +216,7 @@ POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)
 #define I64_REM_S(x, y) REM_S(u64, INT64_MIN, (s64)x, (s64)y)
 
 #define DIVREM_U(op, x, y) \
-  ((UNLIKELY((y) == 0)) ? TRAP(DIV_BY_ZERO) : ((x) op (y)))
+  ((UNLIKELY((y) == 0)) ? TRAP(DIV_BY_ZERO) : ((x)op(y)))
 
 #define DIV_U(x, y) DIVREM_U(/, x, y)
 #define REM_U(x, y) DIVREM_U(%, x, y)
@@ -228,65 +231,87 @@ POPCOUNT_DEFINE_PORTABLE(I64_POPCNT, u64)
 #define I32_ROTR(x, y) ROTR(x, y, 31)
 #define I64_ROTR(x, y) ROTR(x, y, 63)
 
-#define FMIN(x, y)                                          \
-   ((UNLIKELY((x) != (x))) ? NAN                            \
-  : (UNLIKELY((y) != (y))) ? NAN                            \
-  : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? x : y) \
-  : (x < y) ? x : y)
-
-#define FMAX(x, y)                                          \
-   ((UNLIKELY((x) != (x))) ? NAN                            \
-  : (UNLIKELY((y) != (y))) ? NAN                            \
-  : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? y : x) \
-  : (x > y) ? x : y)
-
-#define TRUNC_S(ut, st, ft, min, minop, max, x)                             \
-  ((UNLIKELY((x) != (x)))                        ? TRAP(INVALID_CONVERSION) \
-   : (UNLIKELY(!((x)minop(min) && (x) < (max)))) ? TRAP(INT_OVERFLOW)       \
-                                                 : (ut)(st)(x))
-
-#define I32_TRUNC_S_F32(x) TRUNC_S(u32, s32, f32, (f32)INT32_MIN, >=, 2147483648.f, x)
-#define I64_TRUNC_S_F32(x) TRUNC_S(u64, s64, f32, (f32)INT64_MIN, >=, (f32)INT64_MAX, x)
-#define I32_TRUNC_S_F64(x) TRUNC_S(u32, s32, f64, -2147483649., >, 2147483648., x)
-#define I64_TRUNC_S_F64(x) TRUNC_S(u64, s64, f64, (f64)INT64_MIN, >=, (f64)INT64_MAX, x)
-
-#define TRUNC_U(ut, ft, max, x)                                            \
-  ((UNLIKELY((x) != (x)))                       ? TRAP(INVALID_CONVERSION) \
-   : (UNLIKELY(!((x) > (ft)-1 && (x) < (max)))) ? TRAP(INT_OVERFLOW)       \
-                                                : (ut)(x))
+#define FMIN(x, y)                                                     \
+  ((UNLIKELY((x) != (x)))                                              \
+       ? NAN                                                           \
+       : (UNLIKELY((y) != (y)))                                        \
+             ? NAN                                                     \
+             : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? x : y) \
+                                                : (x < y) ? x : y)
+
+#define FMAX(x, y)                                                     \
+  ((UNLIKELY((x) != (x)))                                              \
+       ? NAN                                                           \
+       : (UNLIKELY((y) != (y)))                                        \
+             ? NAN                                                     \
+             : (UNLIKELY((x) == 0 && (y) == 0)) ? (signbit(x) ? y : x) \
+                                                : (x > y) ? x : y)
+
+#define TRUNC_S(ut, st, ft, min, minop, max, x)                           \
+  ((UNLIKELY((x) != (x)))                                                 \
+       ? TRAP(INVALID_CONVERSION)                                         \
+       : (UNLIKELY(!((x)minop(min) && (x) < (max)))) ? TRAP(INT_OVERFLOW) \
+                                                     : (ut)(st)(x))
+
+#define I32_TRUNC_S_F32(x) \
+  TRUNC_S(u32, s32, f32, (f32)INT32_MIN, >=, 2147483648.f, x)
+#define I64_TRUNC_S_F32(x) \
+  TRUNC_S(u64, s64, f32, (f32)INT64_MIN, >=, (f32)INT64_MAX, x)
+#define I32_TRUNC_S_F64(x) \
+  TRUNC_S(u32, s32, f64, -2147483649., >, 2147483648., x)
+#define I64_TRUNC_S_F64(x) \
+  TRUNC_S(u64, s64, f64, (f64)INT64_MIN, >=, (f64)INT64_MAX, x)
+
+#define TRUNC_U(ut, ft, max, x)                                          \
+  ((UNLIKELY((x) != (x)))                                                \
+       ? TRAP(INVALID_CONVERSION)                                        \
+       : (UNLIKELY(!((x) > (ft)-1 && (x) < (max)))) ? TRAP(INT_OVERFLOW) \
+                                                    : (ut)(x))
 
 #define I32_TRUNC_U_F32(x) TRUNC_U(u32, f32, 4294967296.f, x)
 #define I64_TRUNC_U_F32(x) TRUNC_U(u64, f32, (f32)UINT64_MAX, x)
-#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, 4294967296.,  x)
+#define I32_TRUNC_U_F64(x) TRUNC_U(u32, f64, 4294967296., x)
 #define I64_TRUNC_U_F64(x) TRUNC_U(u64, f64, (f64)UINT64_MAX, x)
 
 #define TRUNC_SAT_S(ut, st, ft, min, smin, minop, max, smax, x) \
-  ((UNLIKELY((x) != (x)))         ? 0                           \
-   : (UNLIKELY(!((x)minop(min)))) ? smin                        \
-   : (UNLIKELY(!((x) < (max))))   ? smax                        \
-                                  : (ut)(st)(x))
-
-#define I32_TRUNC_SAT_S_F32(x) TRUNC_SAT_S(u32, s32, f32, (f32)INT32_MIN, INT32_MIN, >=, 2147483648.f, INT32_MAX, x)
-#define I64_TRUNC_SAT_S_F32(x) TRUNC_SAT_S(u64, s64, f32, (f32)INT64_MIN, INT64_MIN, >=, (f32)INT64_MAX, INT64_MAX, x)
-#define I32_TRUNC_SAT_S_F64(x) TRUNC_SAT_S(u32, s32, f64, -2147483649., INT32_MIN, >, 2147483648., INT32_MAX, x)
-#define I64_TRUNC_SAT_S_F64(x) TRUNC_SAT_S(u64, s64, f64, (f64)INT64_MIN, INT64_MIN, >=, (f64)INT64_MAX, INT64_MAX, x)
-
-#define TRUNC_SAT_U(ut, ft, max, smax, x) \
-  ((UNLIKELY((x) != (x)))        ? 0      \
-   : (UNLIKELY(!((x) > (ft)-1))) ? 0      \
-   : (UNLIKELY(!((x) < (max))))  ? smax   \
-                                 : (ut)(x))
-
-#define I32_TRUNC_SAT_U_F32(x) TRUNC_SAT_U(u32, f32, 4294967296.f, UINT32_MAX, x)
-#define I64_TRUNC_SAT_U_F32(x) TRUNC_SAT_U(u64, f32, (f32)UINT64_MAX, UINT64_MAX, x)
-#define I32_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u32, f64, 4294967296., UINT32_MAX,  x)
-#define I64_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u64, f64, (f64)UINT64_MAX, UINT64_MAX, x)
-
-#define DEFINE_REINTERPRET(name, t1, t2)  \
-  static inline t2 name(t1 x) {           \
-    t2 result;                            \
-    memcpy(&result, &x, sizeof(result));  \
-    return result;                        \
+  ((UNLIKELY((x) != (x)))                                       \
+       ? 0                                                      \
+       : (UNLIKELY(!((x)minop(min))))                           \
+             ? smin                                             \
+             : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(st)(x))
+
+#define I32_TRUNC_SAT_S_F32(x)                                            \
+  TRUNC_SAT_S(u32, s32, f32, (f32)INT32_MIN, INT32_MIN, >=, 2147483648.f, \
+              INT32_MAX, x)
+#define I64_TRUNC_SAT_S_F32(x)                                              \
+  TRUNC_SAT_S(u64, s64, f32, (f32)INT64_MIN, INT64_MIN, >=, (f32)INT64_MAX, \
+              INT64_MAX, x)
+#define I32_TRUNC_SAT_S_F64(x)                                        \
+  TRUNC_SAT_S(u32, s32, f64, -2147483649., INT32_MIN, >, 2147483648., \
+              INT32_MAX, x)
+#define I64_TRUNC_SAT_S_F64(x)                                              \
+  TRUNC_SAT_S(u64, s64, f64, (f64)INT64_MIN, INT64_MIN, >=, (f64)INT64_MAX, \
+              INT64_MAX, x)
+
+#define TRUNC_SAT_U(ut, ft, max, smax, x)               \
+  ((UNLIKELY((x) != (x))) ? 0                           \
+                          : (UNLIKELY(!((x) > (ft)-1))) \
+                                ? 0                     \
+                                : (UNLIKELY(!((x) < (max)))) ? smax : (ut)(x))
+
+#define I32_TRUNC_SAT_U_F32(x) \
+  TRUNC_SAT_U(u32, f32, 4294967296.f, UINT32_MAX, x)
+#define I64_TRUNC_SAT_U_F32(x) \
+  TRUNC_SAT_U(u64, f32, (f32)UINT64_MAX, UINT64_MAX, x)
+#define I32_TRUNC_SAT_U_F64(x) TRUNC_SAT_U(u32, f64, 4294967296., UINT32_MAX, x)
+#define I64_TRUNC_SAT_U_F64(x) \
+  TRUNC_SAT_U(u64, f64, (f64)UINT64_MAX, UINT64_MAX, x)
+
+#define DEFINE_REINTERPRET(name, t1, t2) \
+  static inline t2 name(t1 x) {          \
+    t2 result;                           \
+    memcpy(&result, &x, sizeof(result)); \
+    return result;                       \
   }
 
 DEFINE_REINTERPRET(f32_reinterpret_i32, u32, f32)