[Interpreter] Add ClassOf intrinsic.

src/interpreter/interpreter-intrinsics.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/interpreter/interpreter-intrinsics.h"
 
 #include "src/code-factory.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 85 matching lines @@
   {
     __ Abort(BailoutReason::kUnexpectedFunctionIDForInvokeIntrinsic);
     result.Bind(__ UndefinedConstant());
     __ Goto(&end);
   }
 
   __ Bind(&end);
   return result.value();
 }
 
-Node* IntrinsicsHelper::CompareInstanceType(Node* map, int type,
+Node* IntrinsicsHelper::CompareInstanceType(Node* object, int type,
                                             InstanceTypeCompareMode mode) {
   InterpreterAssembler::Variable return_value(assembler_,
                                               MachineRepresentation::kTagged);
-  Node* instance_type = __ LoadInstanceType(map);
+  Node* instance_type = __ LoadInstanceType(object);
 
   InterpreterAssembler::Label if_true(assembler_), if_false(assembler_),
       end(assembler_);
   if (mode == kInstanceTypeEqual) {
     return __ Word32Equal(instance_type, __ Int32Constant(type));
   } else {
     DCHECK(mode == kInstanceTypeGreaterThanOrEqual);
     return __ Int32GreaterThanOrEqual(instance_type, __ Int32Constant(type));
   }
 }
@@ skipping 212 matching lines @@
   __ GotoUnless(condition, &done);
 
   // If the object is a value type, return the value field.
   return_value.Bind(__ LoadObjectField(object, JSValue::kValueOffset));
   __ Goto(&done);
 
   __ Bind(&done);
   return return_value.value();
 }
 
+Node* IntrinsicsHelper::ClassOf(Node* args_reg, Node* arg_count,
+                                Node* context) {
+  InterpreterAssembler::Variable return_value(assembler_,
+                                              MachineRepresentation::kTagged);
+  InterpreterAssembler::Label done(assembler_), null(assembler_),
+      function(assembler_), non_function_constructor(assembler_);
+
+  Node* object = __ LoadRegister(args_reg);
+
+  // If the object is not a JSReceiver, we return null.
+  __ GotoIf(__ WordIsSmi(object), &null);
+  STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE);
+  Node* is_js_receiver = CompareInstanceType(object, FIRST_JS_RECEIVER_TYPE,
+                                             kInstanceTypeGreaterThanOrEqual);
+  __ GotoUnless(is_js_receiver, &null);
+
+  // Return 'Function' for JSFunction and JSBoundFunction objects.
+  Node* is_function = CompareInstanceType(object, FIRST_FUNCTION_TYPE,
+                                          kInstanceTypeGreaterThanOrEqual);
+  STATIC_ASSERT(LAST_FUNCTION_TYPE == LAST_TYPE);
+  __ GotoIf(is_function, &function);
+
+  // Check if the constructor in the map is a JS function.
+  Node* constructor = __ LoadMapConstructor(__ LoadMap(object));
+  Node* constructor_is_js_function =
+      CompareInstanceType(constructor, JS_FUNCTION_TYPE, kInstanceTypeEqual);
+  __ GotoUnless(constructor_is_js_function, &non_function_constructor);
+
+  // Grab the instance class name from the constructor function.
+  Node* shared =
+      __ LoadObjectField(constructor, JSFunction::kSharedFunctionInfoOffset);
+  return_value.Bind(
+      __ LoadObjectField(shared, SharedFunctionInfo::kInstanceClassNameOffset));
+  __ Goto(&done);
+
+  // Non-JS objects have class null.
+  __ Bind(&null);
+  {
+    return_value.Bind(__ LoadRoot(Heap::kNullValueRootIndex));
+    __ Goto(&done);
+  }
+
+  // Functions have class 'Function'.
+  __ Bind(&function);
+  {
+    return_value.Bind(__ LoadRoot(Heap::kFunction_stringRootIndex));
+    __ Goto(&done);
+  }
+
+  // Objects with a non-function constructor have class 'Object'.
+  __ Bind(&non_function_constructor);
+  {
+    return_value.Bind(__ LoadRoot(Heap::kObject_stringRootIndex));
+    __ Goto(&done);
+  }
+
+  __ Bind(&done);
+  return return_value.value();
+}
+
 void IntrinsicsHelper::AbortIfArgCountMismatch(int expected, Node* actual) {
   InterpreterAssembler::Label match(assembler_);
   Node* comparison = __ Word32Equal(actual, __ Int32Constant(expected));
   __ GotoIf(comparison, &match);
   __ Abort(kWrongArgumentCountForInvokeIntrinsic);
   __ Goto(&match);
   __ Bind(&match);
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8