[builtins] Pass NotNullOrUndefined to ToPrimitive calls.

src/builtins/builtins-conversion.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/builtins/builtins-utils.h"
 #include "src/builtins/builtins.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 
 namespace v8 {
 namespace internal {
 
 Handle<Code> Builtins::NonPrimitiveToPrimitive(ToPrimitiveHint hint) {
   switch (hint) {
     case ToPrimitiveHint::kDefault:
       return NonPrimitiveToPrimitive_Default();
     case ToPrimitiveHint::kNumber:
       return NonPrimitiveToPrimitive_Number();
     case ToPrimitiveHint::kString:
       return NonPrimitiveToPrimitive_String();
   }
   UNREACHABLE();
   return Handle<Code>::null();
 }
 
 namespace {
+
 // ES6 section 7.1.1 ToPrimitive ( input [ , PreferredType ] )
 void Generate_NonPrimitiveToPrimitive(CodeStubAssembler* assembler,
                                       ToPrimitiveHint hint) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef TypeConversionDescriptor Descriptor;
 
   Node* input = assembler->Parameter(Descriptor::kArgument);
   Node* context = assembler->Parameter(Descriptor::kContext);
 
   // Lookup the @@toPrimitive property on the {input}.
   Callable callable = CodeFactory::GetProperty(assembler->isolate());
   Node* to_primitive_symbol =
       assembler->HeapConstant(assembler->factory()->to_primitive_symbol());
   Node* exotic_to_prim =
       assembler->CallStub(callable, context, input, to_primitive_symbol);
 
   // Check if {exotic_to_prim} is neither null nor undefined.
   Label ordinary_to_primitive(assembler);
   assembler->GotoIf(
       assembler->WordEqual(exotic_to_prim, assembler->NullConstant()),
       &ordinary_to_primitive);
   assembler->GotoIf(
       assembler->WordEqual(exotic_to_prim, assembler->UndefinedConstant()),
       &ordinary_to_primitive);
   {
     // Invoke the {exotic_to_prim} method on the {input} with a string
     // representation of the {hint}.
-    Callable callable = CodeFactory::Call(assembler->isolate());
+    Callable callable = CodeFactory::Call(
+        assembler->isolate(), ConvertReceiverMode::kNotNullOrUndefined);
     Node* hint_string = assembler->HeapConstant(
         assembler->factory()->ToPrimitiveHintString(hint));
     Node* result = assembler->CallJS(callable, context, exotic_to_prim, input,
                                      hint_string);
 
     // Verify that the {result} is actually a primitive.
     Label if_resultisprimitive(assembler),
         if_resultisnotprimitive(assembler, Label::kDeferred);
     assembler->GotoIf(assembler->TaggedIsSmi(result), &if_resultisprimitive);
     Node* result_instance_type = assembler->LoadInstanceType(result);
@@ skipping 20 matching lines @@
   // Convert using the OrdinaryToPrimitive algorithm instead.
   assembler->Bind(&ordinary_to_primitive);
   {
     Callable callable = CodeFactory::OrdinaryToPrimitive(
         assembler->isolate(), (hint == ToPrimitiveHint::kString)
                                   ? OrdinaryToPrimitiveHint::kString
                                   : OrdinaryToPrimitiveHint::kNumber);
     assembler->TailCallStub(callable, context, input);
   }
 }
-}  // anonymous namespace
+
+}  // namespace
 
 void Builtins::Generate_NonPrimitiveToPrimitive_Default(
     compiler::CodeAssemblerState* state) {
   CodeStubAssembler assembler(state);
   Generate_NonPrimitiveToPrimitive(&assembler, ToPrimitiveHint::kDefault);
 }
 
 void Builtins::Generate_NonPrimitiveToPrimitive_Number(
     compiler::CodeAssemblerState* state) {
   CodeStubAssembler assembler(state);
@@ skipping 107 matching lines @@
     case OrdinaryToPrimitiveHint::kNumber:
       return OrdinaryToPrimitive_Number();
     case OrdinaryToPrimitiveHint::kString:
       return OrdinaryToPrimitive_String();
   }
   UNREACHABLE();
   return Handle<Code>::null();
 }
 
 namespace {
+
 // 7.1.1.1 OrdinaryToPrimitive ( O, hint )
 void Generate_OrdinaryToPrimitive(CodeStubAssembler* assembler,
                                   OrdinaryToPrimitiveHint hint) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Variable Variable;
   typedef TypeConversionDescriptor Descriptor;
 
   Node* input = assembler->Parameter(Descriptor::kArgument);
   Node* context = assembler->Parameter(Descriptor::kContext);
@@ skipping 22 matching lines @@
     Label if_methodiscallable(assembler),
         if_methodisnotcallable(assembler, Label::kDeferred);
     assembler->GotoIf(assembler->TaggedIsSmi(method), &if_methodisnotcallable);
     Node* method_map = assembler->LoadMap(method);
     assembler->Branch(assembler->IsCallableMap(method_map),
                       &if_methodiscallable, &if_methodisnotcallable);
 
     assembler->Bind(&if_methodiscallable);
     {
       // Call the {method} on the {input}.
-      Callable callable = CodeFactory::Call(assembler->isolate());
+      Callable callable = CodeFactory::Call(
+          assembler->isolate(), ConvertReceiverMode::kNotNullOrUndefined);
       Node* result = assembler->CallJS(callable, context, method, input);
       var_result.Bind(result);
 
       // Return the {result} if it is a primitive.
       assembler->GotoIf(assembler->TaggedIsSmi(result), &return_result);
       Node* result_instance_type = assembler->LoadInstanceType(result);
       STATIC_ASSERT(FIRST_PRIMITIVE_TYPE == FIRST_TYPE);
       assembler->GotoIf(assembler->Int32LessThanOrEqual(
                             result_instance_type,
                             assembler->Int32Constant(LAST_PRIMITIVE_TYPE)),
                         &return_result);
     }
 
     // Just continue with the next {name} if the {method} is not callable.
     assembler->Goto(&if_methodisnotcallable);
     assembler->Bind(&if_methodisnotcallable);
   }
 
   assembler->TailCallRuntime(Runtime::kThrowCannotConvertToPrimitive, context);
 
   assembler->Bind(&return_result);
   assembler->Return(var_result.value());
 }
-}  // anonymous namespace
+
+}  // namespace
 
 void Builtins::Generate_OrdinaryToPrimitive_Number(
     compiler::CodeAssemblerState* state) {
   CodeStubAssembler assembler(state);
   Generate_OrdinaryToPrimitive(&assembler, OrdinaryToPrimitiveHint::kNumber);
 }
 
 void Builtins::Generate_OrdinaryToPrimitive_String(
     compiler::CodeAssemblerState* state) {
   CodeStubAssembler assembler(state);
@@ skipping 191 matching lines @@
   CodeStubAssembler assembler(state);
 
   Node* object = assembler.Parameter(Descriptor::kObject);
   Node* context = assembler.Parameter(Descriptor::kContext);
 
   assembler.Return(assembler.Typeof(object, context));
 }
 
 }  // namespace internal
 }  // namespace v8