[turbofan] Address the useless overflow bit materialization.

src/compiler/machine-operator.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/compiler/machine-operator.h"
 
 #include "src/base/lazy-instance.h"
 #include "src/compiler/opcodes.h"
 #include "src/compiler/operator.h"
 
@@ skipping 70 matching lines @@
   V(Word64And, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
   V(Word64Or, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)       \
   V(Word64Xor, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)      \
   V(Word64Shl, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word64Shr, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word64Sar, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word64Ror, Operator::kNoProperties, 2, 0, 1)                              \
   V(Word64Clz, Operator::kNoProperties, 1, 0, 1)                              \
   V(Word64Equal, Operator::kCommutative, 2, 0, 1)                             \
   V(Int32Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)       \
-  V(Int32AddWithOverflow, Operator::kAssociative | Operator::kCommutative, 2, \
-    0, 2)                                                                     \
   V(Int32Sub, Operator::kNoProperties, 2, 0, 1)                               \
-  V(Int32SubWithOverflow, Operator::kNoProperties, 2, 0, 2)                   \
   V(Int32Mul, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)       \
   V(Int32MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)   \
   V(Int32Div, Operator::kNoProperties, 2, 1, 1)                               \
   V(Int32Mod, Operator::kNoProperties, 2, 1, 1)                               \
   V(Int32LessThan, Operator::kNoProperties, 2, 0, 1)                          \
   V(Int32LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                   \
   V(Uint32Div, Operator::kNoProperties, 2, 1, 1)                              \
   V(Uint32LessThan, Operator::kNoProperties, 2, 0, 1)                         \
   V(Uint32LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                  \
   V(Uint32Mod, Operator::kNoProperties, 2, 1, 1)                              \
   V(Uint32MulHigh, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)  \
   V(Int64Add, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)       \
-  V(Int64AddWithOverflow, Operator::kAssociative | Operator::kCommutative, 2, \
-    0, 2)                                                                     \
   V(Int64Sub, Operator::kNoProperties, 2, 0, 1)                               \
-  V(Int64SubWithOverflow, Operator::kNoProperties, 2, 0, 2)                   \
   V(Int64Mul, Operator::kAssociative | Operator::kCommutative, 2, 0, 1)       \
   V(Int64Div, Operator::kNoProperties, 2, 1, 1)                               \
   V(Int64Mod, Operator::kNoProperties, 2, 1, 1)                               \
   V(Int64LessThan, Operator::kNoProperties, 2, 0, 1)                          \
   V(Int64LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                   \
   V(Uint64Div, Operator::kNoProperties, 2, 1, 1)                              \
   V(Uint64Mod, Operator::kNoProperties, 2, 1, 1)                              \
   V(Uint64LessThan, Operator::kNoProperties, 2, 0, 1)                         \
   V(Uint64LessThanOrEqual, Operator::kNoProperties, 2, 0, 1)                  \
   V(BitcastWordToTagged, Operator::kNoProperties, 1, 0, 1)                    \
@@ skipping 262 matching lines @@
   V(Float32RoundUp, Operator::kNoProperties, 1, 0, 1)       \
   V(Float64RoundUp, Operator::kNoProperties, 1, 0, 1)       \
   V(Float32RoundTruncate, Operator::kNoProperties, 1, 0, 1) \
   V(Float64RoundTruncate, Operator::kNoProperties, 1, 0, 1) \
   V(Float64RoundTiesAway, Operator::kNoProperties, 1, 0, 1) \
   V(Float32RoundTiesEven, Operator::kNoProperties, 1, 0, 1) \
   V(Float64RoundTiesEven, Operator::kNoProperties, 1, 0, 1) \
   V(Float32Neg, Operator::kNoProperties, 1, 0, 1)           \
   V(Float64Neg, Operator::kNoProperties, 1, 0, 1)
 
+#define OVERFLOW_OP_LIST(V)                                                \
+  V(Int32AddWithOverflow, Operator::kAssociative | Operator::kCommutative) \
+  V(Int32SubWithOverflow, Operator::kNoProperties)                         \
+  V(Int64AddWithOverflow, Operator::kAssociative | Operator::kCommutative) \
+  V(Int64SubWithOverflow, Operator::kNoProperties)
+
 #define MACHINE_TYPE_LIST(V) \
   V(Float32)                 \
   V(Float64)                 \
   V(Simd128)                 \
   V(Int8)                    \
   V(Uint8)                   \
   V(Int16)                   \
   V(Uint16)                  \
   V(Int32)                   \
   V(Uint32)                  \
@@ skipping 32 matching lines @@
     Name##Operator()                                                           \
         : Operator(IrOpcode::k##Name, Operator::kPure | properties, #Name,     \
                    value_input_count, 0, control_input_count, output_count, 0, \
                    0) {}                                                       \
   };                                                                           \
   Name##Operator k##Name;
   PURE_OP_LIST(PURE)
   PURE_OPTIONAL_OP_LIST(PURE)
 #undef PURE
 
+#define OVERFLOW_OP(Name, properties)                                        \
+  struct Name##Operator final : public Operator {                            \
+    Name##Operator()                                                         \
+        : Operator(IrOpcode::k##Name,                                        \
+                   Operator::kEliminatable | Operator::kNoRead | properties, \
+                   #Name, 2, 0, 1, 2, 0, 0) {}                               \
+  };                                                                         \
+  Name##Operator k##Name;
+  OVERFLOW_OP_LIST(OVERFLOW_OP)
+#undef OVERFLOW_OP
+
 #define LOAD(Type)                                                           \
   struct Load##Type##Operator final : public Operator1<LoadRepresentation> { \
     Load##Type##Operator()                                                   \
         : Operator1<LoadRepresentation>(                                     \
               IrOpcode::kLoad,                                               \
               Operator::kNoDeopt | Operator::kNoThrow | Operator::kNoWrite,  \
               "Load", 2, 1, 1, 1, 1, 0, MachineType::Type()) {}              \
   };                                                                         \
   struct CheckedLoad##Type##Operator final                                   \
       : public Operator1<CheckedLoadRepresentation> {                        \
@@ skipping 132 matching lines @@
 #undef PURE
 
 #define PURE(Name, properties, value_input_count, control_input_count,     \
              output_count)                                                 \
   const OptionalOperator MachineOperatorBuilder::Name() {                  \
     return OptionalOperator(flags_ & k##Name ? &cache_.k##Name : nullptr); \
   }
 PURE_OPTIONAL_OP_LIST(PURE)
 #undef PURE
 
+#define OVERFLOW_OP(Name, properties) \
+  const Operator* MachineOperatorBuilder::Name() { return &cache_.k##Name; }
+OVERFLOW_OP_LIST(OVERFLOW_OP)
+#undef OVERFLOW_OP
 
 const Operator* MachineOperatorBuilder::Load(LoadRepresentation rep) {
 #define LOAD(Type)                  \
   if (rep == MachineType::Type()) { \
     return &cache_.kLoad##Type;     \
   }
     MACHINE_TYPE_LIST(LOAD)
 #undef LOAD
   UNREACHABLE();
   return nullptr;
@@ skipping 104 matching lines @@
   }
   ATOMIC_REPRESENTATION_LIST(STORE)
 #undef STORE
   UNREACHABLE();
   return nullptr;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8