Revert "[test] Avoid unnecessary std::vector allocations"

This reverts commit e737b4ce.

Reason for revert: On windows, V8_INFINITY is not constexpr

Original change's description:
> [test] Avoid unnecessary std::vector allocations
> 
> Instead of copying an array of fixed values into an std::vector for
> each usage of the FOR_INPUTS macro, just iterate the constant data
> directly.
> This also makes the <type>_vector() functions return {constexpr Vector}
> instead of {std::vector}.
> 
> R=​tebbi@chromium.org
> 
> Change-Id: Ifc3e5509b2fbf5e383c967c2f46acf2b07f7b5b4
> Reviewed-on: https://chromium-review.googlesource.com/725427
> Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
> Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#48688}

TBR=clemensh@chromium.org,tebbi@chromium.org

Change-Id: Iccb52941d4efe71b49b41572c3d922a5d78bdfd2
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Reviewed-on: https://chromium-review.googlesource.com/725899Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#48691}

src/vector.h

@@ -19,14 +19,14 @@ namespace internal {
 template <typename T>
 class Vector {
  public:
-  constexpr Vector() : start_(nullptr), length_(0) {}
+  Vector() : start_(nullptr), length_(0) {}
 
   Vector(T* data, size_t length) : start_(data), length_(length) {
     DCHECK(length == 0 || data != nullptr);
   }
 
   template <int N>
-  explicit constexpr Vector(T (&arr)[N]) : start_(arr), length_(N) {}
+  explicit Vector(T (&arr)[N]) : start_(arr), length_(N) {}
 
   static Vector<T> New(int length) {
     return Vector<T>(NewArray<T>(length), length);
@@ -47,13 +47,13 @@ class Vector {
   }
 
   // Returns the length of the vector as a size_t.
-  constexpr size_t size() const { return length_; }
+  size_t size() const { return length_; }
 
   // Returns whether or not the vector is empty.
-  constexpr bool is_empty() const { return length_ == 0; }
+  bool is_empty() const { return length_ == 0; }
 
   // Returns the pointer to the start of the data in the vector.
-  constexpr T* start() const { return start_; }
+  T* start() const { return start_; }
 
   // Access individual vector elements - checks bounds in debug mode.
   T& operator[](size_t index) const {
@@ -65,14 +65,11 @@ class Vector {
 
   T& first() { return start_[0]; }
 
-  T& last() {
-    DCHECK_LT(0, length_);
-    return start_[length_ - 1];
-  }
+  T& last() { return start_[length_ - 1]; }
 
   typedef T* iterator;
-  constexpr iterator begin() const { return start_; }
-  constexpr iterator end() const { return start_ + length_; }
+  inline iterator begin() const { return &start_[0]; }
+  inline iterator end() const { return &start_[length_]; }
 
   // Returns a clone of this vector with a new backing store.
   Vector<T> Clone() const {
@@ -133,8 +130,8 @@ class Vector {
   // Factory method for creating empty vectors.
   static Vector<T> empty() { return Vector<T>(nullptr, 0); }
 
-  template <typename S>
-  static constexpr Vector<T> cast(Vector<S> input) {
+  template<typename S>
+  static Vector<T> cast(Vector<S> input) {
     return Vector<T>(reinterpret_cast<T*>(input.start()),
                      input.length() * sizeof(S) / sizeof(T));
   }
@@ -217,7 +214,7 @@ inline Vector<char> MutableCStrVector(char* data, int max) {
 }
 
 template <typename T, int N>
-inline constexpr Vector<T> ArrayVector(T (&arr)[N]) {
+inline Vector<T> ArrayVector(T (&arr)[N]) {
   return Vector<T>(arr);
 }
 

test/cctest/BUILD.gn

@@ -87,7 +87,6 @@ v8_source_set("cctest_sources") {
     "compiler/test-run-unwinding-info.cc",
     "compiler/test-run-variables.cc",
     "compiler/test-run-wasm-machops.cc",
-    "compiler/value-helper.cc",
     "compiler/value-helper.h",
     "expression-type-collector-macros.h",
     "gay-fixed.cc",

test/cctest/cctest.gyp

@@ -75,7 +75,6 @@
       'compiler/test-run-stubs.cc',
       'compiler/test-run-variables.cc',
       'compiler/test-run-wasm-machops.cc',
-      'compiler/value-helper.cc',
       'compiler/value-helper.h',
       'cctest.cc',
       'cctest.h',

test/cctest/compiler/codegen-tester.cc

@@ -285,7 +285,7 @@ TEST(CompareWrapper) {
 
 
 void Int32BinopInputShapeTester::TestAllInputShapes() {
-  Vector<const int32_t> inputs = ValueHelper::int32_vector();
+  std::vector<int32_t> inputs = ValueHelper::int32_vector();
   int num_int_inputs = static_cast<int>(inputs.size());
   if (num_int_inputs > 16) num_int_inputs = 16;  // limit to 16 inputs
 

test/cctest/compiler/value-helper.cc

-// Copyright 2017 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.
-
-#include "test/cctest/compiler/value-helper.h"
-
-namespace v8 {
-namespace internal {
-namespace compiler {
-
-// Define constexpr arrays of ValueHelper for external references.
-constexpr int8_t ValueHelper::int8_array[];
-constexpr int16_t ValueHelper::int16_array[];
-constexpr uint32_t ValueHelper::uint32_array[];
-constexpr uint64_t ValueHelper::uint64_array[];
-constexpr float ValueHelper::float32_array[];
-constexpr double ValueHelper::float64_array[];
-
-}  // namespace compiler
-}  // namespace internal
-}  // namespace v8

test/cctest/compiler/value-helper.h

@@ -7,11 +7,9 @@
 
 #include <stdint.h>
 
-#include "src/base/template-utils.h"
 #include "src/compiler/common-operator.h"
-#include "src/compiler/node-matchers.h"
 #include "src/compiler/node.h"
-#include "src/heap/heap-inl.h"
+#include "src/compiler/node-matchers.h"
 #include "src/isolate.h"
 #include "src/objects.h"
 #include "test/cctest/cctest.h"
@@ -62,7 +60,9 @@ class ValueHelper {
     CheckHeapConstant(isolate_->heap()->false_value(), node);
   }
 
-  static constexpr float float32_array[] = {
+  static std::vector<float> float32_vector() {
+    static const float nan = std::numeric_limits<float>::quiet_NaN();
+    static const float kValues[] = {
         -std::numeric_limits<float>::infinity(),
         -2.70497e+38f,
         -1.4698e+37f,
@@ -176,15 +176,15 @@ class ValueHelper {
         3.31899e+38f,
         3.40282e+38f,
         std::numeric_limits<float>::infinity(),
-      std::numeric_limits<float>::quiet_NaN(),
-      -std::numeric_limits<float>::quiet_NaN()};
-
-  static constexpr Vector<const float> float32_vector() {
-    return ArrayVector(float32_array);
+        nan,
+        -nan,
+    };
+    return std::vector<float>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 
-  static constexpr double float64_array[] = {
-      -2e66,
+  static std::vector<double> float64_vector() {
+    static const double nan = std::numeric_limits<double>::quiet_NaN();
+    static const double values[] = {-2e66,
                                     -2.220446049250313e-16,
                                     -9223373136366403584.0,
                                     -9223372036854775808.0,  // INT64_MIN
@@ -231,14 +231,18 @@ class ValueHelper {
                                     2e66,
                                     V8_INFINITY,
                                     -V8_INFINITY,
-      std::numeric_limits<double>::quiet_NaN(),
-      -std::numeric_limits<double>::quiet_NaN()};
+                                    -nan,
+                                    nan};
+    return std::vector<double>(&values[0], &values[arraysize(values)]);
+  }
 
-  static constexpr Vector<const double> float64_vector() {
-    return ArrayVector(float64_array);
+  static const std::vector<int32_t> int32_vector() {
+    std::vector<uint32_t> values = uint32_vector();
+    return std::vector<int32_t>(values.begin(), values.end());
   }
 
-  static constexpr uint32_t uint32_array[] = {
+  static const std::vector<uint32_t> uint32_vector() {
+    static const uint32_t kValues[] = {
         0x00000000, 0x00000001, 0xffffffff, 0x1b09788b, 0x04c5fce8, 0xcc0de5bf,
         // This row is useful for testing lea optimizations on intel.
         0x00000002, 0x00000003, 0x00000004, 0x00000005, 0x00000008, 0x00000009,
@@ -249,16 +253,16 @@ class ValueHelper {
         0xeeeeeeee, 0xfffffffd, 0xf0000000, 0x007fffff, 0x003fffff, 0x001fffff,
         0x000fffff, 0x0007ffff, 0x0003ffff, 0x0001ffff, 0x0000ffff, 0x00007fff,
         0x00003fff, 0x00001fff, 0x00000fff, 0x000007ff, 0x000003ff, 0x000001ff};
-
-  static constexpr Vector<const uint32_t> uint32_vector() {
-    return ArrayVector(uint32_array);
+    return std::vector<uint32_t>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 
-  static constexpr Vector<const int32_t> int32_vector() {
-    return Vector<const int32_t>::cast(uint32_vector());
+  static const std::vector<int64_t> int64_vector() {
+    std::vector<uint64_t> values = uint64_vector();
+    return std::vector<int64_t>(values.begin(), values.end());
   }
 
-  static constexpr uint64_t uint64_array[] = {
+  static const std::vector<uint64_t> uint64_vector() {
+    static const uint64_t kValues[] = {
         0x00000000,         0x00000001,         0xffffffff,
         0x1b09788b,         0x04c5fce8,         0xcc0de5bf,
         0x00000002,         0x00000003,         0x00000004,
@@ -285,54 +289,54 @@ class ValueHelper {
         0x000007ffffffffff, 0x000003ffffffffff, 0x000001ffffffffff,
         0x8000008000000000, 0x8000008000000001, 0x8000000000000400,
         0x8000000000000401, 0x0000000000000020};
-
-  static constexpr Vector<const uint64_t> uint64_vector() {
-    return ArrayVector(uint64_array);
+    return std::vector<uint64_t>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 
-  static constexpr Vector<const int64_t> int64_vector() {
-    return Vector<const int64_t>::cast(uint64_vector());
+  static const std::vector<double> nan_vector(size_t limit = 0) {
+    static const double nan = std::numeric_limits<double>::quiet_NaN();
+    static const double values[] = {-nan,               -V8_INFINITY * -0.0,
+                                    -V8_INFINITY * 0.0, V8_INFINITY * -0.0,
+                                    V8_INFINITY * 0.0,  nan};
+    return std::vector<double>(&values[0], &values[arraysize(values)]);
   }
 
-  static constexpr int16_t int16_array[] = {
+  static const std::vector<int16_t> int16_vector() {
+    static const int16_t kValues[] = {
         0, 1, 2, INT16_MAX - 1, INT16_MAX, INT16_MIN, INT16_MIN + 1, -2, -1};
-
-  static constexpr Vector<const int16_t> int16_vector() {
-    return ArrayVector(int16_array);
+    return std::vector<int16_t>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 
-  static constexpr Vector<const uint16_t> uint16_vector() {
-    return Vector<const uint16_t>::cast(int16_vector());
+  static const std::vector<uint16_t> uint16_vector() {
+    std::vector<int16_t> values = int16_vector();
+    return std::vector<uint16_t>(values.begin(), values.end());
   }
 
-  static constexpr int8_t int8_array[] = {
+  static const std::vector<int8_t> int8_vector() {
+    static const int8_t kValues[] = {
         0, 1, 2, INT8_MAX - 1, INT8_MAX, INT8_MIN, INT8_MIN + 1, -2, -1};
-
-  static constexpr Vector<const int8_t> int8_vector() {
-    return ArrayVector(int8_array);
+    return std::vector<int8_t>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 
-  static constexpr Vector<const uint8_t> uint8_vector() {
-    return Vector<const uint8_t>::cast(ArrayVector(int8_array));
+  static const std::vector<uint8_t> uint8_vector() {
+    std::vector<int8_t> values = int8_vector();
+    return std::vector<uint8_t>(values.begin(), values.end());
   }
 
-  static constexpr uint32_t ror_array[31] = {
+  static const std::vector<uint32_t> ror_vector() {
+    static const uint32_t kValues[31] = {
         1,  2,  3,  4,  5,  6,  7,  8,  9,  10, 11, 12, 13, 14, 15, 16,
         17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31};
-
-  static constexpr Vector<const uint32_t> ror_vector() {
-    return ArrayVector(ror_array);
+    return std::vector<uint32_t>(&kValues[0], &kValues[arraysize(kValues)]);
   }
 };
 
 // Helper macros that can be used in FOR_INT32_INPUTS(i) { ... *i ... }
 // Watch out, these macros aren't hygenic; they pollute your scope. Thanks STL.
 #define FOR_INPUTS(ctype, itype, var)                          \
-  Vector<const ctype> var##_vec =                                 \
+  std::vector<ctype> var##_vec =                               \
       ::v8::internal::compiler::ValueHelper::itype##_vector(); \
-  for (Vector<const ctype>::iterator var = var##_vec.begin(),     \
-                                     var##_end = var##_vec.end(); \
-       var != var##_end; ++var)
+  for (std::vector<ctype>::iterator var = var##_vec.begin();   \
+       var != var##_vec.end(); ++var)
 
 #define FOR_INT32_INPUTS(var) FOR_INPUTS(int32_t, int32, var)
 #define FOR_UINT32_INPUTS(var) FOR_INPUTS(uint32_t, uint32, var)

test/cctest/wasm/test-c-wasm-entry.cc

@@ -100,7 +100,8 @@ TEST(TestCWasmEntryArgPassing_int32) {
        WASM_I32_ADD(WASM_I32_MUL(WASM_I32V_1(2), WASM_GET_LOCAL(0)), WASM_ONE)},
       [](int32_t a) { return 2 * a + 1; });
 
-  FOR_INT32_INPUTS(v) { tester.CheckCall(*v); }
+  std::vector<int32_t> test_values = compiler::ValueHelper::int32_vector();
+  for (int32_t v : test_values) tester.CheckCall(v);
 }
 
 // Pass int64_t, return double.
@@ -110,7 +111,10 @@ TEST(TestCWasmEntryArgPassing_double_int64) {
        WASM_F64_SCONVERT_I64(WASM_GET_LOCAL(0))},
       [](int64_t a) { return static_cast<double>(a); });
 
-  FOR_INT64_INPUTS(v) { tester.CheckCall(*v); }
+  std::vector<int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
+  for (int64_t v : test_values_i64) {
+    tester.CheckCall(v);
+  }
 }
 
 // Pass double, return int64_t.
@@ -120,7 +124,9 @@ TEST(TestCWasmEntryArgPassing_int64_double) {
        WASM_I64_SCONVERT_F64(WASM_GET_LOCAL(0))},
       [](double d) { return static_cast<int64_t>(d); });
 
-  FOR_INT64_INPUTS(i) { tester.CheckCall(*i); }
+  for (int64_t i : compiler::ValueHelper::int64_vector()) {
+    tester.CheckCall(i);
+  }
 }
 
 // Pass float, return double.
@@ -132,7 +138,8 @@ TEST(TestCWasmEntryArgPassing_float_double) {
            WASM_F64(1))},
       [](float f) { return 2. * static_cast<double>(f) + 1.; });
 
-  FOR_FLOAT32_INPUTS(f) { tester.CheckCall(*f); }
+  std::vector<float> test_values = compiler::ValueHelper::float32_vector();
+  for (float f : test_values) tester.CheckCall(f);
 }
 
 // Pass two doubles, return double.
@@ -142,8 +149,11 @@ TEST(TestCWasmEntryArgPassing_double_double) {
        WASM_F64_ADD(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))},
       [](double a, double b) { return a + b; });
 
-  FOR_FLOAT64_INPUTS(d1) {
-    FOR_FLOAT64_INPUTS(d2) { tester.CheckCall(*d1, *d2); }
+  std::vector<double> test_values = compiler::ValueHelper::float64_vector();
+  for (double d1 : test_values) {
+    for (double d2 : test_values) {
+      tester.CheckCall(d1, d2);
+    }
   }
 }
 
@@ -166,11 +176,10 @@ TEST(TestCWasmEntryArgPassing_AllTypes) {
         return 0. + a + b + c + d;
       });
 
-  Vector<const int32_t> test_values_i32 = compiler::ValueHelper::int32_vector();
-  Vector<const int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
-  Vector<const float> test_values_f32 = compiler::ValueHelper::float32_vector();
-  Vector<const double> test_values_f64 =
-      compiler::ValueHelper::float64_vector();
+  std::vector<int32_t> test_values_i32 = compiler::ValueHelper::int32_vector();
+  std::vector<int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
+  std::vector<float> test_values_f32 = compiler::ValueHelper::float32_vector();
+  std::vector<double> test_values_f64 = compiler::ValueHelper::float64_vector();
   size_t max_len =
       std::max(std::max(test_values_i32.size(), test_values_i64.size()),
                std::max(test_values_f32.size(), test_values_f64.size()));

test/cctest/wasm/test-wasm-interpreter-entry.cc

@@ -101,7 +101,8 @@ TEST(TestArgumentPassing_int32) {
        WASM_GET_LOCAL(0), WASM_CALL_FUNCTION0(f2.function_index())},
       [](int32_t a) { return 2 * a + 1; });
 
-  FOR_INT32_INPUTS(v) { helper.CheckCall(*v); }
+  std::vector<int32_t> test_values = compiler::ValueHelper::int32_vector();
+  for (int32_t v : test_values) helper.CheckCall(v);
 }
 
 // Pass int64_t, return double.
@@ -124,13 +125,17 @@ TEST(TestArgumentPassing_double_int64) {
         return static_cast<double>(a64 | b64);
       });
 
-  FOR_INT32_INPUTS(v1) {
-    FOR_INT32_INPUTS(v2) { helper.CheckCall(*v1, *v2); }
+  std::vector<int32_t> test_values_i32 = compiler::ValueHelper::int32_vector();
+  for (int32_t v1 : test_values_i32) {
+    for (int32_t v2 : test_values_i32) {
+      helper.CheckCall(v1, v2);
+    }
   }
 
-  FOR_INT64_INPUTS(v) {
-    int32_t v1 = static_cast<int32_t>(*v);
-    int32_t v2 = static_cast<int32_t>(*v >> 32);
+  std::vector<int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
+  for (int64_t v : test_values_i64) {
+    int32_t v1 = static_cast<int32_t>(v);
+    int32_t v2 = static_cast<int32_t>(v >> 32);
     helper.CheckCall(v1, v2);
     helper.CheckCall(v2, v1);
   }
@@ -171,7 +176,8 @@ TEST(TestArgumentPassing_float_double) {
        WASM_GET_LOCAL(0), WASM_CALL_FUNCTION0(f2.function_index())},
       [](float f) { return 2. * static_cast<double>(f) + 1.; });
 
-  FOR_FLOAT32_INPUTS(f) { helper.CheckCall(*f); }
+  std::vector<float> test_values = compiler::ValueHelper::float32_vector();
+  for (float f : test_values) helper.CheckCall(f);
 }
 
 // Pass two doubles, return double.
@@ -187,8 +193,11 @@ TEST(TestArgumentPassing_double_double) {
                            WASM_CALL_FUNCTION0(f2.function_index())},
                           [](double a, double b) { return a + b; });
 
-  FOR_FLOAT64_INPUTS(d1) {
-    FOR_FLOAT64_INPUTS(d2) { helper.CheckCall(*d1, *d2); }
+  std::vector<double> test_values = compiler::ValueHelper::float64_vector();
+  for (double d1 : test_values) {
+    for (double d2 : test_values) {
+      helper.CheckCall(d1, d2);
+    }
   }
 }
 
@@ -233,11 +242,10 @@ TEST(TestArgumentPassing_AllTypes) {
     helper.CheckCall(a, b1, b0, c, d);
   };
 
-  Vector<const int32_t> test_values_i32 = compiler::ValueHelper::int32_vector();
-  Vector<const int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
-  Vector<const float> test_values_f32 = compiler::ValueHelper::float32_vector();
-  Vector<const double> test_values_f64 =
-      compiler::ValueHelper::float64_vector();
+  std::vector<int32_t> test_values_i32 = compiler::ValueHelper::int32_vector();
+  std::vector<int64_t> test_values_i64 = compiler::ValueHelper::int64_vector();
+  std::vector<float> test_values_f32 = compiler::ValueHelper::float32_vector();
+  std::vector<double> test_values_f64 = compiler::ValueHelper::float64_vector();
   size_t max_len =
       std::max(std::max(test_values_i32.size(), test_values_i64.size()),
                std::max(test_values_f32.size(), test_values_f64.size()));