"src/uri.js",
"src/third_party/fdlibm/fdlibm.js",
"src/math.js",
- "src/apinatives.js",
"src/date.js",
"src/regexp.js",
"src/arraybuffer.js",
"src/allocation-tracker.h",
"src/api.cc",
"src/api.h",
+ "src/api-natives.cc",
+ "src/api-natives.h",
"src/arguments.cc",
"src/arguments.h",
"src/assembler.cc",
"src/rewriter.h",
"src/runtime-profiler.cc",
"src/runtime-profiler.h",
- "src/runtime/runtime-api.cc",
"src/runtime/runtime-array.cc",
"src/runtime/runtime-classes.cc",
"src/runtime/runtime-collections.cc",
static const int kJSObjectHeaderSize = 3 * kApiPointerSize;
static const int kFixedArrayHeaderSize = 2 * kApiPointerSize;
static const int kContextHeaderSize = 2 * kApiPointerSize;
- static const int kContextEmbedderDataIndex = 76;
+ static const int kContextEmbedderDataIndex = 74;
static const int kFullStringRepresentationMask = 0x07;
static const int kStringEncodingMask = 0x4;
static const int kExternalTwoByteRepresentationTag = 0x02;
--- /dev/null
+// 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/api-natives.h"
+#include "src/isolate-inl.h"
+
+namespace v8 {
+namespace internal {
+
+namespace {
+
+// Transform getter or setter into something DefineAccessor can handle.
+Handle<Object> InstantiateAccessorComponent(Isolate* isolate,
+ Handle<Object> component) {
+ if (component->IsUndefined()) return isolate->factory()->undefined_value();
+ Handle<FunctionTemplateInfo> info =
+ Handle<FunctionTemplateInfo>::cast(component);
+ // TODO(dcarney): instantiate directly.
+ return Utils::OpenHandle(*Utils::ToLocal(info)->GetFunction());
+}
+
+
+MaybeHandle<Object> DefineApiAccessorProperty(
+ Isolate* isolate, Handle<JSObject> object, Handle<Name> name,
+ Handle<Object> getter, Handle<Object> setter, Smi* attribute) {
+ DCHECK(PropertyDetails::AttributesField::is_valid(
+ static_cast<PropertyAttributes>(attribute->value())));
+ RETURN_ON_EXCEPTION(
+ isolate, JSObject::DefineAccessor(
+ object, name, InstantiateAccessorComponent(isolate, getter),
+ InstantiateAccessorComponent(isolate, setter),
+ static_cast<PropertyAttributes>(attribute->value())),
+ Object);
+ return object;
+}
+
+
+MaybeHandle<Object> AddPropertyForTemplate(Isolate* isolate,
+ Handle<JSObject> object,
+ Handle<Object> key,
+ Handle<Object> value,
+ Smi* unchecked_attributes) {
+ DCHECK((unchecked_attributes->value() &
+ ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
+ // Compute attributes.
+ PropertyAttributes attributes =
+ static_cast<PropertyAttributes>(unchecked_attributes->value());
+
+#ifdef DEBUG
+ bool duplicate;
+ if (key->IsName()) {
+ LookupIterator it(object, Handle<Name>::cast(key),
+ LookupIterator::OWN_SKIP_INTERCEPTOR);
+ Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
+ DCHECK(maybe.has_value);
+ duplicate = it.IsFound();
+ } else {
+ uint32_t index = 0;
+ key->ToArrayIndex(&index);
+ Maybe<bool> maybe = JSReceiver::HasOwnElement(object, index);
+ if (!maybe.has_value) return MaybeHandle<Object>();
+ duplicate = maybe.value;
+ }
+ if (duplicate) {
+ Handle<Object> args[1] = {key};
+ THROW_NEW_ERROR(isolate, NewTypeError("duplicate_template_property",
+ HandleVector(args, 1)),
+ Object);
+ }
+#endif
+
+ RETURN_ON_EXCEPTION(
+ isolate, Runtime::DefineObjectProperty(object, key, value, attributes),
+ Object);
+ return object;
+}
+
+
+void DisableAccessChecks(Isolate* isolate, Handle<JSObject> object) {
+ Handle<Map> old_map(object->map());
+ // Copy map so it won't interfere constructor's initial map.
+ Handle<Map> new_map = Map::Copy(old_map, "DisableAccessChecks");
+ new_map->set_is_access_check_needed(false);
+ JSObject::MigrateToMap(Handle<JSObject>::cast(object), new_map);
+}
+
+
+void EnableAccessChecks(Isolate* isolate, Handle<JSObject> object) {
+ Handle<Map> old_map(object->map());
+ // Copy map so it won't interfere constructor's initial map.
+ Handle<Map> new_map = Map::Copy(old_map, "EnableAccessChecks");
+ new_map->set_is_access_check_needed(true);
+ JSObject::MigrateToMap(object, new_map);
+}
+
+
+MaybeHandle<JSObject> InstantiateObject(Isolate* isolate,
+ Handle<ObjectTemplateInfo> data);
+
+
+MaybeHandle<JSFunction> InstantiateFunction(Isolate* isolate,
+ Handle<FunctionTemplateInfo> data,
+ Handle<Name> name = Handle<Name>());
+
+
+MaybeHandle<Object> Instantiate(Isolate* isolate, Handle<Object> data,
+ Handle<Name> name = Handle<Name>()) {
+ if (data->IsFunctionTemplateInfo()) {
+ return InstantiateFunction(isolate,
+ Handle<FunctionTemplateInfo>::cast(data), name);
+ } else if (data->IsObjectTemplateInfo()) {
+ return InstantiateObject(isolate, Handle<ObjectTemplateInfo>::cast(data));
+ } else {
+ // TODO(dcarney): CHECK data is JSObject or Primitive.
+ return data;
+ }
+}
+
+
+class AccessCheckDisableScope {
+ public:
+ AccessCheckDisableScope(Isolate* isolate, Handle<JSObject> obj)
+ : isolate_(isolate),
+ disabled_(obj->map()->is_access_check_needed()),
+ obj_(obj) {
+ if (disabled_) {
+ DisableAccessChecks(isolate_, obj_);
+ }
+ }
+ ~AccessCheckDisableScope() {
+ if (disabled_) {
+ EnableAccessChecks(isolate_, obj_);
+ }
+ }
+
+ private:
+ Isolate* isolate_;
+ const bool disabled_;
+ Handle<JSObject> obj_;
+};
+
+
+MaybeHandle<JSObject> ConfigureInstance(Isolate* isolate, Handle<JSObject> obj,
+ Handle<TemplateInfo> data) {
+ auto property_list = handle(data->property_list(), isolate);
+ if (property_list->IsUndefined()) return obj;
+ // TODO(dcarney): just use a FixedArray here.
+ NeanderArray properties(property_list);
+ if (properties.length() == 0) return obj;
+ HandleScope scope(isolate);
+ // Disable access checks while instantiating the object.
+ AccessCheckDisableScope access_check_scope(isolate, obj);
+ for (int i = 0; i < properties.length();) {
+ int length = Smi::cast(properties.get(i))->value();
+ if (length == 3) {
+ auto name = handle(Name::cast(properties.get(i + 1)), isolate);
+ auto prop_data = handle(properties.get(i + 2), isolate);
+ auto attributes = Smi::cast(properties.get(i + 3));
+ Handle<Object> value;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, value, Instantiate(isolate, prop_data, name), JSObject);
+ RETURN_ON_EXCEPTION(isolate, AddPropertyForTemplate(isolate, obj, name,
+ value, attributes),
+ JSObject);
+ } else {
+ DCHECK(length == 4 || length == 5);
+ // TODO(verwaest): The 5th value used to be access_control. Remove once
+ // the bindings are updated.
+ auto name = handle(Name::cast(properties.get(i + 1)), isolate);
+ auto getter = handle(properties.get(i + 2), isolate);
+ auto setter = handle(properties.get(i + 3), isolate);
+ auto attributes = Smi::cast(properties.get(i + 4));
+ RETURN_ON_EXCEPTION(isolate,
+ DefineApiAccessorProperty(isolate, obj, name, getter,
+ setter, attributes),
+ JSObject);
+ }
+ i += length + 1;
+ }
+ return obj;
+}
+
+
+MaybeHandle<JSObject> InstantiateObject(Isolate* isolate,
+ Handle<ObjectTemplateInfo> data) {
+ // Enter a new scope. Recursion could otherwise create a lot of handles.
+ HandleScope scope(isolate);
+ // Fast path.
+ Handle<JSObject> result;
+ auto info = Handle<ObjectTemplateInfo>::cast(data);
+ auto constructor = handle(info->constructor(), isolate);
+ Handle<JSFunction> cons;
+ if (constructor->IsUndefined()) {
+ cons = isolate->object_function();
+ } else {
+ auto cons_templ = Handle<FunctionTemplateInfo>::cast(constructor);
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, cons, InstantiateFunction(isolate, cons_templ), JSFunction);
+ }
+ auto object = isolate->factory()->NewJSObject(cons);
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, result, ConfigureInstance(isolate, object, info), JSFunction);
+ // TODO(dcarney): is this necessary?
+ JSObject::MigrateSlowToFast(result, 0, "ApiNatives::InstantiateObject");
+ return scope.CloseAndEscape(result);
+}
+
+
+void InstallInCache(Isolate* isolate, int serial_number,
+ Handle<JSFunction> function) {
+ auto cache = isolate->function_cache();
+ if (cache->length() <= serial_number) {
+ int new_size;
+ if (isolate->next_serial_number() < 50) {
+ new_size = 100;
+ } else {
+ new_size = 3 * isolate->next_serial_number() / 2;
+ }
+ cache = FixedArray::CopySize(cache, new_size);
+ isolate->native_context()->set_function_cache(*cache);
+ }
+ cache->set(serial_number, *function);
+}
+
+
+MaybeHandle<JSFunction> InstantiateFunction(Isolate* isolate,
+ Handle<FunctionTemplateInfo> data,
+ Handle<Name> name) {
+ int serial_number = Smi::cast(data->serial_number())->value();
+ // Probe cache.
+ if (!data->do_not_cache()) {
+ auto cache = isolate->function_cache();
+ // Fast case: see if the function has already been instantiated
+ if (serial_number < cache->length()) {
+ Handle<Object> element = FixedArray::get(cache, serial_number);
+ if (element->IsJSFunction()) {
+ return Handle<JSFunction>::cast(element);
+ }
+ }
+ }
+ // Enter a new scope. Recursion could otherwise create a lot of handles.
+ HandleScope scope(isolate);
+ Handle<JSObject> prototype;
+ if (!data->remove_prototype()) {
+ auto prototype_templ = handle(data->prototype_template(), isolate);
+ if (prototype_templ->IsUndefined()) {
+ prototype = isolate->factory()->NewJSObject(isolate->object_function());
+ } else {
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, prototype,
+ InstantiateObject(isolate,
+ Handle<ObjectTemplateInfo>::cast(prototype_templ)),
+ JSFunction);
+ }
+ auto parent = handle(data->parent_template(), isolate);
+ if (!parent->IsUndefined()) {
+ Handle<JSFunction> parent_instance;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, parent_instance,
+ InstantiateFunction(isolate,
+ Handle<FunctionTemplateInfo>::cast(parent)),
+ JSFunction);
+ // TODO(dcarney): decide what to do here.
+ Handle<Object> parent_prototype;
+ ASSIGN_RETURN_ON_EXCEPTION(
+ isolate, parent_prototype,
+ JSObject::GetProperty(parent_instance,
+ isolate->factory()->prototype_string()),
+ JSFunction);
+ RETURN_ON_EXCEPTION(
+ isolate, JSObject::SetPrototype(prototype, parent_prototype, false),
+ JSFunction);
+ }
+ }
+ auto function = ApiNatives::CreateApiFunction(
+ isolate, data, prototype, ApiNatives::JavaScriptObjectType);
+ if (!name.is_null() && name->IsString()) {
+ function->shared()->set_name(*name);
+ }
+ if (!data->do_not_cache()) {
+ // Cache the function to limit recursion.
+ InstallInCache(isolate, serial_number, function);
+ }
+ auto result = ConfigureInstance(isolate, function, data);
+ if (result.is_null()) {
+ // uncache on error.
+ if (!data->do_not_cache()) {
+ auto cache = isolate->function_cache();
+ cache->set(serial_number, isolate->heap()->undefined_value());
+ }
+ return MaybeHandle<JSFunction>();
+ }
+ return scope.CloseAndEscape(function);
+}
+
+
+class InvokeScope {
+ public:
+ explicit InvokeScope(Isolate* isolate)
+ : isolate_(isolate), save_context_(isolate) {}
+ ~InvokeScope() {
+ bool has_exception = isolate_->has_pending_exception();
+ if (has_exception) {
+ isolate_->ReportPendingMessages();
+ } else {
+ isolate_->clear_pending_message();
+ }
+ }
+
+ private:
+ Isolate* isolate_;
+ SaveContext save_context_;
+};
+
+} // namespace
+
+
+MaybeHandle<JSFunction> ApiNatives::InstantiateFunction(
+ Handle<FunctionTemplateInfo> data) {
+ Isolate* isolate = data->GetIsolate();
+ InvokeScope invoke_scope(isolate);
+ return ::v8::internal::InstantiateFunction(isolate, data);
+}
+
+
+MaybeHandle<JSObject> ApiNatives::InstantiateObject(
+ Handle<ObjectTemplateInfo> data) {
+ Isolate* isolate = data->GetIsolate();
+ InvokeScope invoke_scope(isolate);
+ return ::v8::internal::InstantiateObject(isolate, data);
+}
+
+
+MaybeHandle<FunctionTemplateInfo> ApiNatives::ConfigureInstance(
+ Isolate* isolate, Handle<FunctionTemplateInfo> desc,
+ Handle<JSObject> instance) {
+ // Configure the instance by adding the properties specified by the
+ // instance template.
+ if (desc->instance_template()->IsUndefined()) return desc;
+ InvokeScope invoke_scope(isolate);
+ Handle<ObjectTemplateInfo> instance_template(
+ ObjectTemplateInfo::cast(desc->instance_template()), isolate);
+ RETURN_ON_EXCEPTION(isolate, ::v8::internal::ConfigureInstance(
+ isolate, instance, instance_template),
+ FunctionTemplateInfo);
+ return desc;
+}
+
+
+Handle<JSFunction> ApiNatives::CreateApiFunction(
+ Isolate* isolate, Handle<FunctionTemplateInfo> obj,
+ Handle<Object> prototype, ApiInstanceType instance_type) {
+ Handle<Code> code = isolate->builtins()->HandleApiCall();
+ Handle<Code> construct_stub = isolate->builtins()->JSConstructStubApi();
+
+ obj->set_instantiated(true);
+ Handle<JSFunction> result;
+ if (obj->remove_prototype()) {
+ result = isolate->factory()->NewFunctionWithoutPrototype(
+ isolate->factory()->empty_string(), code);
+ } else {
+ int internal_field_count = 0;
+ if (!obj->instance_template()->IsUndefined()) {
+ Handle<ObjectTemplateInfo> instance_template = Handle<ObjectTemplateInfo>(
+ ObjectTemplateInfo::cast(obj->instance_template()));
+ internal_field_count =
+ Smi::cast(instance_template->internal_field_count())->value();
+ }
+
+ // TODO(svenpanne) Kill ApiInstanceType and refactor things by generalizing
+ // JSObject::GetHeaderSize.
+ int instance_size = kPointerSize * internal_field_count;
+ InstanceType type;
+ switch (instance_type) {
+ case JavaScriptObjectType:
+ type = JS_OBJECT_TYPE;
+ instance_size += JSObject::kHeaderSize;
+ break;
+ case GlobalObjectType:
+ type = JS_GLOBAL_OBJECT_TYPE;
+ instance_size += JSGlobalObject::kSize;
+ break;
+ case GlobalProxyType:
+ type = JS_GLOBAL_PROXY_TYPE;
+ instance_size += JSGlobalProxy::kSize;
+ break;
+ default:
+ UNREACHABLE();
+ type = JS_OBJECT_TYPE; // Keep the compiler happy.
+ break;
+ }
+
+ result = isolate->factory()->NewFunction(
+ isolate->factory()->empty_string(), code, prototype, type,
+ instance_size, obj->read_only_prototype(), true);
+ }
+
+ result->shared()->set_length(obj->length());
+ Handle<Object> class_name(obj->class_name(), isolate);
+ if (class_name->IsString()) {
+ result->shared()->set_instance_class_name(*class_name);
+ result->shared()->set_name(*class_name);
+ }
+ result->shared()->set_function_data(*obj);
+ result->shared()->set_construct_stub(*construct_stub);
+ result->shared()->DontAdaptArguments();
+
+ if (obj->remove_prototype()) {
+ DCHECK(result->shared()->IsApiFunction());
+ DCHECK(!result->has_initial_map());
+ DCHECK(!result->has_prototype());
+ return result;
+ }
+
+#ifdef DEBUG
+ LookupIterator it(handle(JSObject::cast(result->prototype())),
+ isolate->factory()->constructor_string(),
+ LookupIterator::OWN_SKIP_INTERCEPTOR);
+ MaybeHandle<Object> maybe_prop = Object::GetProperty(&it);
+ DCHECK(it.IsFound());
+ DCHECK(maybe_prop.ToHandleChecked().is_identical_to(result));
+#endif
+
+ // Down from here is only valid for API functions that can be used as a
+ // constructor (don't set the "remove prototype" flag).
+
+ Handle<Map> map(result->initial_map());
+
+ // Mark as undetectable if needed.
+ if (obj->undetectable()) {
+ map->set_is_undetectable();
+ }
+
+ // Mark as hidden for the __proto__ accessor if needed.
+ if (obj->hidden_prototype()) {
+ map->set_is_hidden_prototype();
+ }
+
+ // Mark as needs_access_check if needed.
+ if (obj->needs_access_check()) {
+ map->set_is_access_check_needed(true);
+ }
+
+ // Set interceptor information in the map.
+ if (!obj->named_property_handler()->IsUndefined()) {
+ map->set_has_named_interceptor();
+ }
+ if (!obj->indexed_property_handler()->IsUndefined()) {
+ map->set_has_indexed_interceptor();
+ }
+
+ // Set instance call-as-function information in the map.
+ if (!obj->instance_call_handler()->IsUndefined()) {
+ map->set_has_instance_call_handler();
+ }
+
+ // Recursively copy parent instance templates' accessors,
+ // 'data' may be modified.
+ int max_number_of_additional_properties = 0;
+ int max_number_of_static_properties = 0;
+ FunctionTemplateInfo* info = *obj;
+ while (true) {
+ if (!info->instance_template()->IsUndefined()) {
+ Object* props = ObjectTemplateInfo::cast(info->instance_template())
+ ->property_accessors();
+ if (!props->IsUndefined()) {
+ Handle<Object> props_handle(props, isolate);
+ NeanderArray props_array(props_handle);
+ max_number_of_additional_properties += props_array.length();
+ }
+ }
+ if (!info->property_accessors()->IsUndefined()) {
+ Object* props = info->property_accessors();
+ if (!props->IsUndefined()) {
+ Handle<Object> props_handle(props, isolate);
+ NeanderArray props_array(props_handle);
+ max_number_of_static_properties += props_array.length();
+ }
+ }
+ Object* parent = info->parent_template();
+ if (parent->IsUndefined()) break;
+ info = FunctionTemplateInfo::cast(parent);
+ }
+
+ Map::EnsureDescriptorSlack(map, max_number_of_additional_properties);
+
+ // Use a temporary FixedArray to acculumate static accessors
+ int valid_descriptors = 0;
+ Handle<FixedArray> array;
+ if (max_number_of_static_properties > 0) {
+ array = isolate->factory()->NewFixedArray(max_number_of_static_properties);
+ }
+
+ while (true) {
+ // Install instance descriptors
+ if (!obj->instance_template()->IsUndefined()) {
+ Handle<ObjectTemplateInfo> instance = Handle<ObjectTemplateInfo>(
+ ObjectTemplateInfo::cast(obj->instance_template()), isolate);
+ Handle<Object> props =
+ Handle<Object>(instance->property_accessors(), isolate);
+ if (!props->IsUndefined()) {
+ Map::AppendCallbackDescriptors(map, props);
+ }
+ }
+ // Accumulate static accessors
+ if (!obj->property_accessors()->IsUndefined()) {
+ Handle<Object> props = Handle<Object>(obj->property_accessors(), isolate);
+ valid_descriptors =
+ AccessorInfo::AppendUnique(props, array, valid_descriptors);
+ }
+ // Climb parent chain
+ Handle<Object> parent = Handle<Object>(obj->parent_template(), isolate);
+ if (parent->IsUndefined()) break;
+ obj = Handle<FunctionTemplateInfo>::cast(parent);
+ }
+
+ // Install accumulated static accessors
+ for (int i = 0; i < valid_descriptors; i++) {
+ Handle<AccessorInfo> accessor(AccessorInfo::cast(array->get(i)));
+ JSObject::SetAccessor(result, accessor).Assert();
+ }
+
+ DCHECK(result->shared()->IsApiFunction());
+ return result;
+}
+
+} // namespace internal
+} // namespace v8
--- /dev/null
+// 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.
+
+#ifndef V8_API_NATIVES_H_
+#define V8_API_NATIVES_H_
+
+#include "src/handles.h"
+
+namespace v8 {
+namespace internal {
+
+class ApiNatives {
+ public:
+ MUST_USE_RESULT static MaybeHandle<JSFunction> InstantiateFunction(
+ Handle<FunctionTemplateInfo> data);
+ MUST_USE_RESULT static MaybeHandle<JSObject> InstantiateObject(
+ Handle<ObjectTemplateInfo> data);
+ MUST_USE_RESULT static MaybeHandle<FunctionTemplateInfo> ConfigureInstance(
+ Isolate* isolate, Handle<FunctionTemplateInfo> instance,
+ Handle<JSObject> data);
+
+ enum ApiInstanceType {
+ JavaScriptObjectType,
+ GlobalObjectType,
+ GlobalProxyType
+ };
+
+ static Handle<JSFunction> CreateApiFunction(Isolate* isolate,
+ Handle<FunctionTemplateInfo> obj,
+ Handle<Object> prototype,
+ ApiInstanceType instance_type);
+};
+
+} // namespace internal
+} // namespace v8
+
+#endif
#include "include/v8-debug.h"
#include "include/v8-profiler.h"
#include "include/v8-testing.h"
+#include "src/api-natives.h"
#include "src/assert-scope.h"
#include "src/background-parsing-task.h"
#include "src/base/functional.h"
ENTER_V8(isolate);
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> obj;
- has_pending_exception = !i::Execution::InstantiateObject(info).ToHandle(&obj);
+ has_pending_exception =
+ !i::ApiNatives::InstantiateObject(info).ToHandle(&obj);
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>());
return Utils::ToLocal(i::Handle<i::JSObject>::cast(obj));
}
EXCEPTION_PREAMBLE(isolate);
i::Handle<i::Object> obj;
has_pending_exception =
- !i::Execution::InstantiateFunction(info).ToHandle(&obj);
+ !i::ApiNatives::InstantiateFunction(info).ToHandle(&obj);
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Function>());
return Utils::ToLocal(i::Handle<i::JSFunction>::cast(obj));
}
+++ /dev/null
-// Copyright 2006-2008 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.
-
-"use strict";
-
-// This file contains infrastructure used by the API. See
-// v8natives.js for an explanation of these files are processed and
-// loaded.
-
-
-function CreateDate(time) {
- var date = new $Date();
- date.setTime(time);
- return date;
-}
-
-
-var kApiFunctionCache = new InternalArray();
-var functionCache = kApiFunctionCache;
-
-
-function Instantiate(data, name) {
- if (!%IsTemplate(data)) return data;
- var tag = %GetTemplateField(data, kApiTagOffset);
- switch (tag) {
- case kFunctionTag:
- return InstantiateFunction(data, name);
- case kNewObjectTag:
- var Constructor = %GetTemplateField(data, kApiConstructorOffset);
- // Note: Do not directly use a function template as a condition, our
- // internal ToBoolean doesn't handle that!
- var result;
- if (typeof Constructor === 'undefined') {
- result = {};
- ConfigureTemplateInstance(result, data);
- } else {
- // ConfigureTemplateInstance is implicitly called before calling the API
- // constructor in HandleApiCall.
- result = new (Instantiate(Constructor))();
- result = %ToFastProperties(result);
- }
- return result;
- default:
- throw 'Unknown API tag <' + tag + '>';
- }
-}
-
-
-function InstantiateFunction(data, name) {
- // We need a reference to kApiFunctionCache in the stack frame
- // if we need to bail out from a stack overflow.
- var cache = kApiFunctionCache;
- var serialNumber = %GetTemplateField(data, kApiSerialNumberOffset);
- var isFunctionCached =
- (serialNumber in cache) && (cache[serialNumber] != kUninitialized);
- if (!isFunctionCached) {
- try {
- var flags = %GetTemplateField(data, kApiFlagOffset);
- var prototype;
- if (!(flags & (1 << kRemovePrototypeBit))) {
- var template = %GetTemplateField(data, kApiPrototypeTemplateOffset);
- prototype = typeof template === 'undefined'
- ? {} : Instantiate(template);
-
- var parent = %GetTemplateField(data, kApiParentTemplateOffset);
- // Note: Do not directly use a function template as a condition, our
- // internal ToBoolean doesn't handle that!
- if (typeof parent !== 'undefined') {
- var parent_fun = Instantiate(parent);
- %InternalSetPrototype(prototype, parent_fun.prototype);
- }
- }
- var fun = %CreateApiFunction(data, prototype);
- if (IS_STRING(name)) %FunctionSetName(fun, name);
- var doNotCache = flags & (1 << kDoNotCacheBit);
- if (!doNotCache) cache[serialNumber] = fun;
- ConfigureTemplateInstance(fun, data);
- if (doNotCache) return fun;
- } catch (e) {
- cache[serialNumber] = kUninitialized;
- throw e;
- }
- }
- return cache[serialNumber];
-}
-
-
-function ConfigureTemplateInstance(obj, data) {
- var properties = %GetTemplateField(data, kApiPropertyListOffset);
- if (!properties) return;
- // Disable access checks while instantiating the object.
- var requires_access_checks = %DisableAccessChecks(obj);
- try {
- for (var i = 1; i < properties[0];) {
- var length = properties[i];
- if (length == 3) {
- var name = properties[i + 1];
- var prop_data = properties[i + 2];
- var attributes = properties[i + 3];
- var value = Instantiate(prop_data, name);
- %AddPropertyForTemplate(obj, name, value, attributes);
- } else if (length == 4 || length == 5) {
- // TODO(verwaest): The 5th value used to be access_control. Remove once
- // the bindings are updated.
- var name = properties[i + 1];
- var getter = properties[i + 2];
- var setter = properties[i + 3];
- var attribute = properties[i + 4];
- %DefineApiAccessorProperty(obj, name, getter, setter, attribute);
- } else {
- throw "Bad properties array";
- }
- i += length + 1;
- }
- } finally {
- if (requires_access_checks) %EnableAccessChecks(obj);
- }
-}
#include "src/bootstrapper.h"
#include "src/accessors.h"
+#include "src/api-natives.h"
#include "src/code-stubs.h"
#include "src/extensions/externalize-string-extension.h"
#include "src/extensions/free-buffer-extension.h"
} else {
Handle<FunctionTemplateInfo> js_global_object_constructor(
FunctionTemplateInfo::cast(js_global_object_template->constructor()));
- js_global_object_function =
- factory()->CreateApiFunction(js_global_object_constructor,
- factory()->the_hole_value(),
- factory()->GlobalObjectType);
+ js_global_object_function = ApiNatives::CreateApiFunction(
+ isolate(), js_global_object_constructor, factory()->the_hole_value(),
+ ApiNatives::GlobalObjectType);
}
js_global_object_function->initial_map()->set_is_hidden_prototype();
v8::Utils::OpenHandle(*global_proxy_template);
Handle<FunctionTemplateInfo> global_constructor(
FunctionTemplateInfo::cast(data->constructor()));
- global_proxy_function =
- factory()->CreateApiFunction(global_constructor,
- factory()->the_hole_value(),
- factory()->GlobalProxyType);
+ global_proxy_function = ApiNatives::CreateApiFunction(
+ isolate(), global_constructor, factory()->the_hole_value(),
+ ApiNatives::GlobalProxyType);
}
Handle<String> global_name = factory()->global_string();
INSTALL_NATIVE(JSFunction, "ToLength", to_length_fun);
INSTALL_NATIVE(JSFunction, "GlobalEval", global_eval_fun);
- INSTALL_NATIVE(JSFunction, "Instantiate", instantiate_fun);
- INSTALL_NATIVE(JSFunction, "ConfigureTemplateInstance",
- configure_instance_fun);
INSTALL_NATIVE(JSFunction, "GetStackTraceLine", get_stack_trace_line_fun);
- INSTALL_NATIVE(JSObject, "functionCache", function_cache);
INSTALL_NATIVE(JSFunction, "ToCompletePropertyDescriptor",
to_complete_property_descriptor);
InstallNativeFunctions();
+ native_context()->set_function_cache(heap()->empty_fixed_array());
+
// Store the map for the string prototype after the natives has been compiled
// and the String function has been set up.
Handle<JSFunction> string_function(native_context()->string_function());
->IsTemplateFor(object->map()));;
MaybeHandle<JSObject> maybe_obj =
- Execution::InstantiateObject(object_template);
+ ApiNatives::InstantiateObject(object_template);
Handle<JSObject> obj;
if (!maybe_obj.ToHandle(&obj)) {
DCHECK(isolate()->has_pending_exception());
#include "src/v8.h"
#include "src/api.h"
+#include "src/api-natives.h"
#include "src/arguments.h"
#include "src/base/once.h"
#include "src/bootstrapper.h"
if (is_construct) {
ASSIGN_RETURN_ON_EXCEPTION(
isolate, fun_data,
- isolate->factory()->ConfigureInstance(
- fun_data, Handle<JSObject>::cast(args.receiver())),
+ ApiNatives::ConfigureInstance(isolate, fun_data,
+ Handle<JSObject>::cast(args.receiver())),
Object);
}
V(TO_INT32_FUN_INDEX, JSFunction, to_int32_fun) \
V(TO_LENGTH_FUN_INDEX, JSFunction, to_length_fun) \
V(GLOBAL_EVAL_FUN_INDEX, JSFunction, global_eval_fun) \
- V(INSTANTIATE_FUN_INDEX, JSFunction, instantiate_fun) \
- V(CONFIGURE_INSTANCE_FUN_INDEX, JSFunction, configure_instance_fun) \
V(ARRAY_BUFFER_FUN_INDEX, JSFunction, array_buffer_fun) \
V(UINT8_ARRAY_FUN_INDEX, JSFunction, uint8_array_fun) \
V(INT8_ARRAY_FUN_INDEX, JSFunction, int8_array_fun) \
V(MAKE_MESSAGE_FUN_INDEX, JSFunction, make_message_fun) \
V(GET_STACK_TRACE_LINE_INDEX, JSFunction, get_stack_trace_line_fun) \
V(CONFIGURE_GLOBAL_INDEX, JSFunction, configure_global_fun) \
- V(FUNCTION_CACHE_INDEX, JSObject, function_cache) \
+ V(FUNCTION_CACHE_INDEX, FixedArray, function_cache) \
V(JSFUNCTION_RESULT_CACHES_INDEX, FixedArray, jsfunction_result_caches) \
V(NORMALIZED_MAP_CACHE_INDEX, Object, normalized_map_cache) \
V(RUNTIME_CONTEXT_INDEX, Context, runtime_context) \
TO_INT32_FUN_INDEX,
TO_BOOLEAN_FUN_INDEX,
GLOBAL_EVAL_FUN_INDEX,
- INSTANTIATE_FUN_INDEX,
- CONFIGURE_INSTANCE_FUN_INDEX,
ARRAY_BUFFER_FUN_INDEX,
UINT8_ARRAY_FUN_INDEX,
INT8_ARRAY_FUN_INDEX,
}
+function CreateDate(time) {
+ var date = new $Date();
+ date.setTime(time);
+ return date;
+}
+
// -------------------------------------------------------------------
function SetUpDate() {
}
-MaybeHandle<JSFunction> Execution::InstantiateFunction(
- Handle<FunctionTemplateInfo> data) {
- Isolate* isolate = data->GetIsolate();
- if (!data->do_not_cache()) {
- // Fast case: see if the function has already been instantiated
- int serial_number = Smi::cast(data->serial_number())->value();
- Handle<JSObject> cache(isolate->native_context()->function_cache());
- Handle<Object> elm =
- Object::GetElement(isolate, cache, serial_number).ToHandleChecked();
- if (elm->IsJSFunction()) return Handle<JSFunction>::cast(elm);
- }
- // The function has not yet been instantiated in this context; do it.
- Handle<Object> args[] = { data };
- Handle<Object> result;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, result,
- Call(isolate,
- isolate->instantiate_fun(),
- isolate->js_builtins_object(),
- arraysize(args),
- args),
- JSFunction);
- return Handle<JSFunction>::cast(result);
-}
-
-
-MaybeHandle<JSObject> Execution::InstantiateObject(
- Handle<ObjectTemplateInfo> data) {
- Isolate* isolate = data->GetIsolate();
- Handle<Object> result;
- if (data->property_list()->IsUndefined() &&
- !data->constructor()->IsUndefined()) {
- Handle<FunctionTemplateInfo> cons_template =
- Handle<FunctionTemplateInfo>(
- FunctionTemplateInfo::cast(data->constructor()));
- Handle<JSFunction> cons;
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, cons, InstantiateFunction(cons_template), JSObject);
- ASSIGN_RETURN_ON_EXCEPTION(isolate, result, New(cons, 0, NULL), JSObject);
- } else {
- Handle<Object> args[] = { data };
- ASSIGN_RETURN_ON_EXCEPTION(
- isolate, result,
- Call(isolate,
- isolate->instantiate_fun(),
- isolate->js_builtins_object(),
- arraysize(args),
- args),
- JSObject);
- }
- return Handle<JSObject>::cast(result);
-}
-
-
-MaybeHandle<Object> Execution::ConfigureInstance(
- Isolate* isolate,
- Handle<Object> instance,
- Handle<Object> instance_template) {
- Handle<Object> args[] = { instance, instance_template };
- return Execution::Call(isolate,
- isolate->configure_instance_fun(),
- isolate->js_builtins_object(),
- arraysize(args),
- args);
-}
-
-
Handle<String> Execution::GetStackTraceLine(Handle<Object> recv,
Handle<JSFunction> fun,
Handle<Object> pos,
static Handle<Object> CharAt(Handle<String> str, uint32_t index);
static Handle<Object> GetFunctionFor();
- MUST_USE_RESULT static MaybeHandle<JSFunction> InstantiateFunction(
- Handle<FunctionTemplateInfo> data);
- MUST_USE_RESULT static MaybeHandle<JSObject> InstantiateObject(
- Handle<ObjectTemplateInfo> data);
- MUST_USE_RESULT static MaybeHandle<Object> ConfigureInstance(
- Isolate* isolate, Handle<Object> instance, Handle<Object> data);
static Handle<String> GetStackTraceLine(Handle<Object> recv,
Handle<JSFunction> fun,
Handle<Object> pos,
}
-Handle<JSFunction> Factory::CreateApiFunction(
- Handle<FunctionTemplateInfo> obj,
- Handle<Object> prototype,
- ApiInstanceType instance_type) {
- Handle<Code> code = isolate()->builtins()->HandleApiCall();
- Handle<Code> construct_stub = isolate()->builtins()->JSConstructStubApi();
-
- obj->set_instantiated(true);
- Handle<JSFunction> result;
- if (obj->remove_prototype()) {
- result = NewFunctionWithoutPrototype(empty_string(), code);
- } else {
- int internal_field_count = 0;
- if (!obj->instance_template()->IsUndefined()) {
- Handle<ObjectTemplateInfo> instance_template =
- Handle<ObjectTemplateInfo>(
- ObjectTemplateInfo::cast(obj->instance_template()));
- internal_field_count =
- Smi::cast(instance_template->internal_field_count())->value();
- }
-
- // TODO(svenpanne) Kill ApiInstanceType and refactor things by generalizing
- // JSObject::GetHeaderSize.
- int instance_size = kPointerSize * internal_field_count;
- InstanceType type;
- switch (instance_type) {
- case JavaScriptObjectType:
- type = JS_OBJECT_TYPE;
- instance_size += JSObject::kHeaderSize;
- break;
- case GlobalObjectType:
- type = JS_GLOBAL_OBJECT_TYPE;
- instance_size += JSGlobalObject::kSize;
- break;
- case GlobalProxyType:
- type = JS_GLOBAL_PROXY_TYPE;
- instance_size += JSGlobalProxy::kSize;
- break;
- default:
- UNREACHABLE();
- type = JS_OBJECT_TYPE; // Keep the compiler happy.
- break;
- }
-
- result = NewFunction(empty_string(), code, prototype, type, instance_size,
- obj->read_only_prototype(), true);
- }
-
- result->shared()->set_length(obj->length());
- Handle<Object> class_name(obj->class_name(), isolate());
- if (class_name->IsString()) {
- result->shared()->set_instance_class_name(*class_name);
- result->shared()->set_name(*class_name);
- }
- result->shared()->set_function_data(*obj);
- result->shared()->set_construct_stub(*construct_stub);
- result->shared()->DontAdaptArguments();
-
- if (obj->remove_prototype()) {
- DCHECK(result->shared()->IsApiFunction());
- DCHECK(!result->has_initial_map());
- DCHECK(!result->has_prototype());
- return result;
- }
-
-#ifdef DEBUG
- LookupIterator it(handle(JSObject::cast(result->prototype())),
- constructor_string(), LookupIterator::OWN_SKIP_INTERCEPTOR);
- MaybeHandle<Object> maybe_prop = Object::GetProperty(&it);
- DCHECK(it.IsFound());
- DCHECK(maybe_prop.ToHandleChecked().is_identical_to(result));
-#endif
-
- // Down from here is only valid for API functions that can be used as a
- // constructor (don't set the "remove prototype" flag).
-
- Handle<Map> map(result->initial_map());
-
- // Mark as undetectable if needed.
- if (obj->undetectable()) {
- map->set_is_undetectable();
- }
-
- // Mark as hidden for the __proto__ accessor if needed.
- if (obj->hidden_prototype()) {
- map->set_is_hidden_prototype();
- }
-
- // Mark as needs_access_check if needed.
- if (obj->needs_access_check()) {
- map->set_is_access_check_needed(true);
- }
-
- // Set interceptor information in the map.
- if (!obj->named_property_handler()->IsUndefined()) {
- map->set_has_named_interceptor();
- }
- if (!obj->indexed_property_handler()->IsUndefined()) {
- map->set_has_indexed_interceptor();
- }
-
- // Set instance call-as-function information in the map.
- if (!obj->instance_call_handler()->IsUndefined()) {
- map->set_has_instance_call_handler();
- }
-
- // Recursively copy parent instance templates' accessors,
- // 'data' may be modified.
- int max_number_of_additional_properties = 0;
- int max_number_of_static_properties = 0;
- FunctionTemplateInfo* info = *obj;
- while (true) {
- if (!info->instance_template()->IsUndefined()) {
- Object* props =
- ObjectTemplateInfo::cast(
- info->instance_template())->property_accessors();
- if (!props->IsUndefined()) {
- Handle<Object> props_handle(props, isolate());
- NeanderArray props_array(props_handle);
- max_number_of_additional_properties += props_array.length();
- }
- }
- if (!info->property_accessors()->IsUndefined()) {
- Object* props = info->property_accessors();
- if (!props->IsUndefined()) {
- Handle<Object> props_handle(props, isolate());
- NeanderArray props_array(props_handle);
- max_number_of_static_properties += props_array.length();
- }
- }
- Object* parent = info->parent_template();
- if (parent->IsUndefined()) break;
- info = FunctionTemplateInfo::cast(parent);
- }
-
- Map::EnsureDescriptorSlack(map, max_number_of_additional_properties);
-
- // Use a temporary FixedArray to acculumate static accessors
- int valid_descriptors = 0;
- Handle<FixedArray> array;
- if (max_number_of_static_properties > 0) {
- array = NewFixedArray(max_number_of_static_properties);
- }
-
- while (true) {
- // Install instance descriptors
- if (!obj->instance_template()->IsUndefined()) {
- Handle<ObjectTemplateInfo> instance =
- Handle<ObjectTemplateInfo>(
- ObjectTemplateInfo::cast(obj->instance_template()), isolate());
- Handle<Object> props = Handle<Object>(instance->property_accessors(),
- isolate());
- if (!props->IsUndefined()) {
- Map::AppendCallbackDescriptors(map, props);
- }
- }
- // Accumulate static accessors
- if (!obj->property_accessors()->IsUndefined()) {
- Handle<Object> props = Handle<Object>(obj->property_accessors(),
- isolate());
- valid_descriptors =
- AccessorInfo::AppendUnique(props, array, valid_descriptors);
- }
- // Climb parent chain
- Handle<Object> parent = Handle<Object>(obj->parent_template(), isolate());
- if (parent->IsUndefined()) break;
- obj = Handle<FunctionTemplateInfo>::cast(parent);
- }
-
- // Install accumulated static accessors
- for (int i = 0; i < valid_descriptors; i++) {
- Handle<AccessorInfo> accessor(AccessorInfo::cast(array->get(i)));
- JSObject::SetAccessor(result, accessor).Assert();
- }
-
- DCHECK(result->shared()->IsApiFunction());
- return result;
-}
-
-
Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
int number_of_properties,
bool* is_result_from_cache) {
}
-MaybeHandle<FunctionTemplateInfo> Factory::ConfigureInstance(
- Handle<FunctionTemplateInfo> desc, Handle<JSObject> instance) {
- // Configure the instance by adding the properties specified by the
- // instance template.
- Handle<Object> instance_template(desc->instance_template(), isolate());
- if (!instance_template->IsUndefined()) {
- RETURN_ON_EXCEPTION(
- isolate(),
- Execution::ConfigureInstance(isolate(), instance, instance_template),
- FunctionTemplateInfo);
- }
- return desc;
-}
-
-
Handle<Object> Factory::GlobalConstantFor(Handle<String> name) {
if (String::Equals(name, undefined_string())) return undefined_value();
if (String::Equals(name, nan_string())) return nan_value();
return NumberToString(NewNumberFromUint(value));
}
- enum ApiInstanceType {
- JavaScriptObjectType,
- GlobalObjectType,
- GlobalProxyType
- };
-
- Handle<JSFunction> CreateApiFunction(
- Handle<FunctionTemplateInfo> data,
- Handle<Object> prototype,
- ApiInstanceType type = JavaScriptObjectType);
-
Handle<JSFunction> InstallMembers(Handle<JSFunction> function);
- // Installs interceptors on the instance. 'desc' is a function template,
- // and instance is an object instance created by the function of this
- // function template.
- MUST_USE_RESULT MaybeHandle<FunctionTemplateInfo> ConfigureInstance(
- Handle<FunctionTemplateInfo> desc, Handle<JSObject> instance);
-
#define ROOT_ACCESSOR(type, name, camel_name) \
inline Handle<type> name() { \
return Handle<type>(bit_cast<type**>( \
const GETTER = 0;
const SETTER = 1;
-# These definitions must match the index of the properties in objects.h.
-const kApiTagOffset = 0;
-const kApiPropertyListOffset = 1;
-const kApiSerialNumberOffset = 3;
-const kApiConstructorOffset = 3;
-const kApiPrototypeTemplateOffset = 5;
-const kApiParentTemplateOffset = 6;
-const kApiFlagOffset = 14;
-
const NO_HINT = 0;
const NUMBER_HINT = 1;
const STRING_HINT = 2;
-const kFunctionTag = 0;
-const kNewObjectTag = 1;
-
# For date.js.
const HoursPerDay = 24;
const MinutesPerHour = 60;
const msPerDay = 86400000;
const msPerMonth = 2592000000;
-# For apinatives.js
-const kUninitialized = -1;
-const kReadOnlyPrototypeBit = 3;
-const kRemovePrototypeBit = 4; # For FunctionTemplateInfo, matches objects.h
-const kDoNotCacheBit = 5; # For FunctionTemplateInfo, matches objects.h
-
# Note: kDayZeroInJulianDay = ToJulianDay(1970, 0, 1).
const kInvalidDate = 'Invalid Date';
const kDayZeroInJulianDay = 2440588;
+++ /dev/null
-// Copyright 2014 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/v8.h"
-
-#include "src/arguments.h"
-#include "src/bootstrapper.h"
-#include "src/runtime/runtime.h"
-#include "src/runtime/runtime-utils.h"
-
-namespace v8 {
-namespace internal {
-
-RUNTIME_FUNCTION(Runtime_CreateApiFunction) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_HANDLE_CHECKED(FunctionTemplateInfo, data, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, prototype, 1);
- return *isolate->factory()->CreateApiFunction(data, prototype);
-}
-
-
-RUNTIME_FUNCTION(Runtime_IsTemplate) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, arg, 0);
- bool result = arg->IsObjectTemplateInfo() || arg->IsFunctionTemplateInfo();
- return isolate->heap()->ToBoolean(result);
-}
-
-
-RUNTIME_FUNCTION(Runtime_GetTemplateField) {
- SealHandleScope shs(isolate);
- DCHECK(args.length() == 2);
- CONVERT_ARG_CHECKED(HeapObject, templ, 0);
- CONVERT_SMI_ARG_CHECKED(index, 1);
- int offset = index * kPointerSize + HeapObject::kHeaderSize;
- InstanceType type = templ->map()->instance_type();
- RUNTIME_ASSERT(type == FUNCTION_TEMPLATE_INFO_TYPE ||
- type == OBJECT_TEMPLATE_INFO_TYPE);
- RUNTIME_ASSERT(offset > 0);
- if (type == FUNCTION_TEMPLATE_INFO_TYPE) {
- RUNTIME_ASSERT(offset < FunctionTemplateInfo::kSize);
- } else {
- RUNTIME_ASSERT(offset < ObjectTemplateInfo::kSize);
- }
- return *HeapObject::RawField(templ, offset);
-}
-
-
-// Transform getter or setter into something DefineAccessor can handle.
-static Handle<Object> InstantiateAccessorComponent(Isolate* isolate,
- Handle<Object> component) {
- if (component->IsUndefined()) return isolate->factory()->undefined_value();
- Handle<FunctionTemplateInfo> info =
- Handle<FunctionTemplateInfo>::cast(component);
- return Utils::OpenHandle(*Utils::ToLocal(info)->GetFunction());
-}
-
-
-RUNTIME_FUNCTION(Runtime_DefineApiAccessorProperty) {
- HandleScope scope(isolate);
- DCHECK(args.length() == 5);
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Name, name, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, getter, 2);
- CONVERT_ARG_HANDLE_CHECKED(Object, setter, 3);
- CONVERT_SMI_ARG_CHECKED(attribute, 4);
- RUNTIME_ASSERT(getter->IsUndefined() || getter->IsFunctionTemplateInfo());
- RUNTIME_ASSERT(setter->IsUndefined() || setter->IsFunctionTemplateInfo());
- RUNTIME_ASSERT(PropertyDetails::AttributesField::is_valid(
- static_cast<PropertyAttributes>(attribute)));
- RETURN_FAILURE_ON_EXCEPTION(
- isolate, JSObject::DefineAccessor(
- object, name, InstantiateAccessorComponent(isolate, getter),
- InstantiateAccessorComponent(isolate, setter),
- static_cast<PropertyAttributes>(attribute)));
- return isolate->heap()->undefined_value();
-}
-
-
-RUNTIME_FUNCTION(Runtime_AddPropertyForTemplate) {
- HandleScope scope(isolate);
- RUNTIME_ASSERT(args.length() == 4);
-
- CONVERT_ARG_HANDLE_CHECKED(JSObject, object, 0);
- CONVERT_ARG_HANDLE_CHECKED(Object, key, 1);
- CONVERT_ARG_HANDLE_CHECKED(Object, value, 2);
- CONVERT_SMI_ARG_CHECKED(unchecked_attributes, 3);
- RUNTIME_ASSERT(
- (unchecked_attributes & ~(READ_ONLY | DONT_ENUM | DONT_DELETE)) == 0);
- // Compute attributes.
- PropertyAttributes attributes =
- static_cast<PropertyAttributes>(unchecked_attributes);
-
-#ifdef DEBUG
- bool duplicate;
- if (key->IsName()) {
- LookupIterator it(object, Handle<Name>::cast(key),
- LookupIterator::OWN_SKIP_INTERCEPTOR);
- Maybe<PropertyAttributes> maybe = JSReceiver::GetPropertyAttributes(&it);
- DCHECK(maybe.has_value);
- duplicate = it.IsFound();
- } else {
- uint32_t index = 0;
- RUNTIME_ASSERT(key->ToArrayIndex(&index));
- Maybe<bool> maybe = JSReceiver::HasOwnElement(object, index);
- if (!maybe.has_value) return isolate->heap()->exception();
- duplicate = maybe.value;
- }
- if (duplicate) {
- Handle<Object> args[1] = {key};
- THROW_NEW_ERROR_RETURN_FAILURE(
- isolate,
- NewTypeError("duplicate_template_property", HandleVector(args, 1)));
- }
-#endif
-
- Handle<Object> result;
- ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, result,
- Runtime::DefineObjectProperty(object, key, value, attributes));
- return *result;
-}
-}
-} // namespace v8::internal
#ifdef V8_I18N_SUPPORT
#include "src/v8.h"
+#include "src/api-natives.h"
#include "src/arguments.h"
#include "src/i18n.h"
#include "src/runtime/runtime-utils.h"
Handle<JSObject> local_object;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, local_object,
- Execution::InstantiateObject(date_format_template));
+ ApiNatives::InstantiateObject(date_format_template));
// Set date time formatter as internal field of the resulting JS object.
icu::SimpleDateFormat* date_format =
Handle<JSObject> local_object;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, local_object,
- Execution::InstantiateObject(number_format_template));
+ ApiNatives::InstantiateObject(number_format_template));
// Set number formatter as internal field of the resulting JS object.
icu::DecimalFormat* number_format =
// Create an empty object wrapper.
Handle<JSObject> local_object;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
- isolate, local_object, Execution::InstantiateObject(collator_template));
+ isolate, local_object, ApiNatives::InstantiateObject(collator_template));
// Set collator as internal field of the resulting JS object.
icu::Collator* collator =
Handle<JSObject> local_object;
ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
isolate, local_object,
- Execution::InstantiateObject(break_iterator_template));
+ ApiNatives::InstantiateObject(break_iterator_template));
// Set break iterator as internal field of the resulting JS object.
icu::BreakIterator* break_iterator = BreakIterator::InitializeBreakIterator(
\
F(SetCode, 2, 1) \
\
- F(CreateApiFunction, 2, 1) \
- F(IsTemplate, 1, 1) \
- F(GetTemplateField, 2, 1) \
F(DisableAccessChecks, 1, 1) \
F(EnableAccessChecks, 1, 1) \
\
F(GlobalProxy, 1, 1) \
\
F(AddNamedProperty, 4, 1) \
- F(AddPropertyForTemplate, 4, 1) \
F(SetProperty, 4, 1) \
F(AddElement, 4, 1) \
- F(DefineApiAccessorProperty, 5, 1) \
F(DefineDataPropertyUnchecked, 4, 1) \
F(DefineAccessorPropertyUnchecked, 5, 1) \
F(GetDataProperty, 2, 1) \
i::Smi::cast(v8::Utils::OpenHandle(*func)
->shared()->get_api_func_data()->serial_number())->value();
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
- i::Handle<i::JSObject> cache(i_isolate->native_context()->function_cache());
- i::Handle<i::Object> elm =
- i::Object::GetElement(i_isolate, cache, serial_number).ToHandleChecked();
- CHECK(elm->IsUndefined());
+ i::Handle<i::FixedArray> cache(i_isolate->native_context()->function_cache());
+ if (serial_number < cache->length()) {
+ CHECK(cache->get(serial_number)->IsUndefined());
+ }
// Verify that each Function::New creates a new function instance
Local<Object> data2 = v8::Object::New(isolate);
function_new_expected_env = data2;
'../../src/allocation-tracker.h',
'../../src/api.cc',
'../../src/api.h',
+ '../../src/api-natives.cc',
+ '../../src/api-natives.h',
'../../src/arguments.cc',
'../../src/arguments.h',
'../../src/assembler.cc',
'../../src/rewriter.h',
'../../src/runtime-profiler.cc',
'../../src/runtime-profiler.h',
- '../../src/runtime/runtime-api.cc',
'../../src/runtime/runtime-array.cc',
'../../src/runtime/runtime-classes.cc',
'../../src/runtime/runtime-collections.cc',
'../../src/uri.js',
'../../src/third_party/fdlibm/fdlibm.js',
'../../src/math.js',
- '../../src/apinatives.js',
'../../src/date.js',
'../../src/regexp.js',
'../../src/arraybuffer.js',
projects / platform / upstream / v8.git / commitdiff