Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/src/factory.cc b/src/factory.cc
index ba62341..f03e6b2 100644
--- a/src/factory.cc
+++ b/src/factory.cc
@@ -6,6 +6,7 @@
#include "src/allocation-site-scopes.h"
#include "src/base/bits.h"
+#include "src/bootstrapper.h"
#include "src/conversions.h"
#include "src/isolate-inl.h"
#include "src/macro-assembler.h"
@@ -14,6 +15,44 @@
namespace internal {
+// Calls the FUNCTION_CALL function and retries it up to three times
+// to guarantee that any allocations performed during the call will
+// succeed if there's enough memory.
+//
+// Warning: Do not use the identifiers __object__, __maybe_object__,
+// __allocation__ or __scope__ in a call to this macro.
+
+#define RETURN_OBJECT_UNLESS_RETRY(ISOLATE, TYPE) \
+ if (__allocation__.To(&__object__)) { \
+ DCHECK(__object__ != (ISOLATE)->heap()->exception()); \
+ return Handle<TYPE>(TYPE::cast(__object__), ISOLATE); \
+ }
+
+#define CALL_HEAP_FUNCTION(ISOLATE, FUNCTION_CALL, TYPE) \
+ do { \
+ AllocationResult __allocation__ = FUNCTION_CALL; \
+ Object* __object__ = NULL; \
+ RETURN_OBJECT_UNLESS_RETRY(ISOLATE, TYPE) \
+ /* Two GCs before panicking. In newspace will almost always succeed. */ \
+ for (int __i__ = 0; __i__ < 2; __i__++) { \
+ (ISOLATE)->heap()->CollectGarbage(__allocation__.RetrySpace(), \
+ "allocation failure"); \
+ __allocation__ = FUNCTION_CALL; \
+ RETURN_OBJECT_UNLESS_RETRY(ISOLATE, TYPE) \
+ } \
+ (ISOLATE)->counters()->gc_last_resort_from_handles()->Increment(); \
+ (ISOLATE)->heap()->CollectAllAvailableGarbage("last resort gc"); \
+ { \
+ AlwaysAllocateScope __scope__(ISOLATE); \
+ __allocation__ = FUNCTION_CALL; \
+ } \
+ RETURN_OBJECT_UNLESS_RETRY(ISOLATE, TYPE) \
+ /* TODO(1181417): Fix this. */ \
+ v8::internal::Heap::FatalProcessOutOfMemory("CALL_AND_RETRY_LAST", true); \
+ return Handle<TYPE>(); \
+ } while (false)
+
+
template<typename T>
Handle<T> Factory::New(Handle<Map> map, AllocationSpace space) {
CALL_HEAP_FUNCTION(
@@ -51,12 +90,34 @@
}
-Handle<Oddball> Factory::NewOddball(Handle<Map> map,
- const char* to_string,
+Handle<PrototypeInfo> Factory::NewPrototypeInfo() {
+ Handle<PrototypeInfo> result =
+ Handle<PrototypeInfo>::cast(NewStruct(PROTOTYPE_INFO_TYPE));
+ result->set_prototype_users(WeakFixedArray::Empty());
+ result->set_registry_slot(PrototypeInfo::UNREGISTERED);
+ result->set_validity_cell(Smi::FromInt(0));
+ return result;
+}
+
+
+Handle<SloppyBlockWithEvalContextExtension>
+Factory::NewSloppyBlockWithEvalContextExtension(
+ Handle<ScopeInfo> scope_info, Handle<JSObject> extension) {
+ DCHECK(scope_info->is_declaration_scope());
+ Handle<SloppyBlockWithEvalContextExtension> result =
+ Handle<SloppyBlockWithEvalContextExtension>::cast(
+ NewStruct(SLOPPY_BLOCK_WITH_EVAL_CONTEXT_EXTENSION_TYPE));
+ result->set_scope_info(*scope_info);
+ result->set_extension(*extension);
+ return result;
+}
+
+
+Handle<Oddball> Factory::NewOddball(Handle<Map> map, const char* to_string,
Handle<Object> to_number,
- byte kind) {
- Handle<Oddball> oddball = New<Oddball>(map, OLD_POINTER_SPACE);
- Oddball::Initialize(isolate(), oddball, to_string, to_number, kind);
+ const char* type_of, byte kind) {
+ Handle<Oddball> oddball = New<Oddball>(map, OLD_SPACE);
+ Oddball::Initialize(isolate(), oddball, to_string, to_number, type_of, kind);
return oddball;
}
@@ -116,28 +177,6 @@
}
-Handle<ConstantPoolArray> Factory::NewConstantPoolArray(
- const ConstantPoolArray::NumberOfEntries& small) {
- DCHECK(small.total_count() > 0);
- CALL_HEAP_FUNCTION(
- isolate(),
- isolate()->heap()->AllocateConstantPoolArray(small),
- ConstantPoolArray);
-}
-
-
-Handle<ConstantPoolArray> Factory::NewExtendedConstantPoolArray(
- const ConstantPoolArray::NumberOfEntries& small,
- const ConstantPoolArray::NumberOfEntries& extended) {
- DCHECK(small.total_count() > 0);
- DCHECK(extended.total_count() > 0);
- CALL_HEAP_FUNCTION(
- isolate(),
- isolate()->heap()->AllocateExtendedConstantPoolArray(small, extended),
- ConstantPoolArray);
-}
-
-
Handle<OrderedHashSet> Factory::NewOrderedHashSet() {
return OrderedHashSet::Allocate(isolate(), OrderedHashSet::kMinCapacity);
}
@@ -204,6 +243,12 @@
}
+Handle<Name> Factory::InternalizeName(Handle<Name> name) {
+ if (name->IsUniqueName()) return name;
+ return InternalizeString(Handle<String>::cast(name));
+}
+
+
MaybeHandle<String> Factory::NewStringFromOneByte(Vector<const uint8_t> string,
PretenureFlag pretenure) {
int length = string.length();
@@ -240,7 +285,7 @@
decoder(isolate()->unicode_cache()->utf8_decoder());
decoder->Reset(string.start() + non_ascii_start,
length - non_ascii_start);
- int utf16_length = decoder->Utf16Length();
+ int utf16_length = static_cast<int>(decoder->Utf16Length());
DCHECK(utf16_length > 0);
// Allocate string.
Handle<SeqTwoByteString> result;
@@ -538,10 +583,10 @@
NewRawTwoByteString(length).ToHandleChecked(), left, right);
}
- Handle<Map> map = (is_one_byte || is_one_byte_data_in_two_byte_string)
- ? cons_one_byte_string_map()
- : cons_string_map();
- Handle<ConsString> result = New<ConsString>(map, NEW_SPACE);
+ Handle<ConsString> result =
+ (is_one_byte || is_one_byte_data_in_two_byte_string)
+ ? New<ConsString>(cons_one_byte_string_map(), NEW_SPACE)
+ : New<ConsString>(cons_string_map(), NEW_SPACE);
DisallowHeapAllocation no_gc;
WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
@@ -625,7 +670,13 @@
THROW_NEW_ERROR(isolate(), NewInvalidStringLengthError(), String);
}
- Handle<Map> map = external_one_byte_string_map();
+ Handle<Map> map;
+ if (resource->IsCompressible()) {
+ // TODO(hajimehoshi): Rename this to 'uncached_external_one_byte_string_map'
+ map = short_external_one_byte_string_map();
+ } else {
+ map = external_one_byte_string_map();
+ }
Handle<ExternalOneByteString> external_string =
New<ExternalOneByteString>(map, NEW_SPACE);
external_string->set_length(static_cast<int>(length));
@@ -648,8 +699,15 @@
static const size_t kOneByteCheckLengthLimit = 32;
bool is_one_byte = length <= kOneByteCheckLengthLimit &&
String::IsOneByte(resource->data(), static_cast<int>(length));
- Handle<Map> map = is_one_byte ?
- external_string_with_one_byte_data_map() : external_string_map();
+ Handle<Map> map;
+ if (resource->IsCompressible()) {
+ // TODO(hajimehoshi): Rename these to 'uncached_external_string_...'.
+ map = is_one_byte ? short_external_string_with_one_byte_data_map()
+ : short_external_string_map();
+ } else {
+ map = is_one_byte ? external_string_with_one_byte_data_map()
+ : external_string_map();
+ }
Handle<ExternalTwoByteString> external_string =
New<ExternalTwoByteString>(map, NEW_SPACE);
external_string->set_length(static_cast<int>(length));
@@ -675,19 +733,15 @@
}
-Handle<Symbol> Factory::NewPrivateOwnSymbol() {
- Handle<Symbol> symbol = NewSymbol();
- symbol->set_is_private(true);
- symbol->set_is_own(true);
- return symbol;
-}
-
-
Handle<Context> Factory::NewNativeContext() {
- Handle<FixedArray> array = NewFixedArray(Context::NATIVE_CONTEXT_SLOTS);
+ Handle<FixedArray> array =
+ NewFixedArray(Context::NATIVE_CONTEXT_SLOTS, TENURED);
array->set_map_no_write_barrier(*native_context_map());
Handle<Context> context = Handle<Context>::cast(array);
- context->set_js_array_maps(*undefined_value());
+ context->set_native_context(*context);
+ context->set_errors_thrown(Smi::FromInt(0));
+ Handle<WeakCell> weak_cell = NewWeakCell(context);
+ context->set_self_weak_cell(*weak_cell);
DCHECK(context->IsNativeContext());
return context;
}
@@ -702,7 +756,7 @@
context->set_closure(*function);
context->set_previous(function->context());
context->set_extension(*scope_info);
- context->set_global_object(function->context()->global_object());
+ context->set_native_context(function->native_context());
DCHECK(context->IsScriptContext());
return context;
}
@@ -724,7 +778,7 @@
array->set_map_no_write_barrier(*module_context_map());
// Instance link will be set later.
Handle<Context> context = Handle<Context>::cast(array);
- context->set_extension(Smi::FromInt(0));
+ context->set_extension(*the_hole_value());
return context;
}
@@ -737,8 +791,8 @@
Handle<Context> context = Handle<Context>::cast(array);
context->set_closure(*function);
context->set_previous(function->context());
- context->set_extension(Smi::FromInt(0));
- context->set_global_object(function->context()->global_object());
+ context->set_extension(*the_hole_value());
+ context->set_native_context(function->native_context());
return context;
}
@@ -754,7 +808,7 @@
context->set_closure(*function);
context->set_previous(*previous);
context->set_extension(*name);
- context->set_global_object(previous->global_object());
+ context->set_native_context(previous->native_context());
context->set(Context::THROWN_OBJECT_INDEX, *thrown_object);
return context;
}
@@ -769,7 +823,7 @@
context->set_closure(*function);
context->set_previous(*previous);
context->set_extension(*extension);
- context->set_global_object(previous->global_object());
+ context->set_native_context(previous->native_context());
return context;
}
@@ -777,14 +831,13 @@
Handle<Context> Factory::NewBlockContext(Handle<JSFunction> function,
Handle<Context> previous,
Handle<ScopeInfo> scope_info) {
- Handle<FixedArray> array =
- NewFixedArrayWithHoles(scope_info->ContextLength());
+ Handle<FixedArray> array = NewFixedArray(scope_info->ContextLength());
array->set_map_no_write_barrier(*block_context_map());
Handle<Context> context = Handle<Context>::cast(array);
context->set_closure(*function);
context->set_previous(*previous);
context->set_extension(*scope_info);
- context->set_global_object(previous->global_object());
+ context->set_native_context(previous->native_context());
return context;
}
@@ -802,7 +855,6 @@
Handle<CodeCache>::cast(NewStruct(CODE_CACHE_TYPE));
code_cache->set_default_cache(*empty_fixed_array(), SKIP_WRITE_BARRIER);
code_cache->set_normal_type_cache(*undefined_value(), SKIP_WRITE_BARRIER);
- code_cache->set_weak_cell_cache(*undefined_value(), SKIP_WRITE_BARRIER);
return code_cache;
}
@@ -816,21 +868,6 @@
}
-Handle<DeclaredAccessorDescriptor> Factory::NewDeclaredAccessorDescriptor() {
- return Handle<DeclaredAccessorDescriptor>::cast(
- NewStruct(DECLARED_ACCESSOR_DESCRIPTOR_TYPE));
-}
-
-
-Handle<DeclaredAccessorInfo> Factory::NewDeclaredAccessorInfo() {
- Handle<DeclaredAccessorInfo> info =
- Handle<DeclaredAccessorInfo>::cast(
- NewStruct(DECLARED_ACCESSOR_INFO_TYPE));
- info->set_flag(0); // Must clear the flag, it was initialized as undefined.
- return info;
-}
-
-
Handle<ExecutableAccessorInfo> Factory::NewExecutableAccessorInfo() {
Handle<ExecutableAccessorInfo> info =
Handle<ExecutableAccessorInfo>::cast(
@@ -841,27 +878,24 @@
Handle<Script> Factory::NewScript(Handle<String> source) {
- // Generate id for this script.
- Heap* heap = isolate()->heap();
- int id = heap->last_script_id()->value() + 1;
- if (!Smi::IsValid(id) || id < 0) id = 1;
- heap->set_last_script_id(Smi::FromInt(id));
-
// Create and initialize script object.
+ Heap* heap = isolate()->heap();
Handle<Script> script = Handle<Script>::cast(NewStruct(SCRIPT_TYPE));
script->set_source(*source);
script->set_name(heap->undefined_value());
- script->set_id(Smi::FromInt(id));
- script->set_line_offset(Smi::FromInt(0));
- script->set_column_offset(Smi::FromInt(0));
+ script->set_id(isolate()->heap()->NextScriptId());
+ script->set_line_offset(0);
+ script->set_column_offset(0);
script->set_context_data(heap->undefined_value());
- script->set_type(Smi::FromInt(Script::TYPE_NORMAL));
+ script->set_type(Script::TYPE_NORMAL);
script->set_wrapper(heap->undefined_value());
script->set_line_ends(heap->undefined_value());
script->set_eval_from_shared(heap->undefined_value());
- script->set_eval_from_instructions_offset(Smi::FromInt(0));
- script->set_flags(Smi::FromInt(0));
+ script->set_eval_from_instructions_offset(0);
+ script->set_shared_function_infos(Smi::FromInt(0));
+ script->set_flags(0);
+ heap->set_script_list(*WeakFixedArray::Add(script_list(), script));
return script;
}
@@ -887,32 +921,35 @@
}
-Handle<ExternalArray> Factory::NewExternalArray(int length,
- ExternalArrayType array_type,
- void* external_pointer,
- PretenureFlag pretenure) {
+Handle<BytecodeArray> Factory::NewBytecodeArray(
+ int length, const byte* raw_bytecodes, int frame_size, int parameter_count,
+ Handle<FixedArray> constant_pool) {
+ DCHECK(0 <= length);
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateBytecodeArray(
+ length, raw_bytecodes, frame_size,
+ parameter_count, *constant_pool),
+ BytecodeArray);
+}
+
+
+Handle<FixedTypedArrayBase> Factory::NewFixedTypedArrayWithExternalPointer(
+ int length, ExternalArrayType array_type, void* external_pointer,
+ PretenureFlag pretenure) {
DCHECK(0 <= length && length <= Smi::kMaxValue);
CALL_HEAP_FUNCTION(
- isolate(),
- isolate()->heap()->AllocateExternalArray(length,
- array_type,
- external_pointer,
- pretenure),
- ExternalArray);
+ isolate(), isolate()->heap()->AllocateFixedTypedArrayWithExternalPointer(
+ length, array_type, external_pointer, pretenure),
+ FixedTypedArrayBase);
}
Handle<FixedTypedArrayBase> Factory::NewFixedTypedArray(
- int length,
- ExternalArrayType array_type,
+ int length, ExternalArrayType array_type, bool initialize,
PretenureFlag pretenure) {
DCHECK(0 <= length && length <= Smi::kMaxValue);
- CALL_HEAP_FUNCTION(
- isolate(),
- isolate()->heap()->AllocateFixedTypedArray(length,
- array_type,
- pretenure),
- FixedTypedArrayBase);
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateFixedTypedArray(
+ length, array_type, initialize, pretenure),
+ FixedTypedArrayBase);
}
@@ -925,7 +962,7 @@
}
-Handle<PropertyCell> Factory::NewPropertyCellWithHole() {
+Handle<PropertyCell> Factory::NewPropertyCell() {
CALL_HEAP_FUNCTION(
isolate(),
isolate()->heap()->AllocatePropertyCell(),
@@ -933,24 +970,25 @@
}
-Handle<PropertyCell> Factory::NewPropertyCell(Handle<Object> value) {
- AllowDeferredHandleDereference convert_to_cell;
- Handle<PropertyCell> cell = NewPropertyCellWithHole();
- PropertyCell::SetValueInferType(cell, value);
- return cell;
-}
-
-
Handle<WeakCell> Factory::NewWeakCell(Handle<HeapObject> value) {
+ // It is safe to dereference the value because we are embedding it
+ // in cell and not inspecting its fields.
AllowDeferredHandleDereference convert_to_cell;
CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateWeakCell(*value),
WeakCell);
}
+Handle<TransitionArray> Factory::NewTransitionArray(int capacity) {
+ CALL_HEAP_FUNCTION(isolate(),
+ isolate()->heap()->AllocateTransitionArray(capacity),
+ TransitionArray);
+}
+
+
Handle<AllocationSite> Factory::NewAllocationSite() {
Handle<Map> map = allocation_site_map();
- Handle<AllocationSite> site = New<AllocationSite>(map, OLD_POINTER_SPACE);
+ Handle<AllocationSite> site = New<AllocationSite>(map, OLD_SPACE);
site->Initialize();
// Link the site
@@ -996,6 +1034,15 @@
}
+Handle<FixedArray> Factory::CopyFixedArrayAndGrow(Handle<FixedArray> array,
+ int grow_by,
+ PretenureFlag pretenure) {
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->CopyFixedArrayAndGrow(
+ *array, grow_by, pretenure),
+ FixedArray);
+}
+
+
Handle<FixedArray> Factory::CopyFixedArray(Handle<FixedArray> array) {
CALL_HEAP_FUNCTION(isolate(),
isolate()->heap()->CopyFixedArray(*array),
@@ -1020,14 +1067,6 @@
}
-Handle<ConstantPoolArray> Factory::CopyConstantPoolArray(
- Handle<ConstantPoolArray> array) {
- CALL_HEAP_FUNCTION(isolate(),
- isolate()->heap()->CopyConstantPoolArray(*array),
- ConstantPoolArray);
-}
-
-
Handle<Object> Factory::NewNumber(double value,
PretenureFlag pretenure) {
// We need to distinguish the minus zero value and this cannot be
@@ -1073,198 +1112,104 @@
}
-MaybeHandle<Object> Factory::NewTypeError(const char* message,
- Vector<Handle<Object> > args) {
- return NewError("MakeTypeError", message, args);
-}
-
-
-MaybeHandle<Object> Factory::NewTypeError(Handle<String> message) {
- return NewError("$TypeError", message);
-}
-
-
-MaybeHandle<Object> Factory::NewRangeError(const char* message,
- Vector<Handle<Object> > args) {
- return NewError("MakeRangeError", message, args);
-}
-
-
-MaybeHandle<Object> Factory::NewRangeError(Handle<String> message) {
- return NewError("$RangeError", message);
-}
-
-
-MaybeHandle<Object> Factory::NewSyntaxError(const char* message,
- Handle<JSArray> args) {
- return NewError("MakeSyntaxError", message, args);
-}
-
-
-MaybeHandle<Object> Factory::NewSyntaxError(Handle<String> message) {
- return NewError("$SyntaxError", message);
-}
-
-
-MaybeHandle<Object> Factory::NewReferenceError(const char* message,
- Vector<Handle<Object> > args) {
- return NewError("MakeReferenceError", message, args);
-}
-
-
-MaybeHandle<Object> Factory::NewReferenceError(const char* message,
- Handle<JSArray> args) {
- return NewError("MakeReferenceError", message, args);
-}
-
-
-MaybeHandle<Object> Factory::NewReferenceError(Handle<String> message) {
- return NewError("$ReferenceError", message);
-}
-
-
-MaybeHandle<Object> Factory::NewError(const char* maker, const char* message,
- Vector<Handle<Object> > args) {
- // Instantiate a closeable HandleScope for EscapeFrom.
- v8::EscapableHandleScope scope(reinterpret_cast<v8::Isolate*>(isolate()));
- Handle<FixedArray> array = NewFixedArray(args.length());
- for (int i = 0; i < args.length(); i++) {
- array->set(i, *args[i]);
+#define SIMD128_NEW_DEF(TYPE, Type, type, lane_count, lane_type) \
+ Handle<Type> Factory::New##Type(lane_type lanes[lane_count], \
+ PretenureFlag pretenure) { \
+ CALL_HEAP_FUNCTION( \
+ isolate(), isolate()->heap()->Allocate##Type(lanes, pretenure), Type); \
}
- Handle<JSArray> object = NewJSArrayWithElements(array);
- Handle<Object> result;
- ASSIGN_RETURN_ON_EXCEPTION(isolate(), result,
- NewError(maker, message, object), Object);
- return result.EscapeFrom(&scope);
-}
+SIMD128_TYPES(SIMD128_NEW_DEF)
+#undef SIMD128_NEW_DEF
-MaybeHandle<Object> Factory::NewEvalError(const char* message,
- Vector<Handle<Object> > args) {
- return NewError("MakeEvalError", message, args);
-}
-
-
-MaybeHandle<Object> Factory::NewError(const char* message,
- Vector<Handle<Object> > args) {
- return NewError("MakeError", message, args);
-}
-
-
-Handle<String> Factory::EmergencyNewError(const char* message,
- Handle<JSArray> args) {
- const int kBufferSize = 1000;
- char buffer[kBufferSize];
- size_t space = kBufferSize;
- char* p = &buffer[0];
-
- Vector<char> v(buffer, kBufferSize);
- StrNCpy(v, message, space);
- space -= Min(space, strlen(message));
- p = &buffer[kBufferSize] - space;
-
- for (int i = 0; i < Smi::cast(args->length())->value(); i++) {
- if (space > 0) {
- *p++ = ' ';
- space--;
- if (space > 0) {
- Handle<String> arg_str = Handle<String>::cast(
- Object::GetElement(isolate(), args, i).ToHandleChecked());
- SmartArrayPointer<char> arg = arg_str->ToCString();
- Vector<char> v2(p, static_cast<int>(space));
- StrNCpy(v2, arg.get(), space);
- space -= Min(space, strlen(arg.get()));
- p = &buffer[kBufferSize] - space;
- }
- }
+Handle<Object> Factory::NewError(Handle<JSFunction> constructor,
+ MessageTemplate::Template template_index,
+ Handle<Object> arg0, Handle<Object> arg1,
+ Handle<Object> arg2) {
+ HandleScope scope(isolate());
+ if (isolate()->bootstrapper()->IsActive()) {
+ // During bootstrapping we cannot construct error objects.
+ return scope.CloseAndEscape(NewStringFromAsciiChecked(
+ MessageTemplate::TemplateString(template_index)));
}
- if (space > 0) {
- *p = '\0';
- } else {
- buffer[kBufferSize - 1] = '\0';
- }
- return NewStringFromUtf8(CStrVector(buffer), TENURED).ToHandleChecked();
-}
-
-MaybeHandle<Object> Factory::NewError(const char* maker, const char* message,
- Handle<JSArray> args) {
- Handle<String> make_str = InternalizeUtf8String(maker);
- Handle<Object> fun_obj = Object::GetProperty(
- isolate()->js_builtins_object(), make_str).ToHandleChecked();
- // If the builtins haven't been properly configured yet this error
- // constructor may not have been defined. Bail out.
- if (!fun_obj->IsJSFunction()) {
- return EmergencyNewError(message, args);
- }
- Handle<JSFunction> fun = Handle<JSFunction>::cast(fun_obj);
- Handle<Object> message_obj = InternalizeUtf8String(message);
- Handle<Object> argv[] = { message_obj, args };
+ Handle<JSFunction> fun = isolate()->make_error_function();
+ Handle<Object> message_type(Smi::FromInt(template_index), isolate());
+ if (arg0.is_null()) arg0 = undefined_value();
+ if (arg1.is_null()) arg1 = undefined_value();
+ if (arg2.is_null()) arg2 = undefined_value();
+ Handle<Object> argv[] = {constructor, message_type, arg0, arg1, arg2};
// Invoke the JavaScript factory method. If an exception is thrown while
// running the factory method, use the exception as the result.
Handle<Object> result;
MaybeHandle<Object> exception;
- if (!Execution::TryCall(fun,
- isolate()->js_builtins_object(),
- arraysize(argv),
- argv,
- &exception).ToHandle(&result)) {
- return exception;
+ if (!Execution::TryCall(isolate(), fun, undefined_value(), arraysize(argv),
+ argv, &exception)
+ .ToHandle(&result)) {
+ Handle<Object> exception_obj;
+ if (exception.ToHandle(&exception_obj)) {
+ result = exception_obj;
+ } else {
+ result = undefined_value();
+ }
}
- return result;
+ return scope.CloseAndEscape(result);
}
-MaybeHandle<Object> Factory::NewError(Handle<String> message) {
- return NewError("$Error", message);
-}
-
-
-MaybeHandle<Object> Factory::NewError(const char* constructor,
- Handle<String> message) {
- Handle<String> constr = InternalizeUtf8String(constructor);
- Handle<JSFunction> fun = Handle<JSFunction>::cast(Object::GetProperty(
- isolate()->js_builtins_object(), constr).ToHandleChecked());
+Handle<Object> Factory::NewError(Handle<JSFunction> constructor,
+ Handle<String> message) {
Handle<Object> argv[] = { message };
// Invoke the JavaScript factory method. If an exception is thrown while
// running the factory method, use the exception as the result.
Handle<Object> result;
MaybeHandle<Object> exception;
- if (!Execution::TryCall(fun,
- isolate()->js_builtins_object(),
- arraysize(argv),
- argv,
- &exception).ToHandle(&result)) {
- return exception;
+ if (!Execution::TryCall(isolate(), constructor, undefined_value(),
+ arraysize(argv), argv, &exception)
+ .ToHandle(&result)) {
+ Handle<Object> exception_obj;
+ if (exception.ToHandle(&exception_obj)) return exception_obj;
+ return undefined_value();
}
return result;
}
-void Factory::InitializeFunction(Handle<JSFunction> function,
- Handle<SharedFunctionInfo> info,
- Handle<Context> context) {
- function->initialize_properties();
- function->initialize_elements();
- function->set_shared(*info);
- function->set_code(info->code());
- function->set_context(*context);
- function->set_prototype_or_initial_map(*the_hole_value());
- function->set_literals_or_bindings(*empty_fixed_array());
- function->set_next_function_link(*undefined_value());
-}
+#define DEFINE_ERROR(NAME, name) \
+ Handle<Object> Factory::New##NAME(MessageTemplate::Template template_index, \
+ Handle<Object> arg0, Handle<Object> arg1, \
+ Handle<Object> arg2) { \
+ return NewError(isolate()->name##_function(), template_index, arg0, arg1, \
+ arg2); \
+ }
+DEFINE_ERROR(Error, error)
+DEFINE_ERROR(EvalError, eval_error)
+DEFINE_ERROR(RangeError, range_error)
+DEFINE_ERROR(ReferenceError, reference_error)
+DEFINE_ERROR(SyntaxError, syntax_error)
+DEFINE_ERROR(TypeError, type_error)
+#undef DEFINE_ERROR
Handle<JSFunction> Factory::NewFunction(Handle<Map> map,
Handle<SharedFunctionInfo> info,
Handle<Context> context,
PretenureFlag pretenure) {
- AllocationSpace space = pretenure == TENURED ? OLD_POINTER_SPACE : NEW_SPACE;
- Handle<JSFunction> result = New<JSFunction>(map, space);
- InitializeFunction(result, info, context);
- return result;
+ AllocationSpace space = pretenure == TENURED ? OLD_SPACE : NEW_SPACE;
+ Handle<JSFunction> function = New<JSFunction>(map, space);
+
+ function->initialize_properties();
+ function->initialize_elements();
+ function->set_shared(*info);
+ function->set_code(info->code());
+ function->set_context(*context);
+ function->set_prototype_or_initial_map(*the_hole_value());
+ function->set_literals(LiteralsArray::cast(*empty_fixed_array()));
+ function->set_next_function_link(*undefined_value(), SKIP_WRITE_BARRIER);
+ isolate()->heap()->InitializeJSObjectBody(*function, *map, JSFunction::kSize);
+ return function;
}
@@ -1272,13 +1217,19 @@
Handle<String> name,
MaybeHandle<Code> code) {
Handle<Context> context(isolate()->native_context());
- Handle<SharedFunctionInfo> info = NewSharedFunctionInfo(name, code);
- DCHECK((info->strict_mode() == SLOPPY) &&
- (map.is_identical_to(isolate()->sloppy_function_map()) ||
- map.is_identical_to(
- isolate()->sloppy_function_without_prototype_map()) ||
- map.is_identical_to(
- isolate()->sloppy_function_with_readonly_prototype_map())));
+ Handle<SharedFunctionInfo> info =
+ NewSharedFunctionInfo(name, code, map->is_constructor());
+ DCHECK(is_sloppy(info->language_mode()));
+ DCHECK(!map->IsUndefined());
+ DCHECK(
+ map.is_identical_to(isolate()->sloppy_function_map()) ||
+ map.is_identical_to(isolate()->sloppy_function_without_prototype_map()) ||
+ map.is_identical_to(
+ isolate()->sloppy_function_with_readonly_prototype_map()) ||
+ map.is_identical_to(isolate()->strict_function_map()) ||
+ // TODO(titzer): wasm_function_map() could be undefined here. ugly.
+ (*map == context->get(Context::WASM_FUNCTION_MAP_INDEX)) ||
+ map.is_identical_to(isolate()->proxy_function_map()));
return NewFunction(map, info, context);
}
@@ -1290,19 +1241,27 @@
Handle<JSFunction> Factory::NewFunctionWithoutPrototype(Handle<String> name,
- Handle<Code> code) {
- return NewFunction(
- isolate()->sloppy_function_without_prototype_map(), name, code);
+ Handle<Code> code,
+ bool is_strict) {
+ Handle<Map> map = is_strict
+ ? isolate()->strict_function_without_prototype_map()
+ : isolate()->sloppy_function_without_prototype_map();
+ return NewFunction(map, name, code);
}
-Handle<JSFunction> Factory::NewFunction(Handle<String> name,
- Handle<Code> code,
+Handle<JSFunction> Factory::NewFunction(Handle<String> name, Handle<Code> code,
Handle<Object> prototype,
- bool read_only_prototype) {
- Handle<Map> map = read_only_prototype
- ? isolate()->sloppy_function_with_readonly_prototype_map()
- : isolate()->sloppy_function_map();
+ bool read_only_prototype,
+ bool is_strict) {
+ // In strict mode, readonly strict map is only available during bootstrap
+ DCHECK(!is_strict || !read_only_prototype ||
+ isolate()->bootstrapper()->IsActive());
+ Handle<Map> map =
+ is_strict ? isolate()->strict_function_map()
+ : read_only_prototype
+ ? isolate()->sloppy_function_with_readonly_prototype_map()
+ : isolate()->sloppy_function_map();
Handle<JSFunction> result = NewFunction(map, name, code);
result->set_prototype_or_initial_map(*prototype);
return result;
@@ -1313,10 +1272,11 @@
Handle<Object> prototype,
InstanceType type, int instance_size,
bool read_only_prototype,
- bool install_constructor) {
+ bool install_constructor,
+ bool is_strict) {
// Allocate the function
- Handle<JSFunction> function = NewFunction(
- name, code, prototype, read_only_prototype);
+ Handle<JSFunction> function =
+ NewFunction(name, code, prototype, read_only_prototype, is_strict);
ElementsKind elements_kind =
type == JS_ARRAY_TYPE ? FAST_SMI_ELEMENTS : FAST_HOLEY_SMI_ELEMENTS;
@@ -1373,54 +1333,58 @@
}
-static bool ShouldOptimizeNewClosure(Isolate* isolate,
- Handle<SharedFunctionInfo> info) {
- return isolate->use_crankshaft() && !info->is_toplevel() &&
- info->is_compiled() && info->allows_lazy_compilation() &&
- !info->optimization_disabled() && !isolate->DebuggerHasBreakPoints();
-}
-
-
Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
Handle<SharedFunctionInfo> info,
Handle<Context> context,
PretenureFlag pretenure) {
- int map_index = Context::FunctionMapIndex(info->strict_mode(), info->kind());
- Handle<Map> map(Map::cast(context->native_context()->get(map_index)));
- Handle<JSFunction> result = NewFunction(map, info, context, pretenure);
+ int map_index =
+ Context::FunctionMapIndex(info->language_mode(), info->kind());
+ Handle<Map> initial_map(Map::cast(context->native_context()->get(map_index)));
+
+ return NewFunctionFromSharedFunctionInfo(initial_map, info, context,
+ pretenure);
+}
+
+
+Handle<JSFunction> Factory::NewFunctionFromSharedFunctionInfo(
+ Handle<Map> initial_map, Handle<SharedFunctionInfo> info,
+ Handle<Context> context, PretenureFlag pretenure) {
+ DCHECK_EQ(JS_FUNCTION_TYPE, initial_map->instance_type());
+ Handle<JSFunction> result =
+ NewFunction(initial_map, info, context, pretenure);
if (info->ic_age() != isolate()->heap()->global_ic_age()) {
info->ResetForNewContext(isolate()->heap()->global_ic_age());
}
- int index = info->SearchOptimizedCodeMap(context->native_context(),
- BailoutId::None());
- if (!info->bound() && index < 0) {
- int number_of_literals = info->num_literals();
- Handle<FixedArray> literals = NewFixedArray(number_of_literals, pretenure);
- if (number_of_literals > 0) {
- // Store the native context in the literals array prefix. This
- // context will be used when creating object, regexp and array
- // literals in this function.
- literals->set(JSFunction::kLiteralNativeContextIndex,
- context->native_context());
- }
- result->set_literals(*literals);
- }
-
- if (index > 0) {
- // Caching of optimized code enabled and optimized code found.
- FixedArray* literals = info->GetLiteralsFromOptimizedCodeMap(index);
- if (literals != NULL) result->set_literals(literals);
- Code* code = info->GetCodeFromOptimizedCodeMap(index);
- DCHECK(!code->marked_for_deoptimization());
- result->ReplaceCode(code);
- return result;
- }
-
- if (FLAG_always_opt && ShouldOptimizeNewClosure(isolate(), info)) {
+ if (FLAG_always_opt && info->allows_lazy_compilation()) {
result->MarkForOptimization();
}
+
+ CodeAndLiterals cached = info->SearchOptimizedCodeMap(
+ context->native_context(), BailoutId::None());
+ if (cached.code != nullptr) {
+ // Caching of optimized code enabled and optimized code found.
+ DCHECK(!cached.code->marked_for_deoptimization());
+ DCHECK(result->shared()->is_compiled());
+ result->ReplaceCode(cached.code);
+ }
+
+ if (cached.literals != nullptr) {
+ result->set_literals(cached.literals);
+ } else {
+ int number_of_literals = info->num_literals();
+ Handle<LiteralsArray> literals =
+ LiteralsArray::New(isolate(), handle(info->feedback_vector()),
+ number_of_literals, pretenure);
+ result->set_literals(*literals);
+
+ // Cache context-specific literals.
+ Handle<Context> native_context(context->native_context());
+ SharedFunctionInfo::AddLiteralsToOptimizedCodeMap(info, native_context,
+ literals);
+ }
+
return result;
}
@@ -1456,17 +1420,15 @@
int prologue_offset,
bool is_debug) {
Handle<ByteArray> reloc_info = NewByteArray(desc.reloc_size, TENURED);
- Handle<ConstantPoolArray> constant_pool =
- desc.origin->NewConstantPool(isolate());
// Compute size.
int body_size = RoundUp(desc.instr_size, kObjectAlignment);
int obj_size = Code::SizeFor(body_size);
Handle<Code> code = NewCodeRaw(obj_size, immovable);
- DCHECK(isolate()->code_range() == NULL ||
- !isolate()->code_range()->valid() ||
- isolate()->code_range()->contains(code->address()));
+ DCHECK(isolate()->code_range() == NULL || !isolate()->code_range()->valid() ||
+ isolate()->code_range()->contains(code->address()) ||
+ obj_size <= isolate()->heap()->code_space()->AreaSize());
// The code object has not been fully initialized yet. We rely on the
// fact that no allocation will happen from this point on.
@@ -1484,6 +1446,8 @@
code->set_next_code_link(*undefined_value());
code->set_handler_table(*empty_fixed_array(), SKIP_WRITE_BARRIER);
code->set_prologue_offset(prologue_offset);
+ code->set_constant_pool_offset(desc.instr_size - desc.constant_pool_size);
+
if (code->kind() == Code::OPTIMIZED_FUNCTION) {
code->set_marked_for_deoptimization(false);
}
@@ -1493,9 +1457,6 @@
code->set_has_debug_break_slots(true);
}
- desc.origin->PopulateConstantPool(*constant_pool);
- code->set_constant_pool(*constant_pool);
-
// Allow self references to created code object by patching the handle to
// point to the newly allocated Code object.
if (!self_ref.is_null()) *(self_ref.location()) = *code;
@@ -1561,7 +1522,8 @@
}
-Handle<GlobalObject> Factory::NewGlobalObject(Handle<JSFunction> constructor) {
+Handle<JSGlobalObject> Factory::NewJSGlobalObject(
+ Handle<JSFunction> constructor) {
DCHECK(constructor->has_initial_map());
Handle<Map> map(constructor->initial_map());
DCHECK(map->is_dictionary_map());
@@ -1574,34 +1536,36 @@
// Make sure we don't have a ton of pre-allocated slots in the
// global objects. They will be unused once we normalize the object.
DCHECK(map->unused_property_fields() == 0);
- DCHECK(map->inobject_properties() == 0);
+ DCHECK(map->GetInObjectProperties() == 0);
// Initial size of the backing store to avoid resize of the storage during
// bootstrapping. The size differs between the JS global object ad the
// builtins object.
- int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;
+ int initial_size = 64;
// Allocate a dictionary object for backing storage.
int at_least_space_for = map->NumberOfOwnDescriptors() * 2 + initial_size;
- Handle<NameDictionary> dictionary =
- NameDictionary::New(isolate(), at_least_space_for);
+ Handle<GlobalDictionary> dictionary =
+ GlobalDictionary::New(isolate(), at_least_space_for);
// The global object might be created from an object template with accessors.
// Fill these accessors into the dictionary.
Handle<DescriptorArray> descs(map->instance_descriptors());
for (int i = 0; i < map->NumberOfOwnDescriptors(); i++) {
PropertyDetails details = descs->GetDetails(i);
- DCHECK(details.type() == CALLBACKS); // Only accessors are expected.
- PropertyDetails d(details.attributes(), CALLBACKS, i + 1);
+ // Only accessors are expected.
+ DCHECK_EQ(ACCESSOR_CONSTANT, details.type());
+ PropertyDetails d(details.attributes(), ACCESSOR_CONSTANT, i + 1,
+ PropertyCellType::kMutable);
Handle<Name> name(descs->GetKey(i));
- Handle<Object> value(descs->GetCallbacksObject(i), isolate());
- Handle<PropertyCell> cell = NewPropertyCell(value);
+ Handle<PropertyCell> cell = NewPropertyCell();
+ cell->set_value(descs->GetCallbacksObject(i));
// |dictionary| already contains enough space for all properties.
- USE(NameDictionary::Add(dictionary, name, cell, d));
+ USE(GlobalDictionary::Add(dictionary, name, cell, d));
}
// Allocate the global object and initialize it with the backing store.
- Handle<GlobalObject> global = New<GlobalObject>(map, OLD_POINTER_SPACE);
+ Handle<JSGlobalObject> global = New<JSGlobalObject>(map, OLD_SPACE);
isolate()->heap()->InitializeJSObjectFromMap(*global, *dictionary, *map);
// Create a new map for the global object.
@@ -1613,7 +1577,7 @@
global->set_properties(*dictionary);
// Make sure result is a global object with properties in dictionary.
- DCHECK(global->IsGlobalObject() && !global->HasFastProperties());
+ DCHECK(global->IsJSGlobalObject() && !global->HasFastProperties());
return global;
}
@@ -1621,36 +1585,36 @@
Handle<JSObject> Factory::NewJSObjectFromMap(
Handle<Map> map,
PretenureFlag pretenure,
- bool alloc_props,
Handle<AllocationSite> allocation_site) {
CALL_HEAP_FUNCTION(
isolate(),
isolate()->heap()->AllocateJSObjectFromMap(
*map,
pretenure,
- alloc_props,
allocation_site.is_null() ? NULL : *allocation_site),
JSObject);
}
Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
+ Strength strength,
PretenureFlag pretenure) {
- Context* native_context = isolate()->context()->native_context();
- JSFunction* array_function = native_context->array_function();
- Map* map = array_function->initial_map();
- Map* transition_map = isolate()->get_initial_js_array_map(elements_kind);
- if (transition_map != NULL) map = transition_map;
+ Map* map = isolate()->get_initial_js_array_map(elements_kind, strength);
+ if (map == nullptr) {
+ DCHECK(strength == Strength::WEAK);
+ Context* native_context = isolate()->context()->native_context();
+ JSFunction* array_function = native_context->array_function();
+ map = array_function->initial_map();
+ }
return Handle<JSArray>::cast(NewJSObjectFromMap(handle(map), pretenure));
}
-Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind,
- int length,
- int capacity,
+Handle<JSArray> Factory::NewJSArray(ElementsKind elements_kind, int length,
+ int capacity, Strength strength,
ArrayStorageAllocationMode mode,
PretenureFlag pretenure) {
- Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
+ Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
NewJSArrayStorage(array, length, capacity, mode);
return array;
}
@@ -1658,10 +1622,10 @@
Handle<JSArray> Factory::NewJSArrayWithElements(Handle<FixedArrayBase> elements,
ElementsKind elements_kind,
- int length,
+ int length, Strength strength,
PretenureFlag pretenure) {
DCHECK(length <= elements->length());
- Handle<JSArray> array = NewJSArray(elements_kind, pretenure);
+ Handle<JSArray> array = NewJSArray(elements_kind, strength, pretenure);
array->set_elements(*elements);
array->set_length(Smi::FromInt(length));
@@ -1712,7 +1676,7 @@
DCHECK(function->shared()->is_generator());
JSFunction::EnsureHasInitialMap(function);
Handle<Map> map(function->initial_map());
- DCHECK(map->instance_type() == JS_GENERATOR_OBJECT_TYPE);
+ DCHECK_EQ(JS_GENERATOR_OBJECT_TYPE, map->instance_type());
CALL_HEAP_FUNCTION(
isolate(),
isolate()->heap()->AllocateJSObjectFromMap(*map),
@@ -1720,13 +1684,15 @@
}
-Handle<JSArrayBuffer> Factory::NewJSArrayBuffer() {
+Handle<JSArrayBuffer> Factory::NewJSArrayBuffer(SharedFlag shared,
+ PretenureFlag pretenure) {
Handle<JSFunction> array_buffer_fun(
- isolate()->native_context()->array_buffer_fun());
- CALL_HEAP_FUNCTION(
- isolate(),
- isolate()->heap()->AllocateJSObject(*array_buffer_fun),
- JSArrayBuffer);
+ shared == SharedFlag::kShared
+ ? isolate()->native_context()->shared_array_buffer_fun()
+ : isolate()->native_context()->array_buffer_fun());
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateJSObject(
+ *array_buffer_fun, pretenure),
+ JSArrayBuffer);
}
@@ -1740,6 +1706,22 @@
}
+Handle<JSMap> Factory::NewJSMap() {
+ Handle<Map> map(isolate()->native_context()->js_map_map());
+ Handle<JSMap> js_map = Handle<JSMap>::cast(NewJSObjectFromMap(map));
+ JSMap::Initialize(js_map, isolate());
+ return js_map;
+}
+
+
+Handle<JSSet> Factory::NewJSSet() {
+ Handle<Map> map(isolate()->native_context()->js_set_map());
+ Handle<JSSet> js_set = Handle<JSSet>::cast(NewJSObjectFromMap(map));
+ JSSet::Initialize(js_set, isolate());
+ return js_set;
+}
+
+
Handle<JSMapIterator> Factory::NewJSMapIterator() {
Handle<Map> map(isolate()->native_context()->map_iterator_map());
CALL_HEAP_FUNCTION(isolate(),
@@ -1756,17 +1738,27 @@
}
+Handle<JSIteratorResult> Factory::NewJSIteratorResult(Handle<Object> value,
+ Handle<Object> done) {
+ Handle<JSIteratorResult> result = Handle<JSIteratorResult>::cast(
+ NewJSObjectFromMap(isolate()->iterator_result_map()));
+ result->set_value(*value);
+ result->set_done(*done);
+ return result;
+}
+
+
namespace {
ElementsKind GetExternalArrayElementsKind(ExternalArrayType type) {
switch (type) {
#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
case kExternal##Type##Array: \
- return EXTERNAL_##TYPE##_ELEMENTS;
+ return TYPE##_ELEMENTS;
TYPED_ARRAYS(TYPED_ARRAY_CASE)
}
UNREACHABLE();
- return FIRST_EXTERNAL_ARRAY_ELEMENTS_KIND;
+ return FIRST_FIXED_TYPED_ARRAY_ELEMENTS_KIND;
#undef TYPED_ARRAY_CASE
}
@@ -1777,9 +1769,38 @@
case kExternal##Type##Array: \
return size;
TYPED_ARRAYS(TYPED_ARRAY_CASE)
+ default:
+ UNREACHABLE();
+ return 0;
}
- UNREACHABLE();
- return 0;
+#undef TYPED_ARRAY_CASE
+}
+
+
+size_t GetFixedTypedArraysElementSize(ElementsKind kind) {
+ switch (kind) {
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
+ case TYPE##_ELEMENTS: \
+ return size;
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+ default:
+ UNREACHABLE();
+ return 0;
+ }
+#undef TYPED_ARRAY_CASE
+}
+
+
+ExternalArrayType GetArrayTypeFromElementsKind(ElementsKind kind) {
+ switch (kind) {
+#define TYPED_ARRAY_CASE(Type, type, TYPE, ctype, size) \
+ case TYPE##_ELEMENTS: \
+ return kExternal##Type##Array;
+ TYPED_ARRAYS(TYPED_ARRAY_CASE)
+ default:
+ UNREACHABLE();
+ return kExternalInt8Array;
+ }
#undef TYPED_ARRAY_CASE
}
@@ -1801,24 +1822,39 @@
}
+JSFunction* GetTypedArrayFun(ElementsKind elements_kind, Isolate* isolate) {
+ Context* native_context = isolate->context()->native_context();
+ switch (elements_kind) {
+#define TYPED_ARRAY_FUN(Type, type, TYPE, ctype, size) \
+ case TYPE##_ELEMENTS: \
+ return native_context->type##_array_fun();
+
+ TYPED_ARRAYS(TYPED_ARRAY_FUN)
+#undef TYPED_ARRAY_FUN
+
+ default:
+ UNREACHABLE();
+ return NULL;
+ }
+}
+
+
void SetupArrayBufferView(i::Isolate* isolate,
i::Handle<i::JSArrayBufferView> obj,
i::Handle<i::JSArrayBuffer> buffer,
- size_t byte_offset, size_t byte_length) {
+ size_t byte_offset, size_t byte_length,
+ PretenureFlag pretenure = NOT_TENURED) {
DCHECK(byte_offset + byte_length <=
static_cast<size_t>(buffer->byte_length()->Number()));
obj->set_buffer(*buffer);
- obj->set_weak_next(buffer->weak_first_view());
- buffer->set_weak_first_view(*obj);
-
i::Handle<i::Object> byte_offset_object =
- isolate->factory()->NewNumberFromSize(byte_offset);
+ isolate->factory()->NewNumberFromSize(byte_offset, pretenure);
obj->set_byte_offset(*byte_offset_object);
i::Handle<i::Object> byte_length_object =
- isolate->factory()->NewNumberFromSize(byte_length);
+ isolate->factory()->NewNumberFromSize(byte_length, pretenure);
obj->set_byte_length(*byte_length_object);
}
@@ -1826,21 +1862,32 @@
} // namespace
-Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type) {
+Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
+ PretenureFlag pretenure) {
Handle<JSFunction> typed_array_fun_handle(GetTypedArrayFun(type, isolate()));
- CALL_HEAP_FUNCTION(
- isolate(),
- isolate()->heap()->AllocateJSObject(*typed_array_fun_handle),
- JSTypedArray);
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateJSObject(
+ *typed_array_fun_handle, pretenure),
+ JSTypedArray);
+}
+
+
+Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
+ PretenureFlag pretenure) {
+ Handle<JSFunction> typed_array_fun_handle(
+ GetTypedArrayFun(elements_kind, isolate()));
+
+ CALL_HEAP_FUNCTION(isolate(), isolate()->heap()->AllocateJSObject(
+ *typed_array_fun_handle, pretenure),
+ JSTypedArray);
}
Handle<JSTypedArray> Factory::NewJSTypedArray(ExternalArrayType type,
Handle<JSArrayBuffer> buffer,
- size_t byte_offset,
- size_t length) {
- Handle<JSTypedArray> obj = NewJSTypedArray(type);
+ size_t byte_offset, size_t length,
+ PretenureFlag pretenure) {
+ Handle<JSTypedArray> obj = NewJSTypedArray(type, pretenure);
size_t element_size = GetExternalArrayElementSize(type);
ElementsKind elements_kind = GetExternalArrayElementsKind(type);
@@ -1850,20 +1897,54 @@
CHECK(length <= (std::numeric_limits<size_t>::max() / element_size));
CHECK(length <= static_cast<size_t>(Smi::kMaxValue));
size_t byte_length = length * element_size;
- SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length);
+ SetupArrayBufferView(isolate(), obj, buffer, byte_offset, byte_length,
+ pretenure);
- Handle<Object> length_object = NewNumberFromSize(length);
+ Handle<Object> length_object = NewNumberFromSize(length, pretenure);
obj->set_length(*length_object);
- Handle<ExternalArray> elements = NewExternalArray(
+ Handle<FixedTypedArrayBase> elements = NewFixedTypedArrayWithExternalPointer(
static_cast<int>(length), type,
- static_cast<uint8_t*>(buffer->backing_store()) + byte_offset);
+ static_cast<uint8_t*>(buffer->backing_store()) + byte_offset, pretenure);
Handle<Map> map = JSObject::GetElementsTransitionMap(obj, elements_kind);
JSObject::SetMapAndElements(obj, map, elements);
return obj;
}
+Handle<JSTypedArray> Factory::NewJSTypedArray(ElementsKind elements_kind,
+ size_t number_of_elements,
+ PretenureFlag pretenure) {
+ Handle<JSTypedArray> obj = NewJSTypedArray(elements_kind, pretenure);
+
+ size_t element_size = GetFixedTypedArraysElementSize(elements_kind);
+ ExternalArrayType array_type = GetArrayTypeFromElementsKind(elements_kind);
+
+ CHECK(number_of_elements <=
+ (std::numeric_limits<size_t>::max() / element_size));
+ CHECK(number_of_elements <= static_cast<size_t>(Smi::kMaxValue));
+ size_t byte_length = number_of_elements * element_size;
+
+ obj->set_byte_offset(Smi::FromInt(0));
+ i::Handle<i::Object> byte_length_object =
+ NewNumberFromSize(byte_length, pretenure);
+ obj->set_byte_length(*byte_length_object);
+ Handle<Object> length_object =
+ NewNumberFromSize(number_of_elements, pretenure);
+ obj->set_length(*length_object);
+
+ Handle<JSArrayBuffer> buffer =
+ NewJSArrayBuffer(SharedFlag::kNotShared, pretenure);
+ JSArrayBuffer::Setup(buffer, isolate(), true, NULL, byte_length,
+ SharedFlag::kNotShared);
+ obj->set_buffer(*buffer);
+ Handle<FixedTypedArrayBase> elements = NewFixedTypedArray(
+ static_cast<int>(number_of_elements), array_type, true, pretenure);
+ obj->set_elements(*elements);
+ return obj;
+}
+
+
Handle<JSDataView> Factory::NewJSDataView(Handle<JSArrayBuffer> buffer,
size_t byte_offset,
size_t byte_length) {
@@ -1873,103 +1954,93 @@
}
-Handle<JSProxy> Factory::NewJSProxy(Handle<Object> handler,
- Handle<Object> prototype) {
- // Allocate map.
- // TODO(rossberg): Once we optimize proxies, think about a scheme to share
- // maps. Will probably depend on the identity of the handler object, too.
- Handle<Map> map = NewMap(JS_PROXY_TYPE, JSProxy::kSize);
- map->SetPrototype(prototype);
-
- // Allocate the proxy object.
- Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
- result->InitializeBody(map->instance_size(), Smi::FromInt(0));
- result->set_handler(*handler);
- result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
- return result;
-}
-
-
-Handle<JSProxy> Factory::NewJSFunctionProxy(Handle<Object> handler,
- Handle<Object> call_trap,
- Handle<Object> construct_trap,
- Handle<Object> prototype) {
- // Allocate map.
- // TODO(rossberg): Once we optimize proxies, think about a scheme to share
- // maps. Will probably depend on the identity of the handler object, too.
- Handle<Map> map = NewMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
- map->SetPrototype(prototype);
-
- // Allocate the proxy object.
- Handle<JSFunctionProxy> result = New<JSFunctionProxy>(map, NEW_SPACE);
- result->InitializeBody(map->instance_size(), Smi::FromInt(0));
- result->set_handler(*handler);
- result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
- result->set_call_trap(*call_trap);
- result->set_construct_trap(*construct_trap);
- return result;
-}
-
-
-void Factory::ReinitializeJSProxy(Handle<JSProxy> proxy, InstanceType type,
- int size) {
- DCHECK(type == JS_OBJECT_TYPE || type == JS_FUNCTION_TYPE);
-
- // Allocate fresh map.
- // TODO(rossberg): Once we optimize proxies, cache these maps.
- Handle<Map> map = NewMap(type, size);
-
- // Check that the receiver has at least the size of the fresh object.
- int size_difference = proxy->map()->instance_size() - map->instance_size();
- DCHECK(size_difference >= 0);
-
- map->SetPrototype(handle(proxy->map()->prototype(), proxy->GetIsolate()));
-
- // Allocate the backing storage for the properties.
- int prop_size = map->InitialPropertiesLength();
- Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
-
- Heap* heap = isolate()->heap();
- MaybeHandle<SharedFunctionInfo> shared;
- if (type == JS_FUNCTION_TYPE) {
- OneByteStringKey key(STATIC_CHAR_VECTOR("<freezing call trap>"),
- heap->HashSeed());
- Handle<String> name = InternalizeStringWithKey(&key);
- shared = NewSharedFunctionInfo(name, MaybeHandle<Code>());
+MaybeHandle<JSBoundFunction> Factory::NewJSBoundFunction(
+ Handle<JSReceiver> target_function, Handle<Object> bound_this,
+ Vector<Handle<Object>> bound_args) {
+ DCHECK(target_function->IsCallable());
+ STATIC_ASSERT(Code::kMaxArguments <= FixedArray::kMaxLength);
+ if (bound_args.length() >= Code::kMaxArguments) {
+ THROW_NEW_ERROR(isolate(),
+ NewRangeError(MessageTemplate::kTooManyArguments),
+ JSBoundFunction);
}
- // In order to keep heap in consistent state there must be no allocations
- // before object re-initialization is finished and filler object is installed.
- DisallowHeapAllocation no_allocation;
+ // Determine the prototype of the {target_function}.
+ Handle<Object> prototype;
+ ASSIGN_RETURN_ON_EXCEPTION(isolate(), prototype,
+ Object::GetPrototype(isolate(), target_function),
+ JSBoundFunction);
- // Put in filler if the new object is smaller than the old.
- if (size_difference > 0) {
- Address address = proxy->address();
- heap->CreateFillerObjectAt(address + map->instance_size(), size_difference);
- heap->AdjustLiveBytes(address, -size_difference, Heap::FROM_MUTATOR);
- }
-
- // Reset the map for the object.
- proxy->synchronized_set_map(*map);
- Handle<JSObject> jsobj = Handle<JSObject>::cast(proxy);
-
- // Reinitialize the object from the constructor map.
- heap->InitializeJSObjectFromMap(*jsobj, *properties, *map);
-
- // The current native context is used to set up certain bits.
- // TODO(adamk): Using the current context seems wrong, it should be whatever
- // context the JSProxy originated in. But that context isn't stored anywhere.
- Handle<Context> context(isolate()->native_context());
-
- // Functions require some minimal initialization.
- if (type == JS_FUNCTION_TYPE) {
- map->set_function_with_prototype(true);
- Handle<JSFunction> js_function = Handle<JSFunction>::cast(proxy);
- InitializeFunction(js_function, shared.ToHandleChecked(), context);
+ // Create the [[BoundArguments]] for the result.
+ Handle<FixedArray> bound_arguments;
+ if (bound_args.length() == 0) {
+ bound_arguments = empty_fixed_array();
} else {
- // Provide JSObjects with a constructor.
- map->set_constructor(context->object_function());
+ bound_arguments = NewFixedArray(bound_args.length());
+ for (int i = 0; i < bound_args.length(); ++i) {
+ bound_arguments->set(i, *bound_args[i]);
+ }
}
+
+ // Setup the map for the JSBoundFunction instance.
+ Handle<Map> map = handle(
+ target_function->IsConstructor()
+ ? isolate()->native_context()->bound_function_with_constructor_map()
+ : isolate()
+ ->native_context()
+ ->bound_function_without_constructor_map(),
+ isolate());
+ if (map->prototype() != *prototype) {
+ map = Map::TransitionToPrototype(map, prototype, REGULAR_PROTOTYPE);
+ }
+ DCHECK_EQ(target_function->IsConstructor(), map->is_constructor());
+
+ // Setup the JSBoundFunction instance.
+ Handle<JSBoundFunction> result =
+ Handle<JSBoundFunction>::cast(NewJSObjectFromMap(map));
+ result->set_bound_target_function(*target_function);
+ result->set_bound_this(*bound_this);
+ result->set_bound_arguments(*bound_arguments);
+ result->set_creation_context(*isolate()->native_context());
+ result->set_length(Smi::FromInt(0));
+ result->set_name(*undefined_value(), SKIP_WRITE_BARRIER);
+ return result;
+}
+
+
+// ES6 section 9.5.15 ProxyCreate (target, handler)
+Handle<JSProxy> Factory::NewJSProxy(Handle<JSReceiver> target,
+ Handle<JSReceiver> handler) {
+ // Allocate the proxy object.
+ Handle<Map> map;
+ if (target->IsCallable()) {
+ if (target->IsConstructor()) {
+ map = Handle<Map>(isolate()->proxy_constructor_map());
+ } else {
+ map = Handle<Map>(isolate()->proxy_callable_map());
+ }
+ } else {
+ map = Handle<Map>(isolate()->proxy_map());
+ }
+ DCHECK(map->prototype()->IsNull());
+ Handle<JSProxy> result = New<JSProxy>(map, NEW_SPACE);
+ result->initialize_properties();
+ result->set_target(*target);
+ result->set_handler(*handler);
+ result->set_hash(*undefined_value(), SKIP_WRITE_BARRIER);
+ return result;
+}
+
+
+Handle<JSGlobalProxy> Factory::NewUninitializedJSGlobalProxy() {
+ // Create an empty shell of a JSGlobalProxy that needs to be reinitialized
+ // via ReinitializeJSGlobalProxy later.
+ Handle<Map> map = NewMap(JS_GLOBAL_PROXY_TYPE, JSGlobalProxy::kSize);
+ // Maintain invariant expected from any JSGlobalProxy.
+ map->set_is_access_check_needed(true);
+ CALL_HEAP_FUNCTION(
+ isolate(), isolate()->heap()->AllocateJSObjectFromMap(*map, NOT_TENURED),
+ JSGlobalProxy);
}
@@ -1977,18 +2048,25 @@
Handle<JSFunction> constructor) {
DCHECK(constructor->has_initial_map());
Handle<Map> map(constructor->initial_map(), isolate());
+ Handle<Map> old_map(object->map(), isolate());
// The proxy's hash should be retained across reinitialization.
Handle<Object> hash(object->hash(), isolate());
+ JSObject::InvalidatePrototypeChains(*old_map);
+ if (old_map->is_prototype_map()) {
+ map = Map::Copy(map, "CopyAsPrototypeForJSGlobalProxy");
+ map->set_is_prototype_map(true);
+ }
+ JSObject::UpdatePrototypeUserRegistration(old_map, map, isolate());
+
// Check that the already allocated object has the same size and type as
// objects allocated using the constructor.
- DCHECK(map->instance_size() == object->map()->instance_size());
- DCHECK(map->instance_type() == object->map()->instance_type());
+ DCHECK(map->instance_size() == old_map->instance_size());
+ DCHECK(map->instance_type() == old_map->instance_type());
// Allocate the backing storage for the properties.
- int prop_size = map->InitialPropertiesLength();
- Handle<FixedArray> properties = NewFixedArray(prop_size, TENURED);
+ Handle<FixedArray> properties = empty_fixed_array();
// In order to keep heap in consistent state there must be no allocations
// before object re-initialization is finished.
@@ -2006,39 +2084,17 @@
}
-void Factory::BecomeJSObject(Handle<JSProxy> proxy) {
- ReinitializeJSProxy(proxy, JS_OBJECT_TYPE, JSObject::kHeaderSize);
-}
-
-
-void Factory::BecomeJSFunction(Handle<JSProxy> proxy) {
- ReinitializeJSProxy(proxy, JS_FUNCTION_TYPE, JSFunction::kSize);
-}
-
-
-Handle<TypeFeedbackVector> Factory::NewTypeFeedbackVector(
- const FeedbackVectorSpec& spec) {
- return TypeFeedbackVector::Allocate(isolate(), spec);
-}
-
-
Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
Handle<String> name, int number_of_literals, FunctionKind kind,
Handle<Code> code, Handle<ScopeInfo> scope_info,
Handle<TypeFeedbackVector> feedback_vector) {
DCHECK(IsValidFunctionKind(kind));
- Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(name, code);
+ Handle<SharedFunctionInfo> shared = NewSharedFunctionInfo(
+ name, code, IsConstructable(kind, scope_info->language_mode()));
shared->set_scope_info(*scope_info);
shared->set_feedback_vector(*feedback_vector);
shared->set_kind(kind);
- int literals_array_size = number_of_literals;
- // If the function contains object, regexp or array literals,
- // allocate extra space for a literals array prefix containing the
- // context.
- if (number_of_literals > 0) {
- literals_array_size += JSFunction::kLiteralsPrefixSize;
- }
- shared->set_num_literals(literals_array_size);
+ shared->set_num_literals(number_of_literals);
if (IsGeneratorFunction(kind)) {
shared->set_instance_class_name(isolate()->heap()->Generator_string());
shared->DisableOptimization(kGenerator);
@@ -2048,54 +2104,52 @@
Handle<JSMessageObject> Factory::NewJSMessageObject(
- Handle<String> type,
- Handle<JSArray> arguments,
- int start_position,
- int end_position,
- Handle<Object> script,
+ MessageTemplate::Template message, Handle<Object> argument,
+ int start_position, int end_position, Handle<Object> script,
Handle<Object> stack_frames) {
Handle<Map> map = message_object_map();
- Handle<JSMessageObject> message = New<JSMessageObject>(map, NEW_SPACE);
- message->set_properties(*empty_fixed_array(), SKIP_WRITE_BARRIER);
- message->initialize_elements();
- message->set_elements(*empty_fixed_array(), SKIP_WRITE_BARRIER);
- message->set_type(*type);
- message->set_arguments(*arguments);
- message->set_start_position(start_position);
- message->set_end_position(end_position);
- message->set_script(*script);
- message->set_stack_frames(*stack_frames);
- return message;
+ Handle<JSMessageObject> message_obj = New<JSMessageObject>(map, NEW_SPACE);
+ message_obj->set_properties(*empty_fixed_array(), SKIP_WRITE_BARRIER);
+ message_obj->initialize_elements();
+ message_obj->set_elements(*empty_fixed_array(), SKIP_WRITE_BARRIER);
+ message_obj->set_type(message);
+ message_obj->set_argument(*argument);
+ message_obj->set_start_position(start_position);
+ message_obj->set_end_position(end_position);
+ message_obj->set_script(*script);
+ message_obj->set_stack_frames(*stack_frames);
+ return message_obj;
}
Handle<SharedFunctionInfo> Factory::NewSharedFunctionInfo(
- Handle<String> name,
- MaybeHandle<Code> maybe_code) {
+ Handle<String> name, MaybeHandle<Code> maybe_code, bool is_constructor) {
Handle<Map> map = shared_function_info_map();
- Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map,
- OLD_POINTER_SPACE);
+ Handle<SharedFunctionInfo> share = New<SharedFunctionInfo>(map, OLD_SPACE);
// Set pointer fields.
share->set_name(*name);
Handle<Code> code;
if (!maybe_code.ToHandle(&code)) {
- code = handle(isolate()->builtins()->builtin(Builtins::kIllegal));
+ code = isolate()->builtins()->Illegal();
}
share->set_code(*code);
- share->set_optimized_code_map(Smi::FromInt(0));
+ share->set_optimized_code_map(*cleared_optimized_code_map());
share->set_scope_info(ScopeInfo::Empty(isolate()));
- Code* construct_stub =
- isolate()->builtins()->builtin(Builtins::kJSConstructStubGeneric);
- share->set_construct_stub(construct_stub);
+ Handle<Code> construct_stub =
+ is_constructor ? isolate()->builtins()->JSConstructStubGeneric()
+ : isolate()->builtins()->ConstructedNonConstructable();
+ share->set_construct_stub(*construct_stub);
share->set_instance_class_name(*Object_string());
share->set_function_data(*undefined_value(), SKIP_WRITE_BARRIER);
share->set_script(*undefined_value(), SKIP_WRITE_BARRIER);
share->set_debug_info(*undefined_value(), SKIP_WRITE_BARRIER);
share->set_inferred_name(*empty_string(), SKIP_WRITE_BARRIER);
- FeedbackVectorSpec empty_spec;
+ StaticFeedbackVectorSpec empty_spec;
+ Handle<TypeFeedbackMetadata> feedback_metadata =
+ TypeFeedbackMetadata::New(isolate(), &empty_spec);
Handle<TypeFeedbackVector> feedback_vector =
- NewTypeFeedbackVector(empty_spec);
+ TypeFeedbackVector::New(isolate(), feedback_metadata);
share->set_feedback_vector(*feedback_vector, SKIP_WRITE_BARRIER);
#if TRACE_MAPS
share->set_unique_id(isolate()->GetNextUniqueSharedFunctionInfoId());
@@ -2106,7 +2160,7 @@
// Set integer fields (smi or int, depending on the architecture).
share->set_length(0);
- share->set_formal_parameter_count(0);
+ share->set_internal_formal_parameter_count(0);
share->set_expected_nof_properties(0);
share->set_num_literals(0);
share->set_start_position_and_type(0);
@@ -2116,6 +2170,11 @@
share->set_compiler_hints(0);
share->set_opt_count_and_bailout_reason(0);
+ // Link into the list.
+ Handle<Object> new_noscript_list =
+ WeakFixedArray::Add(noscript_shared_function_infos(), share);
+ isolate()->heap()->set_noscript_shared_function_infos(*new_noscript_list);
+
return share;
}
@@ -2152,12 +2211,6 @@
if (number_string_cache()->get(hash * 2) != *undefined_value()) {
int full_size = isolate()->heap()->FullSizeNumberStringCacheLength();
if (number_string_cache()->length() != full_size) {
- // The first time we have a hash collision, we move to the full sized
- // number string cache. The idea is to have a small number string
- // cache in the snapshot to keep boot-time memory usage down.
- // If we expand the number string cache already while creating
- // the snapshot then that didn't work out.
- DCHECK(!isolate()->serializer_enabled());
Handle<FixedArray> new_cache = NewFixedArray(full_size, TENURED);
isolate()->heap()->set_number_string_cache(*new_cache);
return;
@@ -2196,13 +2249,6 @@
Handle<DebugInfo> Factory::NewDebugInfo(Handle<SharedFunctionInfo> shared) {
- // Get the original code of the function.
- Handle<Code> code(shared->code());
-
- // Create a copy of the code before allocating the debug info object to avoid
- // allocation while setting up the debug info object.
- Handle<Code> original_code(*Factory::CopyCode(code));
-
// Allocate initial fixed array for active break points before allocating the
// debug info object to avoid allocation while setting up the debug info
// object.
@@ -2215,8 +2261,7 @@
Handle<DebugInfo> debug_info =
Handle<DebugInfo>::cast(NewStruct(DEBUG_INFO_TYPE));
debug_info->set_shared(*shared);
- debug_info->set_original_code(*original_code);
- debug_info->set_code(*code);
+ debug_info->set_code(shared->code());
debug_info->set_break_points(*break_points);
// Link debug info to function.
@@ -2228,10 +2273,10 @@
Handle<JSObject> Factory::NewArgumentsObject(Handle<JSFunction> callee,
int length) {
- bool strict_mode_callee = callee->shared()->strict_mode() == STRICT;
+ bool strict_mode_callee = is_strict(callee->shared()->language_mode()) ||
+ !callee->shared()->has_simple_parameters();
Handle<Map> map = strict_mode_callee ? isolate()->strict_arguments_map()
: isolate()->sloppy_arguments_map();
-
AllocationSiteUsageContext context(isolate(), Handle<AllocationSite>(),
false);
DCHECK(!isolate()->has_pending_exception());
@@ -2245,209 +2290,52 @@
}
-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();
-
- 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<JSWeakMap> Factory::NewJSWeakMap() {
+ // TODO(adamk): Currently the map is only created three times per
+ // isolate. If it's created more often, the map should be moved into the
+ // strong root list.
+ Handle<Map> map = NewMap(JS_WEAK_MAP_TYPE, JSWeakMap::kSize);
+ return Handle<JSWeakMap>::cast(NewJSObjectFromMap(map));
}
Handle<Map> Factory::ObjectLiteralMapFromCache(Handle<Context> context,
int number_of_properties,
+ bool is_strong,
bool* is_result_from_cache) {
const int kMapCacheSize = 128;
- if (number_of_properties > kMapCacheSize) {
+ // We do not cache maps for too many properties or when running builtin code.
+ if (number_of_properties > kMapCacheSize ||
+ isolate()->bootstrapper()->IsActive()) {
*is_result_from_cache = false;
- return Map::Create(isolate(), number_of_properties);
+ Handle<Map> map = Map::Create(isolate(), number_of_properties);
+ if (is_strong) map->set_is_strong();
+ return map;
}
*is_result_from_cache = true;
if (number_of_properties == 0) {
// Reuse the initial map of the Object function if the literal has no
- // predeclared properties.
- return handle(context->object_function()->initial_map(), isolate());
+ // predeclared properties, or the strong map if strong.
+ return handle(is_strong
+ ? context->js_object_strong_map()
+ : context->object_function()->initial_map(), isolate());
}
+
int cache_index = number_of_properties - 1;
- if (context->map_cache()->IsUndefined()) {
+ Handle<Object> maybe_cache(is_strong ? context->strong_map_cache()
+ : context->map_cache(), isolate());
+ if (maybe_cache->IsUndefined()) {
// Allocate the new map cache for the native context.
- Handle<FixedArray> new_cache = NewFixedArray(kMapCacheSize, TENURED);
- context->set_map_cache(*new_cache);
- }
- // Check to see whether there is a matching element in the cache.
- Handle<FixedArray> cache(FixedArray::cast(context->map_cache()));
- {
+ maybe_cache = NewFixedArray(kMapCacheSize, TENURED);
+ if (is_strong) {
+ context->set_strong_map_cache(*maybe_cache);
+ } else {
+ context->set_map_cache(*maybe_cache);
+ }
+ } else {
+ // Check to see whether there is a matching element in the cache.
+ Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
Object* result = cache->get(cache_index);
if (result->IsWeakCell()) {
WeakCell* cell = WeakCell::cast(result);
@@ -2457,7 +2345,9 @@
}
}
// Create a new map and add it to the cache.
+ Handle<FixedArray> cache = Handle<FixedArray>::cast(maybe_cache);
Handle<Map> map = Map::Create(isolate(), number_of_properties);
+ if (is_strong) map->set_is_strong();
Handle<WeakCell> cell = NewWeakCell(map);
cache->set(cache_index, *cell);
return map;
@@ -2473,7 +2363,7 @@
store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
store->set(JSRegExp::kSourceIndex, *source);
- store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
+ store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags));
store->set(JSRegExp::kAtomPatternIndex, *data);
regexp->set_data(*store);
}
@@ -2488,7 +2378,7 @@
Smi* uninitialized = Smi::FromInt(JSRegExp::kUninitializedValue);
store->set(JSRegExp::kTagIndex, Smi::FromInt(type));
store->set(JSRegExp::kSourceIndex, *source);
- store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags.value()));
+ store->set(JSRegExp::kFlagsIndex, Smi::FromInt(flags));
store->set(JSRegExp::kIrregexpLatin1CodeIndex, uninitialized);
store->set(JSRegExp::kIrregexpUC16CodeIndex, uninitialized);
store->set(JSRegExp::kIrregexpLatin1CodeSavedIndex, uninitialized);
@@ -2500,25 +2390,10 @@
}
-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();
- if (String::Equals(name, infinity_string())) return infinity_value();
+Handle<Object> Factory::GlobalConstantFor(Handle<Name> name) {
+ if (Name::Equals(name, undefined_string())) return undefined_value();
+ if (Name::Equals(name, nan_string())) return nan_value();
+ if (Name::Equals(name, infinity_string())) return infinity_value();
return Handle<Object>::null();
}
@@ -2528,4 +2403,5 @@
}
-} } // namespace v8::internal
+} // namespace internal
+} // namespace v8