[es6] Perform the IsConstructor test in GetSuperConstructor.

src/code-stub-assembler.cc

 // Copyright 2016 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/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 
 namespace v8 {
 namespace internal {
@@ skipping 2862 matching lines @@
                         Int32Constant(0));
 }
 
 Node* CodeStubAssembler::IsCallableMap(Node* map) {
   CSA_ASSERT(this, IsMap(map));
   return Word32NotEqual(
       Word32And(LoadMapBitField(map), Int32Constant(1 << Map::kIsCallable)),
       Int32Constant(0));
 }
 
+Node* CodeStubAssembler::IsConstructorMap(Node* map) {
+  CSA_ASSERT(this, IsMap(map));
+  return Word32NotEqual(
+      Word32And(LoadMapBitField(map), Int32Constant(1 << Map::kIsConstructor)),
+      Int32Constant(0));
+}
+
 Node* CodeStubAssembler::IsSpecialReceiverInstanceType(Node* instance_type) {
   STATIC_ASSERT(JS_GLOBAL_OBJECT_TYPE <= LAST_SPECIAL_RECEIVER_TYPE);
   return Int32LessThanOrEqual(instance_type,
                               Int32Constant(LAST_SPECIAL_RECEIVER_TYPE));
 }
 
 Node* CodeStubAssembler::IsStringInstanceType(Node* instance_type) {
   STATIC_ASSERT(INTERNALIZED_STRING_TYPE == FIRST_TYPE);
   return Int32LessThan(instance_type, Int32Constant(FIRST_NONSTRING_TYPE));
 }
@@ skipping 2394 matching lines @@
   Node* callable_map = LoadMap(callable);
 
   // Goto runtime if {callable} is not a JSFunction.
   Node* callable_instance_type = LoadMapInstanceType(callable_map);
   GotoUnless(
       Word32Equal(callable_instance_type, Int32Constant(JS_FUNCTION_TYPE)),
       &return_runtime);
 
   // Goto runtime if {callable} is not a constructor or has
   // a non-instance "prototype".
-  Node* callable_bitfield = LoadMapBitField(callable_map);
-  GotoUnless(
-      Word32Equal(Word32And(callable_bitfield,
-                            Int32Constant((1 << Map::kHasNonInstancePrototype) |
-                                          (1 << Map::kIsConstructor))),
-                  Int32Constant(1 << Map::kIsConstructor)),
-      &return_runtime);
+  GotoUnless(IsConstructorMap(callable_map), &return_runtime);

[Benedikt Meurer, 2016/12/08 18:42:24]

This is not correct, as the original code also tests for non-instance
prototypes. Please don't change this code *(it's also unrelated to your CL).

[Henrique Ferreiro, 2016/12/09 13:24:28]

Sorry, I should have double-checked. Anyway, is it not ok to do small
refactorings when introducing helper functions or so?

[Benedikt Meurer, 2016/12/09 18:30:28]

Better do a separate CL for those. Unrelated changes are confusing, esp. when
things go wrong later (i.e. Chrome is crashing) and we cannot figure out why
something was changed.

 
   // Get the "prototype" (or initial map) of the {callable}.
   Node* callable_prototype =
       LoadObjectField(callable, JSFunction::kPrototypeOrInitialMapOffset);
   {
     Variable var_callable_prototype(this, MachineRepresentation::kTagged);
     Label callable_prototype_valid(this);
     var_callable_prototype.Bind(callable_prototype);
 
     // Resolve the "prototype" if the {callable} has an initial map.  Afterwards
@@ skipping 2497 matching lines @@
     result_var.Bind(HeapConstant(isolate()->factory()->type##_string())); \
     Goto(&return_result);                                                 \
   }
   SIMD128_TYPES(SIMD128_BIND_RETURN)
 #undef SIMD128_BIND_RETURN
 
   Bind(&return_result);
   return result_var.value();
 }
 
+Node* CodeStubAssembler::GetSuperConstructor(Node* active_function,
+                                             Node* context) {
+  Label is_not_object(this, Label::kDeferred),
+      is_not_constructor(this, Label::kDeferred), out(this);
+  Variable result(this, MachineRepresentation::kTagged);
+
+  Node* map = LoadMap(active_function);
+  Node* prototype = LoadMapPrototype(map);
+  GotoIf(TaggedIsSmi(active_function), &is_not_object);
+
+  Node* prototype_map = LoadMap(prototype);
+  GotoUnless(IsConstructorMap(prototype_map), &is_not_constructor);
+
+  result.Bind(prototype);
+  Goto(&out);
+
+  Bind(&is_not_object);
+  {
+    CallRuntime(Runtime::kThrowTypeError, context,
+                SmiConstant(MessageTemplate::kMethodCalledOnWrongObject),
+                HeapConstant(factory()->NewStringFromStaticChars("super")));
+    result.Bind(UndefinedConstant());  // Never reached.
+    Goto(&out);
+  }
+
+  Bind(&is_not_constructor);
+  {
+    CallRuntime(Runtime::kThrowNotSuperConstructor, context, prototype,
+                active_function);
+    result.Bind(UndefinedConstant());  // Never reached.
+    Goto(&out);
+  }
+
+  Bind(&out);
+  return result.value();
+}
+
 Node* CodeStubAssembler::InstanceOf(Node* object, Node* callable,
                                     Node* context) {
   Label return_runtime(this, Label::kDeferred), end(this);
   Variable result(this, MachineRepresentation::kTagged);
 
   // Check if no one installed @@hasInstance somewhere.
   GotoUnless(
       WordEqual(LoadObjectField(LoadRoot(Heap::kHasInstanceProtectorRootIndex),
                                 PropertyCell::kValueOffset),
                 SmiConstant(Smi::FromInt(Isolate::kProtectorValid))),
@@ skipping 391 matching lines @@
 
 Node* CodeStubAssembler::IsDebugActive() {
   Node* is_debug_active = Load(
       MachineType::Uint8(),
       ExternalConstant(ExternalReference::debug_is_active_address(isolate())));
   return WordNotEqual(is_debug_active, Int32Constant(0));
 }
 
 }  // namespace internal
 }  // namespace v8