Solve all MSVC compiler warnings

SConstruct

@@ -2077,6 +2077,9 @@ def MakeGTestEnv(env):
     gtest_env.FilterOut(CCFLAGS=['-pedantic', '-Wundef'])
   gtest_env.FilterOut(CXXFLAGS=['-fno-rtti', '-Weffc++'])
 
+  if gtest_env.Bit('windows') and not gtest_env.Bit('mingw'):
+    gtest_env.Append(CPPDEFINES=['_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING'])
+
   # gtest is incompatible with static linking due to obscure libstdc++
   # linking interactions.
   # See http://code.google.com/p/nativeclient/issues/detail?id=1987

src/shared/platform/win/nacl_host_desc_mmap_win_test.c

@@ -417,7 +417,7 @@ int main(int ac, char **av) {
   char const *test_dir_name = "/tmp/nacl_host_desc_mmap_win_test";
   struct NaClHostDesc hd;
   int test_passed;
-  size_t error_count;
+  int error_count;
   size_t ix;
   int opt;
   int num_runs = 1;

src/third_party/gtest/build.scons

@@ -5,28 +5,15 @@
 
 Import('env')
 
-# TODO: this extra include is necessary because of
-#       gtest/gtest.h
-#       The problem is that gtest.h includes other files
-#       expecting the include path to be set
-#       Sadly, we also have to set this path for every unittest
-env.Append(CPPPATH=
-           ['${MAIN_DIR}/src/third_party/gtest/gtest/include'])
-
+env = env.MakeGTestEnv()
 
 # NOTE: src/gtest-all.cc *includes* a bunch of other .cc files
 env.Append(
     CPPPATH=['${MAIN_DIR}/src/third_party/gtest/gtest'])
 
-
 if env.Bit('linux') or env.Bit('mac'):
-  # because of: gtest-typed-test.h:236:46: error:
-  # anonymous variadic macros were introduced in C99
-  #
   # testing/gtest/src/gtest-all.cc skips an enum value
-  #
-  # gtest does not compile successfully with "-Wundef"
-  env.FilterOut(CCFLAGS=['-pedantic', '-Wswitch-enum', '-Wundef'])
+  env.FilterOut(CCFLAGS=['-Wswitch-enum'])
 
 if env.Bit('clang'):
   # testing/gtest/src/gtest-internal-inl.h has an unused struct field.
@@ -41,6 +28,8 @@ if env.Bit('linux') or env.Bit('clang') or env.Bit('mac'):
   # See gtest-port.h GTEST_DEFINE_STATIC_MUTEX_ define for more info
   env.Append(CCFLAGS=['-Wno-missing-field-initializers'])
 
+env.FilterOut(LIBS=['gtest'])
+
 env.ComponentLibrary(
     'gtest',
     [env.ComponentObject('gtest-all.o',

src/trusted/service_runtime/dyn_array_test.c

@@ -97,88 +97,88 @@ int ReadWriteTest(void) {
 int FfsTest(void) {
   static struct {
     size_t  pos;
-    void    *val;
+    uintptr_t val;
     size_t  expected;
   } test_data[] = {
-    { 1, (void *) 0xdeadbeef, 0 },
-    { 3, (void *) 0xdeadbeef, 0 },
-    { 0, (void *) 0xdeadbeef, 2 },
-    { 2, (void *) 0xdeadbeef, 4 },
-    { 1, (void *) 0, 1 },
-    { 1, (void *) 0xdeadbeef, 4 },
-    { 4, (void *) 0xdeadbeef, 5 },
-    { 5, (void *) 0xdeadbeef, 6 },
-    { 6, (void *) 0xdeadbeef, 7 },
-    { 8, (void *) 0xdeadbeef, 7 },
-    { 7, (void *) 0xdeadbeef, 9 },
-    { 9, (void *) 0xdeadbeef, 10 },
-    { 10, (void *) 0xdeadbeef, 11 },
-    { 11, (void *) 0xdeadbeef, 12 },
-    { 12, (void *) 0xdeadbeef, 13 },
-    { 13, (void *) 0xdeadbeef, 14 },
-    { 14, (void *) 0xdeadbeef, 15 },
-    { 15, (void *) 0xdeadbeef, 16 },
-    { 16, (void *) 0xdeadbeef, 17 },
-    { 17, (void *) 0xdeadbeef, 18 },
-    { 18, (void *) 0xdeadbeef, 19 },
-    { 19, (void *) 0xdeadbeef, 20 },
-    { 20, (void *) 0xdeadbeef, 21 },
-    { 21, (void *) 0xdeadbeef, 22 },
-    { 22, (void *) 0xdeadbeef, 23 },
-    { 23, (void *) 0xdeadbeef, 24 },
-    { 24, (void *) 0xdeadbeef, 25 },
-    { 25, (void *) 0xdeadbeef, 26 },
-    { 26, (void *) 0xdeadbeef, 27 },
-    { 27, (void *) 0xdeadbeef, 28 },
-    { 28, (void *) 0xdeadbeef, 29 },
-    { 29, (void *) 0xdeadbeef, 30 },
-    { 30, (void *) 0xdeadbeef, 31 },
-    { 32, (void *) 0xdeadbeef, 31 },
-    { 32, (void *) 0, 31 },
-    { 31, (void *) 0xdeadbeef, 32 },
-    { 32, (void *) 0xdeadbeef, 33 },
-    { 31, (void *) 0, 31 },
-    { 31, (void *) 0xdeadbeef, 33 },
-    { 34, (void *) 0xdeadbeef, 33 },
-    { 35, (void *) 0xdeadbeef, 33 },
-    { 36, (void *) 0xdeadbeef, 33 },
-    { 37, (void *) 0xdeadbeef, 33 },
-    { 38, (void *) 0xdeadbeef, 33 },
-    { 39, (void *) 0xdeadbeef, 33 },
-    { 40, (void *) 0xdeadbeef, 33 },
-    { 41, (void *) 0xdeadbeef, 33 },
-    { 42, (void *) 0xdeadbeef, 33 },
-    { 43, (void *) 0xdeadbeef, 33 },
-    { 44, (void *) 0xdeadbeef, 33 },
-    { 45, (void *) 0xdeadbeef, 33 },
-    { 46, (void *) 0xdeadbeef, 33 },
-    { 47, (void *) 0xdeadbeef, 33 },
-    { 48, (void *) 0xdeadbeef, 33 },
-    { 49, (void *) 0xdeadbeef, 33 },
-    { 50, (void *) 0xdeadbeef, 33 },
-    { 51, (void *) 0xdeadbeef, 33 },
-    { 52, (void *) 0xdeadbeef, 33 },
-    { 53, (void *) 0xdeadbeef, 33 },
-    { 54, (void *) 0xdeadbeef, 33 },
-    { 55, (void *) 0xdeadbeef, 33 },
-    { 56, (void *) 0xdeadbeef, 33 },
-    { 57, (void *) 0xdeadbeef, 33 },
-    { 58, (void *) 0xdeadbeef, 33 },
-    { 59, (void *) 0xdeadbeef, 33 },
-    { 60, (void *) 0xdeadbeef, 33 },
-    { 61, (void *) 0xdeadbeef, 33 },
-    { 62, (void *) 0xdeadbeef, 33 },
-    { 63, (void *) 0xdeadbeef, 33 },
-    { 64, (void *) 0xdeadbeef, 33 },
-    { 65, (void *) 0xdeadbeef, 33 },
-    { 66, (void *) 0xdeadbeef, 33 },
-    { 33, (void *) 0xdeadbeef, 67 },
-    { 31, (void *) 0, 31 },
-    { 32, (void *) 0, 31 },
-    { 63, (void *) 0, 31 },
-    { 31, (void *) 0xdeadbeef, 32 },
-    { 32, (void *) 0xdeadbeef, 63 },
-    { 63, (void *) 0xdeadbeef, 67 },
+    { 1, 0xdeadbeef, 0 },
+    { 3, 0xdeadbeef, 0 },
+    { 0, 0xdeadbeef, 2 },
+    { 2, 0xdeadbeef, 4 },
+    { 1, 0, 1 },
+    { 1, 0xdeadbeef, 4 },
+    { 4, 0xdeadbeef, 5 },
+    { 5, 0xdeadbeef, 6 },
+    { 6, 0xdeadbeef, 7 },
+    { 8, 0xdeadbeef, 7 },
+    { 7, 0xdeadbeef, 9 },
+    { 9, 0xdeadbeef, 10 },
+    { 10, 0xdeadbeef, 11 },
+    { 11, 0xdeadbeef, 12 },
+    { 12, 0xdeadbeef, 13 },
+    { 13, 0xdeadbeef, 14 },
+    { 14, 0xdeadbeef, 15 },
+    { 15, 0xdeadbeef, 16 },
+    { 16, 0xdeadbeef, 17 },
+    { 17, 0xdeadbeef, 18 },
+    { 18, 0xdeadbeef, 19 },
+    { 19, 0xdeadbeef, 20 },
+    { 20, 0xdeadbeef, 21 },
+    { 21, 0xdeadbeef, 22 },
+    { 22, 0xdeadbeef, 23 },
+    { 23, 0xdeadbeef, 24 },
+    { 24, 0xdeadbeef, 25 },
+    { 25, 0xdeadbeef, 26 },
+    { 26, 0xdeadbeef, 27 },
+    { 27, 0xdeadbeef, 28 },
+    { 28, 0xdeadbeef, 29 },
+    { 29, 0xdeadbeef, 30 },
+    { 30, 0xdeadbeef, 31 },
+    { 32, 0xdeadbeef, 31 },
+    { 32, 0, 31 },
+    { 31, 0xdeadbeef, 32 },
+    { 32, 0xdeadbeef, 33 },
+    { 31, 0, 31 },
+    { 31, 0xdeadbeef, 33 },
+    { 34, 0xdeadbeef, 33 },
+    { 35, 0xdeadbeef, 33 },
+    { 36, 0xdeadbeef, 33 },
+    { 37, 0xdeadbeef, 33 },
+    { 38, 0xdeadbeef, 33 },
+    { 39, 0xdeadbeef, 33 },
+    { 40, 0xdeadbeef, 33 },
+    { 41, 0xdeadbeef, 33 },
+    { 42, 0xdeadbeef, 33 },
+    { 43, 0xdeadbeef, 33 },
+    { 44, 0xdeadbeef, 33 },
+    { 45, 0xdeadbeef, 33 },
+    { 46, 0xdeadbeef, 33 },
+    { 47, 0xdeadbeef, 33 },
+    { 48, 0xdeadbeef, 33 },
+    { 49, 0xdeadbeef, 33 },
+    { 50, 0xdeadbeef, 33 },
+    { 51, 0xdeadbeef, 33 },
+    { 52, 0xdeadbeef, 33 },
+    { 53, 0xdeadbeef, 33 },
+    { 54, 0xdeadbeef, 33 },
+    { 55, 0xdeadbeef, 33 },
+    { 56, 0xdeadbeef, 33 },
+    { 57, 0xdeadbeef, 33 },
+    { 58, 0xdeadbeef, 33 },
+    { 59, 0xdeadbeef, 33 },
+    { 60, 0xdeadbeef, 33 },
+    { 61, 0xdeadbeef, 33 },
+    { 62, 0xdeadbeef, 33 },
+    { 63, 0xdeadbeef, 33 },
+    { 64, 0xdeadbeef, 33 },
+    { 65, 0xdeadbeef, 33 },
+    { 66, 0xdeadbeef, 33 },
+    { 33, 0xdeadbeef, 67 },
+    { 31, 0, 31 },
+    { 32, 0, 31 },
+    { 63, 0, 31 },
+    { 31, 0xdeadbeef, 32 },
+    { 32, 0xdeadbeef, 63 },
+    { 63, 0xdeadbeef, 67 },
   };
   struct DynArray da;
   size_t          ix;
@@ -193,11 +193,11 @@ int FfsTest(void) {
   }
 
   for (ix = 0; ix < NACL_ARRAY_SIZE(test_data); ++ix) {
-    if (!DynArraySet(&da, test_data[ix].pos, test_data[ix].val)) {
+    if (!DynArraySet(&da, test_data[ix].pos, (void *) test_data[ix].val)) {
       fprintf(stderr,
               "dyn_array_test: setting at position %"NACL_PRIuS" to 0x%08"
               NACL_PRIxPTR", test_data entry %"NACL_PRIuS" failed\n",
-              test_data[ix].pos, (uintptr_t) test_data[ix].val, ix);
+              test_data[ix].pos, test_data[ix].val, ix);
       ++nerrors;
     }
     if (DynArrayFirstAvail(&da) != test_data[ix].expected) {

src/trusted/validator_ragel/build.scons

@@ -18,6 +18,8 @@ Import('env')
 # so we leave VALIDATOR_EXPORT undefined in gyp build.
 env = env.Clone()
 env.Append(CCFLAGS=['-DVALIDATOR_EXPORT=DLLEXPORT'])
+if env.Bit('windows') and not env.Bit('mingw'):
+  env.Append(CCFLAGS=['/wd5287'])
 
 # Dir to place c files generated by 'dfagen' target (it's under source control).
 gen_dir = '$MAIN_DIR/src/trusted/validator_ragel/gen'

tests/trusted_crash/crash_in_syscall/test_host.c

@@ -73,7 +73,7 @@ static void PrintSymbolForAddress(DWORD64 addr) {
   has_symbol = SymFromAddr(GetCurrentProcess(),
                            addr, &sym_displacement, symbol);
   if (has_symbol) {
-    fprintf(stderr, "%s + 0x%x\n", symbol->Name, sym_displacement);
+    fprintf(stderr, "%s + 0x%" NACL_PRIx64 "\n", symbol->Name, sym_displacement);
   } else {
     fprintf(stderr, "<no symbol>\n");
   }
@@ -127,7 +127,7 @@ static void Backtrace(CONTEXT *initial_context) {
     }
     fprintf(stderr, "#%i: ip=%p stack=%llx frame=%llx ",
             frame_number,
-            frame.AddrPC.Offset,
+            (void *) frame.AddrPC.Offset,
             frame.AddrStack.Offset,
             frame.AddrFrame.Offset);
     PrintSymbolForAddress(frame.AddrPC.Offset);
@@ -163,7 +163,7 @@ static void Backtrace(CONTEXT *initial_context) {
       /* frame_size must be signed for the check to be useful. */
       long long frame_size = frame.AddrFrame.Offset - frame.AddrStack.Offset;
       if (frame_number > 0 && frame_size < 32) {
-        fprintf(stderr, "Error: frame_size=%i, which is too small\n",
+        fprintf(stderr, "Error: frame_size=%lli, which is too small\n",
                 frame_size);
         failed = 1;
       }