Add inlining for intrinsics.

src/compiler/simplified-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/simplified-lowering.h"
 
 #include <limits>
 
 #include "src/base/bits.h"
 #include "src/code-factory.h"
@@ skipping 337 matching lines @@
       MachineType use_type =
           static_cast<MachineType>((use & kTypeMask) | propagate);
       for (Node::Inputs::iterator iter(inputs.begin()); iter != inputs.end();
            ++iter, --values) {
         // TODO(titzer): it'd be nice to have distinguished edge kinds here.
         ProcessInput(node, iter.index(), values > 0 ? use_type : 0);
       }
     }
   }
 
+  void VisitIsSmi(Node* node) {
+    ProcessInput(node, 0, kMachAnyTagged);
+    if (lower()) {
+      Node* is_tagged = jsgraph_->graph()->NewNode(
+          jsgraph_->machine()->WordAnd(), node->InputAt(0),
+          jsgraph_->Int32Constant(static_cast<int>(kSmiTagMask)));
+      Node* is_smi = jsgraph_->graph()->NewNode(

[Michael Starzinger, 2014/10/15 13:03:17]

For posterity: There might be a more optimal lowering if the output
representation is determined to be kRepBit, but lets land it like this for now.

[sigurds, 2014/10/15 14:59:58]

Acknowledged.

+          jsgraph_->machine()->WordEqual(), is_tagged,
+          jsgraph_->Int32Constant(kSmiTag));
+      DeferReplacement(node, is_smi);
+    }
+    SetOutput(node, kRepBit | kTypeBool);
+  }
+
+  void VisitIsNonNegativeSmi(Node* node) {
+    ProcessInput(node, 0, kMachAnyTagged);
+    if (lower()) {
+      Node* is_tagged = jsgraph_->graph()->NewNode(
+          jsgraph_->machine()->WordAnd(), node->InputAt(0),
+          jsgraph_->Int32Constant(static_cast<int>(kSmiTagMask)));
+      Node* is_smi = jsgraph_->graph()->NewNode(
+          jsgraph_->machine()->WordEqual(), is_tagged,
+          jsgraph_->Int32Constant(kSmiTag));
+      Node* is_non_neg = jsgraph_->graph()->NewNode(
+          jsgraph_->machine()->Is32()

[Michael Starzinger, 2014/10/15 13:03:17]

nit: There already should be IntLessThanOrEqual() shortcut for this.

[sigurds, 2014/10/15 14:59:58]

Done.

+              ? jsgraph_->machine()->Int32LessThanOrEqual()
+              : jsgraph_->machine()->Int64LessThanOrEqual(),
+          jsgraph_->Int32Constant(0), node->InputAt(0));
+      Node* is_non_neg_smi = jsgraph_->graph()->NewNode(
+          jsgraph_->machine()->Word32And(), is_smi, is_non_neg);
+      DeferReplacement(node, is_non_neg_smi);
+    }
+    SetOutput(node, kRepBit | kTypeBool);
+  }
+
   const Operator* Int32Op(Node* node) {
     return changer_->Int32OperatorFor(node->opcode());
   }
 
   const Operator* Uint32Op(Node* node) {
     return changer_->Uint32OperatorFor(node->opcode());
   }
 
   const Operator* Float64Op(Node* node) {
     return changer_->Float64OperatorFor(node->opcode());
@@ skipping 458 matching lines @@
       case IrOpcode::kFloat64LessThanOrEqual:
         return VisitFloat64Cmp(node);
       case IrOpcode::kLoadStackPointer:
         return VisitLeaf(node, kMachPtr);
       case IrOpcode::kStateValues:
         for (int i = 0; i < node->InputCount(); i++) {
           ProcessInput(node, i, kTypeAny);
         }
         SetOutput(node, kMachAnyTagged);
         break;
+      case IrOpcode::kIsSmi:
+        return VisitIsSmi(node);

[Michael Starzinger, 2014/10/15 13:03:17]

Please move this into the section for simplified operators, we are in the
section for machine operators here.

Also to be consistent with the rest of the code, the processing of inputs and
setting of output type (i.e. the "VisitFoo" method family) should be done
inline, whereas the actual lowering could be done in a helper (i.e. the "DoFoo"
method familiy).

[sigurds, 2014/10/15 14:59:58]

Done. Did not create DoIsSmi/DoIsNonNegativeSmi.

+      case IrOpcode::kIsNonNegativeSmi:
+        return VisitIsNonNegativeSmi(node);
       default:
         VisitInputs(node);
         break;
     }
   }
 
   void DeferReplacement(Node* node, Node* replacement) {
     if (FLAG_trace_representation) {
       TRACE(("defer replacement #%d:%s with #%d:%s\n", node->id(),
              node->op()->mnemonic(), replacement->id(),
@@ skipping 287 matching lines @@
 void SimplifiedLowering::DoStringLessThanOrEqual(Node* node) {
   node->set_op(machine()->IntLessThanOrEqual());
   node->ReplaceInput(0, StringComparison(node, true));
   node->ReplaceInput(1, jsgraph()->SmiConstant(EQUAL));
 }
 
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8