Warning disable for mod-by-zero and union 'uninitialized' use

[mcgov]

Summary

MSVC is throwing some warnings when compiling these sections (during a compile of asan_rt and llvm-symbolizer).

The uninitialized use warning is just an artifact of using a union, so I think we can safely ignore it. The mod-by-zero warning I'm less sure about, but unless someone with more knowledge about the code feels like this needs a fix I'd like to just disable the warning so we can build with warn-as-error and get past these.

[rnk]

lgtm

compiler-rt/lib/builtins/fixxfdi.c

50–54

I would put the warning pop inside the !_ARCH_PPC block. It would only be an issue in an _MSC_VER + PPC build.

compiler-rt/lib/builtins/udivmoddi4.c

21–22

I think the % by 0 will happen only in the cases where the user actually does division by zero, and that's actually the desired behavior.

[mcgov]

update to add !defined(clang)

[mcgov]

compiler-rt/lib/builtins/udivmoddi4.c

21–22

Ok that makes sense. I appreciate the look, thank you!

[mstorsjo]

compiler-rt/lib/builtins/fixunsxfdi.c

48

This broke compilation for me with errors like this:

lib/builtins/fixunsxfdi.c:13:2: error: unterminated conditional directive
#if !_ARCH_PPC

Also, the commit message speaks about sanitizers, even though all the changes are for builtins.

I fixed the compile error in SVN r368480.

[mcgov]

compiler-rt/lib/builtins/fixunsxfdi.c

48

Thank you for the fix!

[thakis]

This broke -Werror bots due to -Wnewline-eof. I added missing newlines in r368613 to fix this. Please configure your editor to save files with (exactly) one newline for next time :)

See also the "New newline at end of file" notes in phab.

compiler-rt/lib/builtins/emutls.c

 // We can't wait until the final two rounds, because jemalloc needs two rounds
 // after the final malloc/free call to free its thread-specific data (see
 // https://reviews.llvm.org/D46978#1107507).
 #define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 1
 #else
 #define EMUTLS_SKIP_DESTRUCTOR_ROUNDS 0
 #endif
 
+#ifdef _MSC_VER && !defined(__clang__)
+// MSVC raises a warning about a nonstandard extension being used for the 0
+// sized element in this array. Disable this for warn-as-error builds.
+#pragma warning(push)
+#pragma warning(disable : 4206)
+#endif
+
 typedef struct emutls_address_array {
   uintptr_t skip_destructor_rounds;
   uintptr_t size; // number of elements in the 'data' array
   void *data[];
 } emutls_address_array;
 
+#ifdef _MSC_VER && !defined(__clang__)
+#pragma warning(pop)
+#endif
+
 static void emutls_shutdown(emutls_address_array *array);
 
 #ifndef _WIN32
 
 #include <pthread.h>
 
 static pthread_mutex_t emutls_mutex = PTHREAD_MUTEX_INITIALIZER;
 static pthread_key_t emutls_pthread_key;

compiler-rt/lib/builtins/fixunsxfdi.c

 // Assumption: long double is an intel 80 bit floating point type padded with 6
 // bytes du_int is a 64 bit integral type value in long double is representable
 // in du_int or is negative (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
 // eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
+#ifdef _MSC_VER && !defined(__clang__)
+// MSVC throws a warning about 'unitialized variable use' here,
+// disable it for builds that warn-as-error
+#pragma warning(push)
+#pragma warning(disable : 4700)
+#endif
+
 COMPILER_RT_ABI du_int __fixunsxfdi(long double a) {
   long_double_bits fb;
   fb.f = a;
   int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
   if (e < 0 || (fb.u.high.s.low & 0x00008000))
     return 0;
   if ((unsigned)e > sizeof(du_int) * CHAR_BIT)
     return ~(du_int)0;
   return fb.u.low.all >> (63 - e);
 }
 
+#ifdef _MSC_VER && !defined(__clang__)
+#pragma warning(pop)
 #endif

compiler-rt/lib/builtins/fixunsxfsi.c

 // Assumption: long double is an intel 80 bit floating point type padded with 6
 // bytes su_int is a 32 bit integral type value in long double is representable
 // in su_int or is negative
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
 // eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
+#ifdef _MSC_VER && !defined(__clang__)
+// MSVC throws a warning about 'unitialized variable use' here,
+// disable it for builds that warn-as-error
+#pragma warning(push)
+#pragma warning(disable : 4700)
+#endif
+
 COMPILER_RT_ABI su_int __fixunsxfsi(long double a) {
   long_double_bits fb;
   fb.f = a;
   int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
   if (e < 0 || (fb.u.high.s.low & 0x00008000))
     return 0;
   if ((unsigned)e > sizeof(su_int) * CHAR_BIT)
     return ~(su_int)0;
   return fb.u.low.s.high >> (31 - e);
 }
 
+#ifdef _MSC_VER && !defined(__clang__)
+#pragma warning(pop)
+#endif
+
 #endif // !_ARCH_PPC

compiler-rt/lib/builtins/fixxfdi.c

 // Assumption: long double is an intel 80 bit floating point type padded with 6
 // bytes di_int is a 64 bit integral type value in long double is representable
 // in di_int (no range checking performed)
 
 // gggg gggg gggg gggg gggg gggg gggg gggg | gggg gggg gggg gggg seee eeee eeee
 // eeee | 1mmm mmmm mmmm mmmm mmmm mmmm mmmm mmmm | mmmm mmmm mmmm mmmm mmmm
 // mmmm mmmm mmmm
 
+#ifdef _MSC_VER && !defined(__clang__)
+// MSVC throws a warning about 'unitialized variable use' here,
+// disable it for builds that warn-as-error
+#pragma warning(push)
+#pragma warning(disable : 4700)
+#endif
+
 COMPILER_RT_ABI di_int __fixxfdi(long double a) {
   const di_int di_max = (di_int)((~(du_int)0) / 2);
   const di_int di_min = -di_max - 1;
   long_double_bits fb;
   fb.f = a;
   int e = (fb.u.high.s.low & 0x00007FFF) - 16383;
   if (e < 0)
     return 0;
   if ((unsigned)e >= sizeof(di_int) * CHAR_BIT)
     return a > 0 ? di_max : di_min;
   di_int s = -(si_int)((fb.u.high.s.low & 0x00008000) >> 15);
   di_int r = fb.u.low.all;
   r = (du_int)r >> (63 - e);
   return (r ^ s) - s;
 }
 
 #endif // !_ARCH_PPC
+
+#ifdef _MSC_VER && !defined(__clang__)
+#pragma warning(pop)
+#endif
 No newline at end of file

compiler-rt/lib/builtins/udivmoddi4.c

 
 #include "int_lib.h"
 
 // Effects: if rem != 0, *rem = a % b
 // Returns: a / b
 
 // Translated from Figure 3-40 of The PowerPC Compiler Writer's Guide
 
+#ifdef _MSC_VER && !defined(__clang__)
+// MSVC throws a warning about mod 0 here, disable it for builds that
+// warn-as-error
+#pragma warning(push)
+#pragma warning(disable : 4724)
+#endif
+
 COMPILER_RT_ABI du_int __udivmoddi4(du_int a, du_int b, du_int *rem) {
   const unsigned n_uword_bits = sizeof(su_int) * CHAR_BIT;
   const unsigned n_udword_bits = sizeof(du_int) * CHAR_BIT;
   udwords n;
   n.all = a;
   udwords d;
   d.all = b;
   udwords q;
for (; sr > 0; --sr) {
     carry = s & 1;
     r.all -= d.all & s;
   }
   q.all = (q.all << 1) | carry;
   if (rem)
     *rem = r.all;
   return q.all;
 }
+
+#ifdef _MSC_VER && !defined(__clang__)
+#pragma warning(pop)
+#endif
 No newline at end of file