Revision: 20813
Author: [email protected]
Date: Wed Apr 16 14:15:32 2014 UTC
Log: Reland r20772 "Handlifying clients of StringTable, step 1."
[email protected]
Review URL: https://codereview.chromium.org/238263003
http://code.google.com/p/v8/source/detail?r=20813
Modified:
/branches/bleeding_edge/src/factory.cc
/branches/bleeding_edge/src/factory.h
/branches/bleeding_edge/src/heap.cc
/branches/bleeding_edge/src/heap.h
/branches/bleeding_edge/src/objects.cc
/branches/bleeding_edge/src/objects.h
/branches/bleeding_edge/src/runtime.cc
=======================================
--- /branches/bleeding_edge/src/factory.cc Wed Apr 16 14:04:54 2014 UTC
+++ /branches/bleeding_edge/src/factory.cc Wed Apr 16 14:15:32 2014 UTC
@@ -37,6 +37,16 @@
result->set_value(*value);
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);
+ return oddball;
+}
Handle<FixedArray> Factory::NewFixedArray(int size, PretenureFlag
pretenure) {
=======================================
--- /branches/bleeding_edge/src/factory.h Wed Apr 16 14:04:54 2014 UTC
+++ /branches/bleeding_edge/src/factory.h Wed Apr 16 14:15:32 2014 UTC
@@ -14,6 +14,11 @@
class Factory V8_FINAL {
public:
+ Handle<Oddball> NewOddball(Handle<Map> map,
+ const char* to_string,
+ Handle<Object> to_number,
+ byte kind);
+
// Allocates a fixed array initialized with undefined values.
Handle<FixedArray> NewFixedArray(
int size,
=======================================
--- /branches/bleeding_edge/src/heap.cc Wed Apr 16 14:04:54 2014 UTC
+++ /branches/bleeding_edge/src/heap.cc Wed Apr 16 14:15:32 2014 UTC
@@ -2722,18 +2722,6 @@
cell->set_type(HeapType::None());
return result;
}
-
-
-MaybeObject* Heap::CreateOddball(Map* map,
- const char* to_string,
- Object* to_number,
- byte kind) {
- Object* result;
- { MaybeObject* maybe_result = Allocate(map, OLD_POINTER_SPACE);
- if (!maybe_result->ToObject(&result)) return maybe_result;
- }
- return Oddball::cast(result)->Initialize(this, to_string, to_number,
kind);
-}
bool Heap::CreateApiObjects() {
@@ -2808,115 +2796,82 @@
bool Heap::CreateInitialObjects() {
- Object* obj;
+ HandleScope scope(isolate());
+ Factory* factory = isolate()->factory();
// The -0 value must be set before NumberFromDouble works.
- { MaybeObject* maybe_obj = AllocateHeapNumber(-0.0, TENURED);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_minus_zero_value(HeapNumber::cast(obj));
+ set_minus_zero_value(*factory->NewHeapNumber(-0.0, TENURED));
ASSERT(std::signbit(minus_zero_value()->Number()) != 0);
- { MaybeObject* maybe_obj = AllocateHeapNumber(OS::nan_value(), TENURED);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_nan_value(HeapNumber::cast(obj));
-
- { MaybeObject* maybe_obj = AllocateHeapNumber(V8_INFINITY, TENURED);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_infinity_value(HeapNumber::cast(obj));
+ set_nan_value(*factory->NewHeapNumber(OS::nan_value(), TENURED));
+ set_infinity_value(*factory->NewHeapNumber(V8_INFINITY, TENURED));
// The hole has not been created yet, but we want to put something
// predictable in the gaps in the string table, so lets make that Smi
zero.
set_the_hole_value(reinterpret_cast<Oddball*>(Smi::FromInt(0)));
// Allocate initial string table.
- { MaybeObject* maybe_obj =
- StringTable::Allocate(this, kInitialStringTableSize);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- // Don't use set_string_table() due to asserts.
- roots_[kStringTableRootIndex] = obj;
+ set_string_table(*StringTable::New(isolate(), kInitialStringTableSize));
// Finish initializing oddballs after creating the string table.
- { MaybeObject* maybe_obj =
- undefined_value()->Initialize(this,
- "undefined",
- nan_value(),
- Oddball::kUndefined);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
+ Oddball::Initialize(isolate(),
+ factory->undefined_value(),
+ "undefined",
+ factory->nan_value(),
+ Oddball::kUndefined);
// Initialize the null_value.
- { MaybeObject* maybe_obj = null_value()->Initialize(
- this, "null", Smi::FromInt(0), Oddball::kNull);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
+ Oddball::Initialize(isolate(),
+ factory->null_value(),
+ "null",
+ handle(Smi::FromInt(0), isolate()),
+ Oddball::kNull);
- { MaybeObject* maybe_obj = CreateOddball(boolean_map(),
- "true",
- Smi::FromInt(1),
- Oddball::kTrue);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_true_value(Oddball::cast(obj));
+ set_true_value(*factory->NewOddball(factory->boolean_map(),
+ "true",
+ handle(Smi::FromInt(1), isolate()),
+ Oddball::kTrue));
- { MaybeObject* maybe_obj = CreateOddball(boolean_map(),
- "false",
- Smi::FromInt(0),
- Oddball::kFalse);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_false_value(Oddball::cast(obj));
+ set_false_value(*factory->NewOddball(factory->boolean_map(),
+ "false",
+ handle(Smi::FromInt(0), isolate()),
+ Oddball::kFalse));
- { MaybeObject* maybe_obj = CreateOddball(the_hole_map(),
- "hole",
- Smi::FromInt(-1),
- Oddball::kTheHole);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_the_hole_value(Oddball::cast(obj));
+ set_the_hole_value(*factory->NewOddball(factory->the_hole_map(),
+ "hole",
+ handle(Smi::FromInt(-1),
isolate()),
+ Oddball::kTheHole));
- { MaybeObject* maybe_obj = CreateOddball(uninitialized_map(),
- "uninitialized",
- Smi::FromInt(-1),
- Oddball::kUninitialized);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_uninitialized_value(Oddball::cast(obj));
+ set_uninitialized_value(
+ *factory->NewOddball(factory->uninitialized_map(),
+ "uninitialized",
+ handle(Smi::FromInt(-1), isolate()),
+ Oddball::kUninitialized));
- { MaybeObject* maybe_obj = CreateOddball(arguments_marker_map(),
- "arguments_marker",
- Smi::FromInt(-4),
- Oddball::kArgumentMarker);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_arguments_marker(Oddball::cast(obj));
+
set_arguments_marker(*factory->NewOddball(factory->arguments_marker_map(),
+ "arguments_marker",
+ handle(Smi::FromInt(-4),
isolate()),
+ Oddball::kArgumentMarker));
- { MaybeObject* maybe_obj =
CreateOddball(no_interceptor_result_sentinel_map(),
- "no_interceptor_result_sentinel",
- Smi::FromInt(-2),
- Oddball::kOther);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_no_interceptor_result_sentinel(Oddball::cast(obj));
+ set_no_interceptor_result_sentinel(
+ *factory->NewOddball(factory->no_interceptor_result_sentinel_map(),
+ "no_interceptor_result_sentinel",
+ handle(Smi::FromInt(-2), isolate()),
+ Oddball::kOther));
- { MaybeObject* maybe_obj = CreateOddball(termination_exception_map(),
- "termination_exception",
- Smi::FromInt(-3),
- Oddball::kOther);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- set_termination_exception(Oddball::cast(obj));
+ set_termination_exception(
+ *factory->NewOddball(factory->termination_exception_map(),
+ "termination_exception",
+ handle(Smi::FromInt(-3), isolate()),
+ Oddball::kOther));
for (unsigned i = 0; i < ARRAY_SIZE(constant_string_table); i++) {
- { MaybeObject* maybe_obj =
- InternalizeUtf8String(constant_string_table[i].contents);
- if (!maybe_obj->ToObject(&obj)) return false;
- }
- roots_[constant_string_table[i].index] = String::cast(obj);
+ Handle<String> str =
+ factory->InternalizeUtf8String(constant_string_table[i].contents);
+ roots_[constant_string_table[i].index] = *str;
}
+
+ Object* obj;
// Allocate the hidden string which is used to identify the hidden
properties
// in JSObjects. The hash code has a special value so that it will not
match
@@ -2957,11 +2912,12 @@
CreateFixedStubs();
// Allocate the dictionary of intrinsic function names.
- { MaybeObject* maybe_obj =
- NameDictionary::Allocate(this, Runtime::kNumFunctions);
- if (!maybe_obj->ToObject(&obj)) return false;
+ {
+ Handle<NameDictionary> function_names =
+ NameDictionary::New(isolate(), Runtime::kNumFunctions);
+ Runtime::InitializeIntrinsicFunctionNames(isolate(), function_names);
+ set_intrinsic_function_names(*function_names);
}
- set_intrinsic_function_names(NameDictionary::cast(obj));
{ MaybeObject* maybe_obj = AllocateInitialNumberStringCache();
if (!maybe_obj->ToObject(&obj)) return false;
@@ -3160,60 +3116,58 @@
}
-void RegExpResultsCache::Enter(Heap* heap,
- String* key_string,
- Object* key_pattern,
- FixedArray* value_array,
+void RegExpResultsCache::Enter(Isolate* isolate,
+ Handle<String> key_string,
+ Handle<Object> key_pattern,
+ Handle<FixedArray> value_array,
ResultsCacheType type) {
- FixedArray* cache;
+ Factory* factory = isolate->factory();
+ Handle<FixedArray> cache;
if (!key_string->IsInternalizedString()) return;
if (type == STRING_SPLIT_SUBSTRINGS) {
ASSERT(key_pattern->IsString());
if (!key_pattern->IsInternalizedString()) return;
- cache = heap->string_split_cache();
+ cache = factory->string_split_cache();
} else {
ASSERT(type == REGEXP_MULTIPLE_INDICES);
ASSERT(key_pattern->IsFixedArray());
- cache = heap->regexp_multiple_cache();
+ cache = factory->regexp_multiple_cache();
}
uint32_t hash = key_string->Hash();
uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
~(kArrayEntriesPerCacheEntry - 1));
if (cache->get(index + kStringOffset) == Smi::FromInt(0)) {
- cache->set(index + kStringOffset, key_string);
- cache->set(index + kPatternOffset, key_pattern);
- cache->set(index + kArrayOffset, value_array);
+ cache->set(index + kStringOffset, *key_string);
+ cache->set(index + kPatternOffset, *key_pattern);
+ cache->set(index + kArrayOffset, *value_array);
} else {
uint32_t index2 =
((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize -
1));
if (cache->get(index2 + kStringOffset) == Smi::FromInt(0)) {
- cache->set(index2 + kStringOffset, key_string);
- cache->set(index2 + kPatternOffset, key_pattern);
- cache->set(index2 + kArrayOffset, value_array);
+ cache->set(index2 + kStringOffset, *key_string);
+ cache->set(index2 + kPatternOffset, *key_pattern);
+ cache->set(index2 + kArrayOffset, *value_array);
} else {
cache->set(index2 + kStringOffset, Smi::FromInt(0));
cache->set(index2 + kPatternOffset, Smi::FromInt(0));
cache->set(index2 + kArrayOffset, Smi::FromInt(0));
- cache->set(index + kStringOffset, key_string);
- cache->set(index + kPatternOffset, key_pattern);
- cache->set(index + kArrayOffset, value_array);
+ cache->set(index + kStringOffset, *key_string);
+ cache->set(index + kPatternOffset, *key_pattern);
+ cache->set(index + kArrayOffset, *value_array);
}
}
// If the array is a reasonably short list of substrings, convert it
into a
// list of internalized strings.
if (type == STRING_SPLIT_SUBSTRINGS && value_array->length() < 100) {
for (int i = 0; i < value_array->length(); i++) {
- String* str = String::cast(value_array->get(i));
- Object* internalized_str;
- MaybeObject* maybe_string = heap->InternalizeString(str);
- if (maybe_string->ToObject(&internalized_str)) {
- value_array->set(i, internalized_str);
- }
+ Handle<String> str(String::cast(value_array->get(i)), isolate);
+ Handle<String> internalized_str = factory->InternalizeString(str);
+ value_array->set(i, *internalized_str);
}
}
// Convert backing store to a copy-on-write array.
- value_array->set_map_no_write_barrier(heap->fixed_cow_array_map());
+ value_array->set_map_no_write_barrier(*factory->fixed_cow_array_map());
}
@@ -5578,16 +5532,12 @@
// Create initial objects
if (!CreateInitialObjects()) return false;
+ CHECK_EQ(0, gc_count_);
native_contexts_list_ = undefined_value();
array_buffers_list_ = undefined_value();
allocation_sites_list_ = undefined_value();
weak_object_to_code_table_ = undefined_value();
-
- HandleScope scope(isolate());
- Runtime::InitializeIntrinsicFunctionNames(
- isolate(), handle(intrinsic_function_names(), isolate()));
-
return true;
}
=======================================
--- /branches/bleeding_edge/src/heap.h Wed Apr 16 14:04:54 2014 UTC
+++ /branches/bleeding_edge/src/heap.h Wed Apr 16 14:15:32 2014 UTC
@@ -2009,11 +2009,6 @@
void CreateFixedStubs();
- MUST_USE_RESULT MaybeObject* CreateOddball(Map* map,
- const char* to_string,
- Object* to_number,
- byte kind);
-
// Allocate empty fixed array.
MUST_USE_RESULT MaybeObject* AllocateEmptyFixedArray();
@@ -2787,10 +2782,10 @@
ResultsCacheType type);
// Attempt to add value_array to the cache specified by type. On
success,
// value_array is turned into a COW-array.
- static void Enter(Heap* heap,
- String* key_string,
- Object* key_pattern,
- FixedArray* value_array,
+ static void Enter(Isolate* isolate,
+ Handle<String> key_string,
+ Handle<Object> key_pattern,
+ Handle<FixedArray> value_array,
ResultsCacheType type);
static void Clear(FixedArray* cache);
static const int kRegExpResultsCacheSize = 0x100;
=======================================
--- /branches/bleeding_edge/src/objects.cc Wed Apr 16 13:28:11 2014 UTC
+++ /branches/bleeding_edge/src/objects.cc Wed Apr 16 14:15:32 2014 UTC
@@ -10393,20 +10393,16 @@
}
-MaybeObject* Oddball::Initialize(Heap* heap,
- const char* to_string,
- Object* to_number,
- byte kind) {
- String* internalized_to_string;
- { MaybeObject* maybe_string =
- heap->InternalizeUtf8String(
- CStrVector(to_string));
- if (!maybe_string->To(&internalized_to_string)) return maybe_string;
- }
- set_to_string(internalized_to_string);
- set_to_number(to_number);
- set_kind(kind);
- return this;
+void Oddball::Initialize(Isolate* isolate,
+ Handle<Oddball> oddball,
+ const char* to_string,
+ Handle<Object> to_number,
+ byte kind) {
+ Handle<String> internalized_to_string =
+ isolate->factory()->InternalizeUtf8String(CStrVector(to_string));
+ oddball->set_to_string(*internalized_to_string);
+ oddball->set_to_number(*to_number);
+ oddball->set_kind(kind);
}
@@ -14874,6 +14870,10 @@
template MaybeObject* Dictionary<NameDictionary, NameDictionaryShape,
Name*>::
Allocate(Heap* heap, int n, PretenureFlag pretenure);
+template Handle<NameDictionary>
+Dictionary<NameDictionary, NameDictionaryShape, Name*>::
+ New(Isolate* isolate, int n, PretenureFlag pretenure);
+
template MaybeObject*
Dictionary<SeededNumberDictionary, SeededNumberDictionaryShape, uint32_t>::
AtPut(uint32_t, Object*);
@@ -14926,6 +14926,10 @@
int,
JSObject::DeleteMode);
+template Handle<NameDictionary>
+HashTable<NameDictionary, NameDictionaryShape, Name*>::
+ New(Isolate*, int, MinimumCapacity, PretenureFlag);
+
template Handle<NameDictionary>
HashTable<NameDictionary, NameDictionaryShape, Name*>::
Shrink(Handle<NameDictionary>, Name* n);
@@ -15786,6 +15790,23 @@
SetNextEnumerationIndex(PropertyDetails::kInitialIndex);
return obj;
}
+
+
+template<typename Derived, typename Shape, typename Key>
+Handle<Derived> Dictionary<Derived, Shape, Key>::New(
+ Isolate* isolate,
+ int at_least_space_for,
+ PretenureFlag pretenure) {
+ Handle<Derived> dict = DerivedHashTable::New(isolate,
+ at_least_space_for,
+
USE_DEFAULT_MINIMUM_CAPACITY,
+ pretenure);
+
+ // Initialize the next enumeration index.
+ dict->SetNextEnumerationIndex(PropertyDetails::kInitialIndex);
+ return dict;
+}
+
void NameDictionary::DoGenerateNewEnumerationIndices(
=======================================
--- /branches/bleeding_edge/src/objects.h Wed Apr 16 13:28:11 2014 UTC
+++ /branches/bleeding_edge/src/objects.h Wed Apr 16 14:15:32 2014 UTC
@@ -4054,6 +4054,12 @@
int at_least_space_for,
PretenureFlag pretenure = NOT_TENURED);
+ // Creates a new dictionary.
+ static Handle<Derived> New(
+ Isolate* isolate,
+ int at_least_space_for,
+ PretenureFlag pretenure = NOT_TENURED);
+
// Ensure enough space for n additional elements.
MUST_USE_RESULT MaybeObject* EnsureCapacity(int n, Key key);
@@ -9757,10 +9763,11 @@
DECLARE_VERIFIER(Oddball)
// Initialize the fields.
- MUST_USE_RESULT MaybeObject* Initialize(Heap* heap,
- const char* to_string,
- Object* to_number,
- byte kind);
+ static void Initialize(Isolate* isolate,
+ Handle<Oddball> oddball,
+ const char* to_string,
+ Handle<Object> to_number,
+ byte kind);
// Layout description.
static const int kToStringOffset = HeapObject::kHeaderSize;
=======================================
--- /branches/bleeding_edge/src/runtime.cc Wed Apr 16 14:11:30 2014 UTC
+++ /branches/bleeding_edge/src/runtime.cc Wed Apr 16 14:15:32 2014 UTC
@@ -4730,10 +4730,10 @@
fixed_array->set(fixed_array->length() - 1,
Smi::FromInt(builder.length()));
// Cache the result and turn the FixedArray into a COW array.
- RegExpResultsCache::Enter(isolate->heap(),
- *subject,
- regexp->data(),
- *fixed_array,
+ RegExpResultsCache::Enter(isolate,
+ subject,
+ handle(regexp->data(), isolate),
+ fixed_array,
RegExpResultsCache::REGEXP_MULTIPLE_INDICES);
}
return *builder.ToJSArray(result_array);
@@ -6757,10 +6757,10 @@
if (limit == 0xffffffffu) {
if (result->HasFastObjectElements()) {
- RegExpResultsCache::Enter(isolate->heap(),
- *subject,
- *pattern,
- *elements,
+ RegExpResultsCache::Enter(isolate,
+ subject,
+ pattern,
+ elements,
RegExpResultsCache::STRING_SPLIT_SUBSTRINGS);
}
}
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
