Add a MathFloor stub generated with TurboFan

src/compiler/js-intrinsic-lowering.cc

 // Copyright 2015 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/js-intrinsic-lowering.h"
 
 #include <stack>
 
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/operator-properties.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 JSIntrinsicLowering::JSIntrinsicLowering(JSGraph* jsgraph)
     : jsgraph_(jsgraph), simplified_(jsgraph->zone()) {}
 
 
 Reduction JSIntrinsicLowering::Reduce(Node* node) {
   if (node->opcode() != IrOpcode::kJSCallRuntime) return NoChange();
   const Runtime::Function* const f =
       Runtime::FunctionForId(CallRuntimeParametersOf(node->op()).id());
-  if (f->intrinsic_type != Runtime::IntrinsicType::INLINE) return NoChange();
+  if (f->intrinsic_type != Runtime::IntrinsicType::INLINE) {
+    return NoChange();
+  }
   switch (f->function_id) {
     case Runtime::kInlineConstructDouble:
       return ReduceConstructDouble(node);
     case Runtime::kInlineDeoptimizeNow:
       return ReduceDeoptimizeNow(node);
     case Runtime::kInlineDoubleHi:
       return ReduceDoubleHi(node);
     case Runtime::kInlineDoubleLo:
       return ReduceDoubleLo(node);
     case Runtime::kInlineHeapObjectGetMap:
       return ReduceHeapObjectGetMap(node);
     case Runtime::kInlineIncrementStatsCounter:
       return ReduceIncrementStatsCounter(node);
+    case Runtime::kInlineIsMinusZero:
+      return ReduceIsMinusZero(node);
     case Runtime::kInlineIsArray:
       return ReduceIsInstanceType(node, JS_ARRAY_TYPE);
     case Runtime::kInlineIsFunction:
       return ReduceIsInstanceType(node, JS_FUNCTION_TYPE);
     case Runtime::kInlineIsNonNegativeSmi:
       return ReduceIsNonNegativeSmi(node);
     case Runtime::kInlineIsRegExp:
       return ReduceIsInstanceType(node, JS_REGEXP_TYPE);
     case Runtime::kInlineIsSmi:
       return ReduceIsSmi(node);
@@ skipping 16 matching lines @@
     case Runtime::kInlineStringGetLength:
       return ReduceStringGetLength(node);
     case Runtime::kInlineTwoByteSeqStringGetChar:
       return ReduceSeqStringGetChar(node, String::TWO_BYTE_ENCODING);
     case Runtime::kInlineTwoByteSeqStringSetChar:
       return ReduceSeqStringSetChar(node, String::TWO_BYTE_ENCODING);
     case Runtime::kInlineUnlikely:
       return ReduceUnLikely(node, BranchHint::kFalse);
     case Runtime::kInlineValueOf:
       return ReduceValueOf(node);
+    case Runtime::kInlineFixedArraySet:
+      return ReduceFixedArraySet(node);
+    case Runtime::kInlineGetTypeFeedbackVector:
+      return ReduceGetTypeFeedbackVector(node);
     default:
       break;
   }
   return NoChange();
 }
 
 
 Reduction JSIntrinsicLowering::ReduceConstructDouble(Node* node) {
   Node* high = NodeProperties::GetValueInput(node, 0);
   Node* low = NodeProperties::GetValueInput(node, 1);
@@ skipping 76 matching lines @@
   Node* load =
       graph()->NewNode(simplified()->LoadField(access), cnt, effect, control);
   Node* inc =
       graph()->NewNode(machine()->Int32Add(), load, jsgraph()->OneConstant());
   Node* store = graph()->NewNode(simplified()->StoreField(access), cnt, inc,
                                  load, control);
   return ChangeToUndefined(node, store);
 }
 
 
+Reduction JSIntrinsicLowering::ReduceIsMinusZero(Node* node) {
+  Node* value = NodeProperties::GetValueInput(node, 0);
+  Node* effect = NodeProperties::GetEffectInput(node);
+
+  Node* double_lo =
+      graph()->NewNode(machine()->Float64ExtractLowWord32(), value);
+  Node* check1 = graph()->NewNode(machine()->Word32Equal(), double_lo,
+                                  jsgraph()->ZeroConstant());
+
+  Node* double_hi =
+      graph()->NewNode(machine()->Float64ExtractHighWord32(), value);
+  Node* check2 = graph()->NewNode(
+      machine()->Word32Equal(), double_hi,
+      jsgraph()->Int32Constant(static_cast<int32_t>(0x80000000)));
+
+  NodeProperties::ReplaceWithValue(node, node, effect);
+
+  Node* and_result = graph()->NewNode(machine()->Word32And(), check1, check2);
+
+  node->set_op(machine()->Word32Equal());

[Benedikt Meurer, 2015/05/08 12:17:07]

How about

 return Change(node, machine()->Word32Equal(), and_result,
jsgraph()->Int32Constant(1))

here?

[danno, 2015/05/08 15:28:01]

Done.

+  node->ReplaceInput(0, and_result);
+  node->ReplaceInput(1, jsgraph()->OneConstant());
+  node->TrimInputCount(2);
+  return Changed(node);
+}
+
+
 Reduction JSIntrinsicLowering::ReduceIsInstanceType(
     Node* node, InstanceType instance_type) {
   // if (%_IsSmi(value)) {
   //   return false;
   // } else {
   //   return %_GetInstanceType(%_GetMap(value)) == instance_type;
   // }
   MachineType const type = static_cast<MachineType>(kTypeBool | kRepTagged);
 
   Node* value = NodeProperties::GetValueInput(node, 0);
@@ skipping 208 matching lines @@
   // Replace all effect uses of {node} with the effect dependency.
   NodeProperties::ReplaceWithValue(node, node);
   // Remove the inputs corresponding to context, effect and control.
   NodeProperties::RemoveNonValueInputs(node);
   // Finally update the operator to the new one.
   node->set_op(op);
   return Changed(node);
 }
 
 
+Reduction JSIntrinsicLowering::ReduceFixedArraySet(Node* node) {
+  Node* base = node->InputAt(0);
+  Node* index = node->InputAt(1);
+  Node* value = node->InputAt(2);
+  Node* effect = NodeProperties::GetEffectInput(node);
+  Node* control = NodeProperties::GetControlInput(node);
+  Node* store = (graph()->NewNode(
+      simplified()->StoreElement(AccessBuilder::ForFixedArrayElement()), base,
+      index, value, effect, control));
+  NodeProperties::ReplaceWithValue(node, value, store);
+  return Changed(store);
+}
+
+
+Reduction JSIntrinsicLowering::ReduceGetTypeFeedbackVector(Node* node) {
+  Node* func = node->InputAt(0);
+  Node* effect = NodeProperties::GetEffectInput(node);
+  Node* control = NodeProperties::GetControlInput(node);
+  FieldAccess access = AccessBuilder::ForSharedFunctionInfo();
+  Node* load =
+      graph()->NewNode(simplified()->LoadField(access), func, effect, control);
+  access = AccessBuilder::ForTypeFeedbackVector();
+  return Change(node, simplified()->LoadField(access), load, load, control);
+}
+
+
 Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,
                                       Node* b, Node* c) {
   node->set_op(op);
   node->ReplaceInput(0, a);
   node->ReplaceInput(1, b);
   node->ReplaceInput(2, c);
   node->TrimInputCount(3);
   NodeProperties::ReplaceWithValue(node, node, node);
   return Changed(node);
 }
 
 
+Reduction JSIntrinsicLowering::Change(Node* node, const Operator* op, Node* a,

[Benedikt Meurer, 2015/05/08 12:17:07]

We don't need this helper?

[danno, 2015/05/08 15:28:01]

Done.

+                                      Node* b, Node* c, Node* d, Node* e) {
+  node->set_op(op);
+  node->ReplaceInput(0, a);
+  node->ReplaceInput(1, b);
+  node->ReplaceInput(2, c);
+  node->ReplaceInput(3, d);
+  node->ReplaceInput(4, e);
+  node->TrimInputCount(5);
+  NodeProperties::ReplaceWithValue(node, node, node);
+  return Changed(node);
+}
+
+
 Reduction JSIntrinsicLowering::ChangeToUndefined(Node* node, Node* effect) {
   NodeProperties::ReplaceWithValue(node, jsgraph()->UndefinedConstant(),
                                    effect);
   return Changed(node);
 }
 
 
 Graph* JSIntrinsicLowering::graph() const { return jsgraph()->graph(); }
 
 
 CommonOperatorBuilder* JSIntrinsicLowering::common() const {
   return jsgraph()->common();
 }
 
 
 MachineOperatorBuilder* JSIntrinsicLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8