math-emu/op-2.h: Use statement expressions to prevent negative constant shift

This modification is quoted from glibc 'commit <
sysdeps/unix/sysv/linux/sparc/sparc64/dl-procinfo.c: Moved to>
(fe0b1e854ad32a69b260)'

Signed-off-by: Vincent Chen <vincentc@andestech.com>
Acked-by: Greentime Hu <greentime@andestech.com>
Signed-off-by: Greentime Hu <greentime@andestech.com>

diff --git a/include/math-emu/op-2.h b/include/math-emu/op-2.h
index 4f26ecc1411b836bcf30dd26320e2304395d7044..13a374f51a225bf77f9b19189a1145001fae3c5a 100644 (file)
--- a/include/math-emu/op-2.h
+++ b/include/math-emu/op-2.h
@@ -31,61 +31,56 @@
 #define _FP_FRAC_HIGH_2(X)     (X##_f1)
 #define _FP_FRAC_LOW_2(X)      (X##_f0)
 #define _FP_FRAC_WORD_2(X,w)   (X##_f##w)
+#define _FP_FRAC_SLL_2(X, N) (                                                \
+       (void) (((N) < _FP_W_TYPE_SIZE)                                        \
+         ? ({                                                                 \
+               if (__builtin_constant_p(N) && (N) == 1) {                     \
+                       X##_f1 = X##_f1 + X##_f1 +                             \
+                               (((_FP_WS_TYPE) (X##_f0)) < 0);                \
+                       X##_f0 += X##_f0;                                      \
+               } else {                                                       \
+                       X##_f1 = X##_f1 << (N) | X##_f0 >>                     \
+                                               (_FP_W_TYPE_SIZE - (N));       \
+                       X##_f0 <<= (N);                                        \
+               }                                                              \
+               0;                                                             \
+           })                                                                 \
+         : ({                                                                 \
+             X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE);                      \
+             X##_f0 = 0;                                                      \
+         })))
+
+
+#define _FP_FRAC_SRL_2(X, N) (                                                \
+       (void) (((N) < _FP_W_TYPE_SIZE)                                        \
+         ? ({                                                                 \
+             X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N));      \
+             X##_f1 >>= (N);                                                  \
+           })                                                                 \
+         : ({                                                                 \
+             X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE);                      \
+             X##_f1 = 0;                                                      \
+           })))
 
-#define _FP_FRAC_SLL_2(X,N)                                            \
-  do {                                                                 \
-    if ((N) < _FP_W_TYPE_SIZE)                                         \
-      {                                                                        \
-       if (__builtin_constant_p(N) && (N) == 1)                        \
-         {                                                             \
-           X##_f1 = X##_f1 + X##_f1 + (((_FP_WS_TYPE)(X##_f0)) < 0);   \
-           X##_f0 += X##_f0;                                           \
-         }                                                             \
-       else                                                            \
-         {                                                             \
-           X##_f1 = X##_f1 << (N) | X##_f0 >> (_FP_W_TYPE_SIZE - (N)); \
-           X##_f0 <<= (N);                                             \
-         }                                                             \
-      }                                                                        \
-    else                                                               \
-      {                                                                        \
-       X##_f1 = X##_f0 << ((N) - _FP_W_TYPE_SIZE);                     \
-       X##_f0 = 0;                                                     \
-      }                                                                        \
-  } while (0)
-
-#define _FP_FRAC_SRL_2(X,N)                                            \
-  do {                                                                 \
-    if ((N) < _FP_W_TYPE_SIZE)                                         \
-      {                                                                        \
-       X##_f0 = X##_f0 >> (N) | X##_f1 << (_FP_W_TYPE_SIZE - (N));     \
-       X##_f1 >>= (N);                                                 \
-      }                                                                        \
-    else                                                               \
-      {                                                                        \
-       X##_f0 = X##_f1 >> ((N) - _FP_W_TYPE_SIZE);                     \
-       X##_f1 = 0;                                                     \
-      }                                                                        \
-  } while (0)
 
 /* Right shift with sticky-lsb.  */
-#define _FP_FRAC_SRS_2(X,N,sz)                                         \
-  do {                                                                 \
-    if ((N) < _FP_W_TYPE_SIZE)                                         \
-      {                                                                        \
-       X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N) |   \
-                 (__builtin_constant_p(N) && (N) == 1                  \
-                  ? X##_f0 & 1                                         \
-                  : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0));        \
-       X##_f1 >>= (N);                                                 \
-      }                                                                        \
-    else                                                               \
-      {                                                                        \
-       X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE) |                   \
-               (((X##_f1 << (2*_FP_W_TYPE_SIZE - (N))) | X##_f0) != 0)); \
-       X##_f1 = 0;                                                     \
-      }                                                                        \
-  } while (0)
+#define _FP_FRAC_SRS_2(X, N, sz) (                                            \
+       (void) (((N) < _FP_W_TYPE_SIZE)                                        \
+         ? ({                                                                 \
+             X##_f0 = (X##_f1 << (_FP_W_TYPE_SIZE - (N)) | X##_f0 >> (N)      \
+                       | (__builtin_constant_p(N) && (N) == 1                 \
+                          ? X##_f0 & 1                                        \
+                          : (X##_f0 << (_FP_W_TYPE_SIZE - (N))) != 0));       \
+               X##_f1 >>= (N);                                                \
+           })                                                                 \
+         : ({                                                                 \
+             X##_f0 = (X##_f1 >> ((N) - _FP_W_TYPE_SIZE)                      \
+                       | ((((N) == _FP_W_TYPE_SIZE                            \
+                            ? 0                                               \
+                            : (X##_f1 << (2*_FP_W_TYPE_SIZE - (N))))          \
+                           | X##_f0) != 0));                                  \
+             X##_f1 = 0;                                                      \
+           })))
 
 #define _FP_FRAC_ADDI_2(X,I)   \
   __FP_FRAC_ADDI_2(X##_f1, X##_f0, I)