[turbofan] Improve typed lowering of JSBitwiseAnd.

src/compiler/js-typed-lowering.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/access-builder.h"
 #include "src/compiler/graph-inl.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/node-aux-data-inl.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 15 matching lines @@
 // TODO(titzer): move into a GraphEditor?
 static void RelaxEffects(Node* node) {
   NodeProperties::ReplaceWithValue(node, node, NULL);
 }
 
 
 JSTypedLowering::JSTypedLowering(JSGraph* jsgraph, Zone* zone)
     : jsgraph_(jsgraph), simplified_(graph()->zone()), conversions_(zone) {
   Handle<Object> zero = factory()->NewNumber(0.0);
   Handle<Object> one = factory()->NewNumber(1.0);
-  zero_range_ = Type::Range(zero, zero, graph()->zone());
-  one_range_ = Type::Range(one, one, graph()->zone());
+  zero_range_ = Type::Range(zero, zero, zone);
+  one_range_ = Type::Range(one, one, zone);
+  zero_one_range_ = Type::Range(zero, one, zone);
   Handle<Object> thirtyone = factory()->NewNumber(31.0);
-  zero_thirtyone_range_ = Type::Range(zero, thirtyone, graph()->zone());
+  zero_thirtyone_range_ = Type::Range(zero, thirtyone, zone);
   // TODO(jarin): Can we have a correctification of the stupid type system?
   // These stupid work-arounds are just stupid!
   shifted_int32_ranges_[0] = Type::Signed32();
   if (SmiValuesAre31Bits()) {
     shifted_int32_ranges_[1] = Type::SignedSmall();
     for (size_t k = 2; k < arraysize(shifted_int32_ranges_); ++k) {
       Handle<Object> min = factory()->NewNumber(kMinInt / (1 << k));
       Handle<Object> max = factory()->NewNumber(kMaxInt / (1 << k));
-      shifted_int32_ranges_[k] = Type::Range(min, max, graph()->zone());
+      shifted_int32_ranges_[k] = Type::Range(min, max, zone);
     }
   } else {
     for (size_t k = 1; k < arraysize(shifted_int32_ranges_); ++k) {
       Handle<Object> min = factory()->NewNumber(kMinInt / (1 << k));
       Handle<Object> max = factory()->NewNumber(kMaxInt / (1 << k));
-      shifted_int32_ranges_[k] = Type::Range(min, max, graph()->zone());
+      shifted_int32_ranges_[k] = Type::Range(min, max, zone);
     }
   }
 }
 
 
 Reduction JSTypedLowering::ReplaceEagerly(Node* old, Node* node) {
   NodeProperties::ReplaceWithValue(old, node, node);
   return Changed(node);
 }
 
@@ skipping 39 matching lines @@
   }
 
   void SwapInputs() {
     Node* l = left();
     Node* r = right();
     node_->ReplaceInput(0, r);
     node_->ReplaceInput(1, l);
     std::swap(left_type_, right_type_);
   }
 
+  void ReplaceLeftInput(Node* l) {
+    node_->ReplaceInput(0, l);
+    left_type_ = NodeProperties::GetBounds(l).upper;
+  }
+
   // Remove all effect and control inputs and outputs to this node and change
   // to the pure operator {op}, possibly inserting a boolean inversion.
   Reduction ChangeToPureOperator(const Operator* op, bool invert = false,
                                  Type* type = Type::Any()) {
     DCHECK_EQ(0, op->EffectInputCount());
     DCHECK_EQ(false, OperatorProperties::HasContextInput(op));
     DCHECK_EQ(0, op->ControlInputCount());
-    DCHECK_EQ(2, op->ValueInputCount());
+    DCHECK_LE(1, op->ValueInputCount());
+    DCHECK_GE(2, op->ValueInputCount());
 
     // Remove the effects from the node, if any, and update its effect usages.
     if (node_->op()->EffectInputCount() > 0) {
       RelaxEffects(node_);
     }
+    // Finally, update the operator to the new one.
+    node_->set_op(op);
     // Remove the inputs corresponding to context, effect, and control.
     NodeProperties::RemoveNonValueInputs(node_);
-    // Finally, update the operator to the new one.
-    node_->set_op(op);
 
     // TODO(jarin): Replace the explicit typing hack with a call to some method
     // that encapsulates changing the operator and re-typing.
     Bounds const bounds = NodeProperties::GetBounds(node_);
     NodeProperties::SetBounds(node_, Bounds::NarrowUpper(bounds, type, zone()));
 
     if (invert) {
       // Insert an boolean not to invert the value.
       Node* value = graph()->NewNode(simplified()->BooleanNot(), node_);
       node_->ReplaceUses(value);
       // Note: ReplaceUses() smashes all uses, so smash it back here.
       value->ReplaceInput(0, node_);
       return lowering_->Replace(value);
     }
     return lowering_->Changed(node_);
   }
 
   Reduction ChangeToPureOperator(const Operator* op, Type* type) {
     return ChangeToPureOperator(op, false, type);
   }
 
-  bool OneInputIs(Type* t) { return left_type_->Is(t) || right_type_->Is(t); }
+  Reduction ReplaceWithLeftInput() {
+    // Remove the effects from the node, if any, and update its effect usages.
+    if (node_->op()->EffectInputCount() > 0) {
+      RelaxEffects(node_);
+    }
+    return lowering_->Replace(left());
+  }
 
-  bool BothInputsAre(Type* t) {
-    return left_type_->Is(t) && right_type_->Is(t);
-  }
+  bool LeftInputIs(Type* t) { return left_type_->Is(t); }
+  bool RightInputIs(Type* t) { return right_type_->Is(t); }
+  bool OneInputIs(Type* t) { return LeftInputIs(t) || RightInputIs(t); }
+  bool BothInputsAre(Type* t) { return LeftInputIs(t) && RightInputIs(t); }
 
   bool OneInputCannotBe(Type* t) {
     return !left_type_->Maybe(t) || !right_type_->Maybe(t);
   }
 
   bool NeitherInputCanBe(Type* t) {
     return !left_type_->Maybe(t) && !right_type_->Maybe(t);
   }
 
   Node* effect() { return NodeProperties::GetEffectInput(node_); }
@@ skipping 91 matching lines @@
     // JSAdd(x:string, y) => StringAdd(x, ToString(y))
     // JSAdd(x, y:string) => StringAdd(ToString(x), y)
     r.ConvertInputsToString();
     return r.ChangeToPureOperator(simplified()->StringAdd());
   }
 #endif
   return NoChange();
 }
 
 
+Reduction JSTypedLowering::ReduceJSBitwiseAnd(Node* node) {
+  JSBinopReduction r(this, node);
+  if (r.LeftInputIs(one_range_)) {
+    if (r.RightInputIs(zero_one_range_)) {
+      // JSBitwiseAnd(1, x:[0,1]) => x
+      r.SwapInputs();
+      return r.ReplaceWithLeftInput();
+    } else if (r.RightInputIs(Type::Boolean())) {
+      // JSBitwiseAnd(1, x:boolean) => BooleanToNumber(x)
+      r.SwapInputs();
+      return r.ChangeToPureOperator(simplified()->BooleanToNumber());
+    }
+  }
+  if (r.RightInputIs(one_range_)) {
+    if (r.LeftInputIs(zero_one_range_)) {
+      // JSBitwiseAnd(x:[0,1], 1) => x
+      return r.ReplaceWithLeftInput();
+    } else if (r.LeftInputIs(Type::Boolean())) {
+      // JSBitwiseAnd(x:boolean, 1) => BooleanToNumber(x)
+      return r.ChangeToPureOperator(simplified()->BooleanToNumber());
+    }
+  }
+  if (r.BothInputsAre(Type::Primitive())) {
+    // TODO(titzer): some Smi bitwise operations don't really require going
+    // all the way to int32, which can save tagging/untagging for some
+    // operations
+    // on some platforms.
+    // TODO(turbofan): make this heuristic configurable for code size.
+    r.ConvertInputsToUI32(kSigned, kSigned);
+    return r.ChangeToPureOperator(machine()->Word32And(), Type::Integral32());
+  }
+  return NoChange();
+}
+
+
 Reduction JSTypedLowering::ReduceJSBitwiseOr(Node* node) {
   JSBinopReduction r(this, node);
   if (r.BothInputsAre(Type::Primitive()) || r.OneInputIs(zero_range_)) {
     // TODO(jarin): Propagate frame state input from non-primitive input node to
     // JSToNumber node.
     // TODO(titzer): some Smi bitwise operations don't really require going
     // all the way to int32, which can save tagging/untagging for some
     // operations
     // on some platforms.
     // TODO(turbofan): make this heuristic configurable for code size.
@@ skipping 602 matching lines @@
     case IrOpcode::kJSLessThan:         // fall through
     case IrOpcode::kJSGreaterThan:      // fall through
     case IrOpcode::kJSLessThanOrEqual:  // fall through
     case IrOpcode::kJSGreaterThanOrEqual:
       return ReduceJSComparison(node);
     case IrOpcode::kJSBitwiseOr:
       return ReduceJSBitwiseOr(node);
     case IrOpcode::kJSBitwiseXor:
       return ReduceInt32Binop(node, machine()->Word32Xor());
     case IrOpcode::kJSBitwiseAnd:
-      return ReduceInt32Binop(node, machine()->Word32And());
+      return ReduceJSBitwiseAnd(node);
     case IrOpcode::kJSShiftLeft:
       return ReduceUI32Shift(node, kSigned, machine()->Word32Shl());
     case IrOpcode::kJSShiftRight:
       return ReduceUI32Shift(node, kSigned, machine()->Word32Sar());
     case IrOpcode::kJSShiftRightLogical:
       return ReduceUI32Shift(node, kUnsigned, machine()->Word32Shr());
     case IrOpcode::kJSAdd:
       return ReduceJSAdd(node);
     case IrOpcode::kJSSubtract:
       return ReduceNumberBinop(node, simplified()->NumberSubtract());
@@ skipping 85 matching lines @@
 }
 
 
 MachineOperatorBuilder* JSTypedLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8