Fixing gcc warning 'variable tracking size limit exceeded'

test/cctest/test-asm-validator.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // TODO(jochen): Remove this after the setting is turned on globally.
 #define V8_IMMINENT_DEPRECATION_WARNINGS
 
 #include "src/v8.h"
 
 #include "src/ast/ast.h"
@@ skipping 382 matching lines @@
         CHECK_VAR(stdlib, Bounds::Unbounded());   \
         CHECK_EXPR(Literal, Bounds::Unbounded()); \
       }                                           \
       CHECK_VAR(buffer, Bounds::Unbounded());     \
     }                                             \
   }
 
 
 namespace {
 
-void CheckStdlibShortcuts(Zone* zone, ZoneVector<ExpressionTypeEntry>& types,
-                          size_t& index, int& depth, TypeCache& cache) {
+void CheckStdlibShortcuts1(Zone* zone, ZoneVector<ExpressionTypeEntry>& types,
+                           size_t& index, int& depth, TypeCache& cache) {
   // var exp = stdlib.*; (D * 12)
   CHECK_VAR_SHORTCUT(Infinity, Bounds(cache.kAsmDouble));
   CHECK_VAR_SHORTCUT(NaN, Bounds(cache.kAsmDouble));
   // var x = stdlib.Math.x;  D2D
   CHECK_VAR_MATH_SHORTCUT(acos, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(asin, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(atan, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(cos, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(sin, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(tan, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(exp, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(log, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(ceil, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(floor, FUNC_D2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(sqrt, FUNC_D2D_TYPE);
   // var exp = stdlib.Math.*; (DD2D * 12)
   CHECK_VAR_MATH_SHORTCUT(min, FUNC_DD2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(max, FUNC_DD2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(atan2, FUNC_DD2D_TYPE);
   CHECK_VAR_MATH_SHORTCUT(pow, FUNC_DD2D_TYPE);
   // Special ones.
   CHECK_VAR_MATH_SHORTCUT(abs, FUNC_N2N_TYPE);
   CHECK_VAR_MATH_SHORTCUT(imul, FUNC_II2I_TYPE);
   CHECK_VAR_MATH_SHORTCUT(fround, FUNC_N2F_TYPE);
+}
+
+
+void CheckStdlibShortcuts2(Zone* zone, ZoneVector<ExpressionTypeEntry>& types,
+                           size_t& index, int& depth, TypeCache& cache) {
   // var exp = stdlib.Math.*; (D * 12)
   CHECK_VAR_MATH_SHORTCUT(E, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(LN10, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(LN2, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(LOG2E, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(LOG10E, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(PI, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(SQRT1_2, Bounds(cache.kAsmDouble));
   CHECK_VAR_MATH_SHORTCUT(SQRT2, Bounds(cache.kAsmDouble));
   // var values = new stdlib.*Array(buffer);
@@ skipping 17 matching lines @@
   v8::V8::Initialize();                                \
   HandleAndZoneScope handles;                          \
   Zone* zone = handles.main_zone();                    \
   ZoneVector<ExpressionTypeEntry> types(zone);         \
   CHECK_EQ("", Validate(zone, test_function, &types)); \
   TypeCache cache;                                     \
                                                        \
   CHECK_TYPES_BEGIN {                                  \
     /* Module. */                                      \
     CHECK_EXPR(FunctionLiteral, Bounds::Unbounded()) {
-#define CHECK_FUNC_TYPES_END_1()                   \
-  /* "use asm"; */                                 \
-  CHECK_EXPR(Literal, Bounds(Type::String(zone))); \
-  /* stdlib shortcuts. */                          \
-  CheckStdlibShortcuts(zone, types, index, depth, cache);
+#define CHECK_FUNC_TYPES_END_1()                           \
+  /* "use asm"; */                                         \
+  CHECK_EXPR(Literal, Bounds(Type::String(zone)));         \
+  /* stdlib shortcuts. */                                  \
+  CheckStdlibShortcuts1(zone, types, index, depth, cache); \
+  CheckStdlibShortcuts2(zone, types, index, depth, cache);
 
 
 #define CHECK_FUNC_TYPES_END_2()                   \
   /* return { foo: foo }; */                       \
   CHECK_EXPR(ObjectLiteral, Bounds::Unbounded()) { \
     CHECK_VAR(foo, FUNC_V_TYPE);                   \
   }                                                \
   }                                                \
   }                                                \
   CHECK_TYPES_END
@@ skipping 1337 matching lines @@
   CHECK(!cache.kAsmFloat->Is(cache.kAsmFixnum));
   CHECK(!cache.kAsmFloat->Is(cache.kAsmDouble));
 
   CHECK(cache.kAsmDouble->Is(cache.kAsmDouble));
   CHECK(!cache.kAsmDouble->Is(cache.kAsmInt));
   CHECK(!cache.kAsmDouble->Is(cache.kAsmUnsigned));
   CHECK(!cache.kAsmDouble->Is(cache.kAsmSigned));
   CHECK(!cache.kAsmDouble->Is(cache.kAsmFixnum));
   CHECK(!cache.kAsmDouble->Is(cache.kAsmFloat));
 }