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(
+          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()
+              ? 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);
+      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 94 matching lines @@
   }
   return kNoWriteBarrier;
 }
 
 
 void SimplifiedLowering::DoLoadField(Node* node) {
   const FieldAccess& access = FieldAccessOf(node->op());
   node->set_op(machine()->Load(access.machine_type));
   Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
   node->InsertInput(zone(), 1, offset);
-  node->AppendInput(zone(), graph()->start());
 }
 
 
 void SimplifiedLowering::DoStoreField(Node* node) {
   const FieldAccess& access = FieldAccessOf(node->op());
   WriteBarrierKind kind = ComputeWriteBarrierKind(
       access.base_is_tagged, access.machine_type, access.type);
   node->set_op(
       machine()->Store(StoreRepresentation(access.machine_type, kind)));
   Node* offset = jsgraph()->Int32Constant(access.offset - access.tag());
@@ skipping 173 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