[intrinsic] Drop the %_ValueOf intrinsic.

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"
 #include "src/ic/stub-cache.h"
 
@@ skipping 1221 matching lines @@
   {
     // The {value} is a Smi, convert it to a String.
     Callable callable = CodeFactory::NumberToString(isolate());
     var_value.Bind(CallStub(callable, context, value));
     Goto(&if_valueisstring);
   }
   Bind(&if_valueisstring);
   return var_value.value();
 }
 
+Node* CodeStubAssembler::ToThisValue(Node* context, Node* value,
+                                     PrimitiveType primitive_type,
+                                     char const* method_name) {
+  // We might need to loop once due to JSValue unboxing.
+  Variable var_value(this, MachineRepresentation::kTagged);
+  Label loop(this, &var_value), done_loop(this),
+      done_throw(this, Label::kDeferred);
+  var_value.Bind(value);
+  Goto(&loop);
+  Bind(&loop);
+  {
+    // Load the current {value}.
+    value = var_value.value();
+
+    // Check if the {value} is a Smi or a HeapObject.
+    GotoIf(WordIsSmi(value), (primitive_type == PrimitiveType::kNumber)
+                                 ? &done_loop
+                                 : &done_throw);
+
+    // Load the mape of the {value}.
+    Node* value_map = LoadMap(value);
+
+    // Load the instance type of the {value}.
+    Node* value_instance_type = LoadMapInstanceType(value_map);
+
+    // Check if {value} is a JSValue.
+    Label if_valueisvalue(this, Label::kDeferred), if_valueisnotvalue(this);
+    Branch(Word32Equal(value_instance_type, Int32Constant(JS_VALUE_TYPE)),
+           &if_valueisvalue, &if_valueisnotvalue);
+
+    Bind(&if_valueisvalue);
+    {
+      // Load the actual value from the {value}.
+      var_value.Bind(LoadObjectField(value, JSValue::kValueOffset));
+      Goto(&loop);
+    }
+
+    Bind(&if_valueisnotvalue);
+    {
+      switch (primitive_type) {
+        case PrimitiveType::kBoolean:
+          GotoIf(WordEqual(value_map, BooleanMapConstant()), &done_loop);
+          break;
+        case PrimitiveType::kNumber:
+          GotoIf(
+              Word32Equal(value_instance_type, Int32Constant(HEAP_NUMBER_TYPE)),
+              &done_loop);
+          break;
+        case PrimitiveType::kString:
+          GotoIf(Int32LessThan(value_instance_type,
+                               Int32Constant(FIRST_NONSTRING_TYPE)),
+                 &done_loop);
+          break;
+        case PrimitiveType::kSymbol:
+          GotoIf(Word32Equal(value_instance_type, Int32Constant(SYMBOL_TYPE)),
+                 &done_loop);
+          break;
+      }
+      Goto(&done_throw);
+    }
+  }
+
+  Bind(&done_throw);
+  {
+    // The {value} is not a compatible receiver for this method.
+    CallRuntime(Runtime::kThrowNotGeneric, context,
+                HeapConstant(factory()->NewStringFromAsciiChecked(method_name,
+                                                                  TENURED)));
+    Goto(&done_loop);  // Never reached.
+  }
+
+  Bind(&done_loop);
+  return var_value.value();
+}
+
 Node* CodeStubAssembler::StringCharCodeAt(Node* string, Node* index) {
   // Translate the {index} into a Word.
   index = SmiToWord(index);
 
   // We may need to loop in case of cons or sliced strings.
   Variable var_index(this, MachineType::PointerRepresentation());
   Variable var_result(this, MachineRepresentation::kWord32);
   Variable var_string(this, MachineRepresentation::kTagged);
   Variable* loop_vars[] = {&var_index, &var_string};
   Label done_loop(this, &var_result), loop(this, 2, loop_vars);
@@ skipping 1528 matching lines @@
   }
   Bind(&miss);
   {
     TailCallRuntime(Runtime::kLoadGlobalIC_Miss, p->context, p->slot,
                     p->vector);
   }
 }
 
 }  // namespace internal
 }  // namespace v8