[Interpreter] TurboFan implementation of intrinsics.

src/interpreter/interpreter-intrinsics.cc

Index: src/interpreter/interpreter-intrinsics.cc
diff --git a/src/interpreter/interpreter-intrinsics.cc b/src/interpreter/interpreter-intrinsics.cc
new file mode 100644
index 0000000000000000000000000000000000000000..68a037945c2e1c74e9b41c1e0e0cc8e102b5c22d
--- /dev/null
+++ b/src/interpreter/interpreter-intrinsics.cc
@@ -0,0 +1,142 @@
+// 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/interpreter/interpreter-intrinsics.h"
+
+namespace v8 {
+namespace internal {
+namespace interpreter {
+
+using compiler::Node;
+
+IntrinsicsHelper::IntrinsicsHelper(InterpreterAssembler* assembler)
+    : assembler_(assembler) {}
+
+bool IntrinsicsHelper::IsSupported(Runtime::FunctionId function_id) {
+  switch (function_id) {
+#define SUPPORTED(name, lower_case) case Runtime::kInline##name:
+    INTRINSICS_LIST(SUPPORTED)
+    return true;
+#undef SUPPORTED
+    default:
+      return false;
+  }
+}
+
+Node* IntrinsicsHelper::DispatchIntrinsic(Node* function_id, Node* context,

[rmcilroy, 2016/03/05 04:21:46]

nit - I would prefer InvokeIntrinsic, dispatch is a bit overloaded in the
interpreter.

[epertoso, 2016/03/07 11:26:35]

Done.

+                                          Node* first_arg_reg,
+                                          Node* arg_count) {
+  InterpreterAssembler::Label abort(assembler_), end(assembler_);
+  InterpreterAssembler::Variable result(assembler_,
+                                        MachineRepresentation::kTagged);
+
+#define MAKE_LABEL(name, lower_case) \
+  InterpreterAssembler::Label lower_case(assembler_);
+  INTRINSICS_LIST(MAKE_LABEL)
+#undef MAKE_LABEL
+
+#define LABEL_POINTER(name, lower_case) &lower_case,
+  InterpreterAssembler::Label* labels[] = {INTRINSICS_LIST(LABEL_POINTER)};
+#undef LABEL_POINTER
+
+#define CASE(name, lower_case) static_cast<int32_t>(Runtime::kInline##name),
+  int32_t cases[] = {INTRINSICS_LIST(CASE)};
+#undef CASE
+
+  assembler_->Switch(function_id, &abort, cases, labels, arraysize(cases));
+#define HANDLE_CASE(name, lower_case) \
+  assembler_->Bind(&lower_case);      \
+  result.Bind(name(first_arg_reg));   \

[rmcilroy, 2016/03/05 04:21:46]

Could you add a check (guarded with FLAG_debug_code) which checks the number of
arguments is correct? You probably want to have a arg count in the
INTRINSICS_LIST for future intrinsics which take different numbers of arguments
in order to pull out the correct arguments here to pass to the intrinsic
generation functions.

[epertoso, 2016/03/07 11:26:35]

Done.

+  assembler_->Goto(&end);
+  INTRINSICS_LIST(HANDLE_CASE)
+#undef HANDLE_CASE
+
+  assembler_->Bind(&abort);
+  assembler_->Abort(BailoutReason::kUnexpectedFunctionIDForInvokeIntrinsic);
+
+  assembler_->Bind(&end);
+  return result.value();
+}
+
+Node* IntrinsicsHelper::IsJSReceiver(Node* input) {
+  InterpreterAssembler::Variable return_value(assembler_,
+                                              MachineRepresentation::kTagged);
+
+  InterpreterAssembler::Label if_smi(assembler_), if_notsmi(assembler_),
+      end(assembler_);
+  Node* arg = assembler_->LoadRegister(input);

[rmcilroy, 2016/03/05 04:21:46]

Nit - How about #defining __ to assembler_-> like interpreter.cc to make this
code a bit less cluttered?

[epertoso, 2016/03/07 11:26:35]

Done.

+
+  assembler_->Branch(assembler_->WordIsSmi(arg), &if_smi, &if_notsmi);

[rmcilroy, 2016/03/05 04:21:46]

/s/if_notsmi/if_not_smi/

[epertoso, 2016/03/07 11:26:35]

Done.

+  assembler_->Bind(&if_smi);
+  return_value.Bind(assembler_->BooleanConstant(false));
+  assembler_->Goto(&end);
+
+  assembler_->Bind(&if_notsmi);
+  {
+    STATIC_ASSERT(LAST_TYPE == LAST_JS_RECEIVER_TYPE);
+    Node* map = assembler_->LoadObjectField(arg, HeapObject::kMapOffset);
+    Node* instance_type = assembler_->Load(
+        MachineType::Uint8(), map,
+        assembler_->IntPtrConstant(Map::kInstanceTypeOffset - kHeapObjectTag));
+
+    InterpreterAssembler::Label if_isreceiver(assembler_),
+        if_isnotreceiver(assembler_);

[rmcilroy, 2016/03/05 04:21:46]

nit - if_receiever and if_not_receiver 

[epertoso, 2016/03/07 11:26:35]

Done.

+    assembler_->Branch(
+        assembler_->Int32GreaterThanOrEqual(
+            instance_type, assembler_->Int32Constant(FIRST_JS_RECEIVER_TYPE)),
+        &if_isreceiver, &if_isnotreceiver);
+
+    assembler_->Bind(&if_isreceiver);
+    return_value.Bind(assembler_->BooleanConstant(true));
+    assembler_->Goto(&end);
+
+    assembler_->Bind(&if_isnotreceiver);
+    return_value.Bind(assembler_->BooleanConstant(false));
+    assembler_->Goto(&end);
+  }
+
+  assembler_->Bind(&end);
+  return return_value.value();
+}
+
+Node* IntrinsicsHelper::IsArray(Node* input) {
+  InterpreterAssembler::Label if_smi(assembler_), if_notsmi(assembler_),
+      end(assembler_);
+  Node* arg = assembler_->LoadRegister(input);
+  assembler_->Branch(assembler_->WordIsSmi(arg), &if_smi, &if_notsmi);

[rmcilroy, 2016/03/05 04:21:46]

ditto

[epertoso, 2016/03/07 11:26:35]

Done.

+  InterpreterAssembler::Variable return_value(assembler_,
+                                              MachineRepresentation::kTagged);
+  assembler_->Bind(&if_smi);
+  return_value.Bind(assembler_->BooleanConstant(false));
+  assembler_->Goto(&end);
+
+  assembler_->Bind(&if_notsmi);
+  {
+    Node* map = assembler_->LoadObjectField(arg, HeapObject::kMapOffset);
+    Node* instance_type = assembler_->Load(
+        MachineType::Uint8(), map,
+        assembler_->IntPtrConstant(Map::kInstanceTypeOffset - kHeapObjectTag));
+
+    InterpreterAssembler::Label if_isarray(assembler_),
+        if_isnotarray(assembler_);
+    assembler_->Branch(
+        assembler_->Word32Equal(instance_type,
+                                assembler_->Int32Constant(JS_ARRAY_TYPE)),

[rmcilroy, 2016/03/05 04:21:46]

Could we share the code between IsJSReciever and IsArray in a common helper? The
only difference seems to be the instance type to compare.

[epertoso, 2016/03/07 11:26:35]

Done. 

The difference is also the type of comparison ('==' vs '>='), but I've extracted
a common helper anyway as other intrinsic we might implement will benefit from
it.

+        &if_isarray, &if_isnotarray);
+
+    assembler_->Bind(&if_isarray);
+    return_value.Bind(assembler_->BooleanConstant(true));
+    assembler_->Goto(&end);
+
+    assembler_->Bind(&if_isnotarray);
+    return_value.Bind(assembler_->BooleanConstant(false));
+    assembler_->Goto(&end);
+  }
+  assembler_->Bind(&end);
+  return return_value.value();
+}
+
+}  // namespace interpreter
+}  // namespace internal
+}  // namespace v8