Revert of Remove property loads from js builtins objects from runtime.

src/api.cc

 // Copyright 2012 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/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 2257 matching lines @@
   ENTER_V8(isolate);
   EscapableHandleScope scope(reinterpret_cast<Isolate*>(isolate));
   auto message = i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
   i::Handle<i::Object> stackFramesObj(message->stack_frames(), isolate);
   if (!stackFramesObj->IsJSArray()) return v8::Local<v8::StackTrace>();
   auto stackTrace = i::Handle<i::JSArray>::cast(stackFramesObj);
   return scope.Escape(Utils::StackTraceToLocal(stackTrace));
 }
 
 
+MUST_USE_RESULT static i::MaybeHandle<i::Object> CallV8HeapFunction(
+    i::Isolate* isolate, const char* name, i::Handle<i::Object> recv, int argc,
+    i::Handle<i::Object> argv[]) {
+  i::Handle<i::Object> object_fun =
+      i::Object::GetProperty(
+          isolate, isolate->js_builtins_object(), name).ToHandleChecked();
+  i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(object_fun);
+  return i::Execution::Call(isolate, fun, recv, argc, argv);
+}
+
+
+MUST_USE_RESULT static i::MaybeHandle<i::Object> CallV8HeapFunction(
+    i::Isolate* isolate, const char* name, i::Handle<i::Object> data) {
+  i::Handle<i::Object> argv[] = { data };
+  return CallV8HeapFunction(isolate, name, isolate->js_builtins_object(),
+                            arraysize(argv), argv);
+}
+
+
 Maybe<int> Message::GetLineNumber(Local<Context> context) const {
   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetLineNumber()", int);
-  i::Handle<i::JSFunction> fun = isolate->message_get_line_number();
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  i::Handle<i::Object> args[] = {Utils::OpenHandle(this)};
   i::Handle<i::Object> result;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
-           .ToHandle(&result);
+      !CallV8HeapFunction(isolate, "$messageGetLineNumber",
+                          Utils::OpenHandle(this)).ToHandle(&result);
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int);
   return Just(static_cast<int>(result->Number()));
 }
 
 
 int Message::GetLineNumber() const {
   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
   return GetLineNumber(context).FromMaybe(0);
 }
 
 
 int Message::GetStartPosition() const {
   auto self = Utils::OpenHandle(this);
   return self->start_position();
 }
 
 
 int Message::GetEndPosition() const {
   auto self = Utils::OpenHandle(this);
   return self->end_position();
 }
 
 
 Maybe<int> Message::GetStartColumn(Local<Context> context) const {
   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetStartColumn()",
                                   int);
-  i::Handle<i::JSFunction> fun = isolate->message_get_column_number();
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  i::Handle<i::Object> args[] = {Utils::OpenHandle(this)};
-  i::Handle<i::Object> result;
+  auto self = Utils::OpenHandle(this);
+  i::Handle<i::Object> start_col_obj;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
-           .ToHandle(&result);
+      !CallV8HeapFunction(isolate, "$messageGetPositionInLine", self)
+           .ToHandle(&start_col_obj);
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int);
-  return Just(static_cast<int>(result->Number()));
+  return Just(static_cast<int>(start_col_obj->Number()));
 }
 
 
 int Message::GetStartColumn() const {
   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
   const int default_value = kNoColumnInfo;
   return GetStartColumn(context).FromMaybe(default_value);
 }
 
 
 Maybe<int> Message::GetEndColumn(Local<Context> context) const {
+  PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetEndColumn()", int);
   auto self = Utils::OpenHandle(this);
-  PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Message::GetEndColumn()", int);
-  i::Handle<i::JSFunction> fun = isolate->message_get_column_number();
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  i::Handle<i::Object> args[] = {self};
-  i::Handle<i::Object> result;
+  i::Handle<i::Object> start_col_obj;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
-           .ToHandle(&result);
+      !CallV8HeapFunction(isolate, "$messageGetPositionInLine", self)
+           .ToHandle(&start_col_obj);
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(int);
   int start = self->start_position();
   int end = self->end_position();
-  return Just(static_cast<int>(result->Number()) + (end - start));
+  return Just(static_cast<int>(start_col_obj->Number()) + (end - start));
 }
 
 
 int Message::GetEndColumn() const {
   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
   const int default_value = kNoColumnInfo;
   return GetEndColumn(context).FromMaybe(default_value);
 }
 
 
@@ skipping 13 matching lines @@
   ENTER_V8(isolate);
   auto self = Utils::OpenHandle(this);
   auto script = i::Handle<i::JSValue>::cast(
       i::Handle<i::Object>(self->script(), isolate));
   return i::Script::cast(script->value())->origin_options().IsOpaque();
 }
 
 
 MaybeLocal<String> Message::GetSourceLine(Local<Context> context) const {
   PREPARE_FOR_EXECUTION(context, "v8::Message::GetSourceLine()", String);
-  i::Handle<i::JSFunction> fun = isolate->message_get_source_line();
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  i::Handle<i::Object> args[] = {Utils::OpenHandle(this)};
   i::Handle<i::Object> result;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
-           .ToHandle(&result);
+      !CallV8HeapFunction(isolate, "$messageGetSourceLine",
+                          Utils::OpenHandle(this)).ToHandle(&result);
   RETURN_ON_FAILED_EXECUTION(String);
   Local<String> str;
   if (result->IsString()) {
     str = Utils::ToLocal(i::Handle<i::String>::cast(result));
   }
   RETURN_ESCAPED(str);
 }
 
 
 Local<String> Message::GetSourceLine() const {
@@ skipping 969 matching lines @@
   auto self = Utils::OpenHandle(this);
   auto other = Utils::OpenHandle(*that);
   if (self->IsSmi() && other->IsSmi()) {
     return Just(self->Number() == other->Number());
   }
   if (self->IsJSObject() && other->IsJSObject()) {
     return Just(*self == *other);
   }
   PREPARE_FOR_EXECUTION_PRIMITIVE(context, "v8::Value::Equals()", bool);
   i::Handle<i::Object> args[] = { other };
-  i::Handle<i::JSFunction> fun(i::JSFunction::cast(
-      isolate->js_builtins_object()->javascript_builtin(i::Builtins::EQUALS)));
   i::Handle<i::Object> result;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, self, arraysize(args), args)
+      !CallV8HeapFunction(isolate, "EQUALS", self, arraysize(args), args)
            .ToHandle(&result);
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
   return Just(*result == i::Smi::FromInt(i::EQUAL));
 }
 
 
 bool Value::Equals(Local<Value> that) const {
   auto self = Utils::OpenHandle(this);
   auto other = Utils::OpenHandle(*that);
   if (self->IsSmi() && other->IsSmi()) {
@@ skipping 109 matching lines @@
     return Nothing<bool>();
   }
 
   i::Handle<i::FixedArray> desc = isolate->factory()->NewFixedArray(3);
   desc->set(0, isolate->heap()->ToBoolean(!(attributes & v8::ReadOnly)));
   desc->set(1, isolate->heap()->ToBoolean(!(attributes & v8::DontEnum)));
   desc->set(2, isolate->heap()->ToBoolean(!(attributes & v8::DontDelete)));
   i::Handle<i::JSArray> desc_array =
       isolate->factory()->NewJSArrayWithElements(desc, i::FAST_ELEMENTS, 3);
   i::Handle<i::Object> args[] = {self, key_obj, value_obj, desc_array};
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
-  i::Handle<i::JSFunction> fun = isolate->object_define_own_property();
   i::Handle<i::Object> result;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
-           .ToHandle(&result);
+      !CallV8HeapFunction(isolate, "$objectDefineOwnProperty",
+                          isolate->factory()->undefined_value(),
+                          arraysize(args), args).ToHandle(&result);
   RETURN_ON_FAILED_EXECUTION_PRIMITIVE(bool);
   return Just(result->BooleanValue());
 }
 
 
 MUST_USE_RESULT
 static i::MaybeHandle<i::Object> DefineObjectProperty(
     i::Handle<i::JSObject> js_object, i::Handle<i::Object> key,
     i::Handle<i::Object> value, PropertyAttributes attrs) {
   i::Isolate* isolate = js_object->GetIsolate();
@@ skipping 111 matching lines @@
 }
 
 
 MaybeLocal<Value> v8::Object::GetOwnPropertyDescriptor(Local<Context> context,
                                                        Local<String> key) {
   PREPARE_FOR_EXECUTION(context, "v8::Object::GetOwnPropertyDescriptor()",
                         Value);
   auto obj = Utils::OpenHandle(this);
   auto key_name = Utils::OpenHandle(*key);
   i::Handle<i::Object> args[] = { obj, key_name };
-  i::Handle<i::JSFunction> fun = isolate->object_get_own_property_descriptor();
-  i::Handle<i::Object> undefined = isolate->factory()->undefined_value();
   i::Handle<i::Object> result;
   has_pending_exception =
-      !i::Execution::Call(isolate, fun, undefined, arraysize(args), args)
-           .ToHandle(&result);
+      !CallV8HeapFunction(isolate, "$objectGetOwnPropertyDescriptor",
+                          isolate->factory()->undefined_value(),
+                          arraysize(args), args).ToHandle(&result);
   RETURN_ON_FAILED_EXECUTION(Value);
   RETURN_ESCAPED(Utils::ToLocal(result));
 }
 
 
 Local<Value> v8::Object::GetOwnPropertyDescriptor(Local<String> key) {
   auto context = ContextFromHeapObject(Utils::OpenHandle(this));
   RETURN_TO_LOCAL_UNCHECKED(GetOwnPropertyDescriptor(context, key), Value);
 }
 
@@ skipping 4748 matching lines @@
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 }  // namespace internal
 }  // namespace v8