[turbofan] Take the immediate size in account when narrowing ia32/x64 word comparison operators.

test/cctest/compiler/test-run-load-store.cc

 // Copyright 2016 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 <cmath>
 #include <functional>
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/base/utils/random-number-generator.h"
@@ skipping 233 matching lines @@
   FOR_INT32_INPUTS(i) {
     buffer[0] = *i;
 
     CHECK_EQ(static_cast<int8_t>(*i & 0xff), m.Call());
     CHECK_EQ(static_cast<int8_t>(*i & 0xff), buffer[1]);
     CHECK_EQ(static_cast<int16_t>(*i & 0xffff), buffer[2]);
     CHECK_EQ(*i, buffer[3]);
   }
 }
 
+TEST(RunLoadEliminationWithCompareAndTest) {
+  int8_t byte = 0x81;
+  int16_t word = 0xf00f;
+  RawMachineAssemblerTester<int32_t> m;
+  Node* load8 = m.LoadFromPointer(&byte, MachineType::Int8());
+  RawMachineLabel a, b, c, d;
+  m.Branch(m.Word32And(load8, m.Int32Constant(-0x80)), &b, &a);
+  m.Bind(&a);
+  m.Return(m.Int32Constant(0));
+  m.Bind(&b);
+  Node* load16 = m.LoadFromPointer(&word, MachineType::Int16());
+  m.Branch(m.Word32And(load16, m.Int32Constant(-0x7fff)), &d, &c);
+  m.Bind(&c);
+  m.Return(m.Int32Constant(0));
+  m.Bind(&d);
+  m.Return(m.Int32Constant(1));
+
+  CHECK_EQ(1, m.Call());
+}
+
 TEST(RunLoadStoreZeroExtend32) {
   uint32_t buffer[4];
   RawMachineAssemblerTester<uint32_t> m;
   Node* load8 = m.LoadFromPointer(LSB(&buffer[0], 1), MachineType::Uint8());
   Node* load16 = m.LoadFromPointer(LSB(&buffer[0], 2), MachineType::Uint16());
   Node* load32 = m.LoadFromPointer(&buffer[0], MachineType::Uint32());
   m.StoreToPointer(&buffer[1], MachineRepresentation::kWord32, load8);
   m.StoreToPointer(&buffer[2], MachineRepresentation::kWord32, load16);
   m.StoreToPointer(&buffer[3], MachineRepresentation::kWord32, load32);
   m.Return(load8);
@@ skipping 646 matching lines @@
   TestRunOobCheckedLoadT_pseudo<int32_t>(4 * A_BILLION, true);
   TestRunOobCheckedLoadT_pseudo<float>(4 * A_BILLION, false);
   TestRunOobCheckedLoadT_pseudo<float>(4 * A_BILLION, true);
   TestRunOobCheckedLoadT_pseudo<double>(4 * A_BILLION, false);
   TestRunOobCheckedLoadT_pseudo<double>(4 * A_BILLION, true);
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8