Hack representation inference to assume current behavior of float32 loads and stores, which include…

test/cctest/compiler/test-run-properties.cc

 // Copyright 2014 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 "src/v8.h"
 
 #include "test/cctest/compiler/function-tester.h"
 
 using namespace v8::internal;
 using namespace v8::internal::compiler;
@@ skipping 29 matching lines @@
   EmbeddedVector<char, 1024> source_buffer;
   SNPrintF(source_buffer, source, array_type, arraysize(kValues),
            values_buffer.start(), array_type, arraysize(kValues),
            values_buffer.start(), array_type, array_type);
 
   FunctionTester T(
       source_buffer.start(),
       CompilationInfo::kContextSpecializing | CompilationInfo::kTypingEnabled);
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     for (size_t j = 0; j < arraysize(kValues); ++j) {
-      double value_a = static_cast<U>(kValues[i]);
-      double value_b = static_cast<U>(kValues[j]);
-      double expected = value_a + value_b;
+      volatile U value_a = static_cast<U>(kValues[i]);

[Michael Starzinger, 2014/09/18 18:38:07]

Man, do I love C++ intuitiveness. :)

+      volatile U value_b = static_cast<U>(kValues[j]);
+      double expected =
+          static_cast<double>(value_a) + static_cast<double>(value_b);

[Sven Panne, 2014/09/19 06:07:26]

Casting away volatile leads to undefined behavior:

Section 7.1.6.1 The cv-qualifiers
... If an attempt is made to refer to an object defined with a
volatile-qualified type through the use of a glvalue
with a non-volatile-qualified type, the program behavior is undefined.

Why was it introduced here at all? Trying to avoid some compiler optimizations?
If that was the intention, that won't work in general.

       T.CheckCall(T.Val(expected), T.Val(static_cast<double>(i)),
                   T.Val(static_cast<double>(j)));
     }
   }
 }
 
 
 TEST(TypedArrayLoad) {
   FLAG_typed_array_max_size_in_heap = 256;
   TypedArrayLoadHelper<int8_t>("Int8");
   TypedArrayLoadHelper<uint8_t>("Uint8");
   TypedArrayLoadHelper<int16_t>("Int16");
   TypedArrayLoadHelper<uint16_t>("Uint16");
   TypedArrayLoadHelper<int32_t>("Int32");
   TypedArrayLoadHelper<uint32_t>("Uint32");
+  TypedArrayLoadHelper<float>("Float32");
   TypedArrayLoadHelper<double>("Float64");
-  // TODO(mstarzinger): Add tests for Float32.
   // TODO(mstarzinger): Add tests for ClampedUint8.
 }
 
 
 template <typename U>
 static void TypedArrayStoreHelper(const char* array_type) {
   static const uint32_t kValues[] = {
       0x00000000, 0x00000001, 0x00000023, 0x00000042, 0x12345678, 0x87654321,
       0x0000003f, 0x0000007f, 0x00003fff, 0x00007fff, 0x3fffffff, 0x7fffffff,
       0x000000ff, 0x00000080, 0x0000ffff, 0x00008000, 0xffffffff, 0x80000000};
@@ skipping 28 matching lines @@
   EmbeddedVector<char, 2048> source_buffer;
   SNPrintF(source_buffer, source, array_type, arraysize(kValues),
            values_buffer.start(), array_type, arraysize(kValues),
            values_buffer.start(), array_type, array_type);
 
   FunctionTester T(
       source_buffer.start(),
       CompilationInfo::kContextSpecializing | CompilationInfo::kTypingEnabled);
   for (size_t i = 0; i < arraysize(kValues); ++i) {
     for (size_t j = 0; j < arraysize(kValues); ++j) {
-      double value_a = static_cast<U>(kValues[i]);
-      double value_b = static_cast<U>(kValues[j]);
-      double expected = value_b + value_a;
+      volatile U value_a = static_cast<U>(kValues[i]);
+      volatile U value_b = static_cast<U>(kValues[j]);
+      double expected =
+          static_cast<double>(value_a) + static_cast<double>(value_b);
       T.CheckCall(T.Val(expected), T.Val(static_cast<double>(i)),
                   T.Val(static_cast<double>(j)));
     }
   }
 }
 
 
 TEST(TypedArrayStore) {
   FLAG_typed_array_max_size_in_heap = 256;
   TypedArrayStoreHelper<int8_t>("Int8");
   TypedArrayStoreHelper<uint8_t>("Uint8");
   TypedArrayStoreHelper<int16_t>("Int16");
   TypedArrayStoreHelper<uint16_t>("Uint16");
   TypedArrayStoreHelper<int32_t>("Int32");
   TypedArrayStoreHelper<uint32_t>("Uint32");
+  TypedArrayStoreHelper<float>("Float32");
   TypedArrayStoreHelper<double>("Float64");
-  // TODO(mstarzinger): Add tests for Float32.
   // TODO(mstarzinger): Add tests for ClampedUint8.
 }