i::Handle<i::String> string = i_isolate->factory()
->NewExternalStringFromTwoByte(resource)
.ToHandleChecked();
- i_isolate->heap()->external_string_table()->AddString(*string);
+ i_isolate->heap()->RegisterExternalString(*string);
return Utils::ToLocal(string);
}
i::Handle<i::String> string = i_isolate->factory()
->NewExternalStringFromOneByte(resource)
.ToHandleChecked();
- i_isolate->heap()->external_string_table()->AddString(*string);
+ i_isolate->heap()->RegisterExternalString(*string);
return Utils::ToLocal(string);
}
DCHECK(!CanMakeExternal() || result);
if (result) {
DCHECK(obj->IsExternalString());
- isolate->heap()->external_string_table()->AddString(*obj);
+ isolate->heap()->RegisterExternalString(*obj);
}
return result;
}
DCHECK(!CanMakeExternal() || result);
if (result) {
DCHECK(obj->IsExternalString());
- isolate->heap()->external_string_table()->AddString(*obj);
+ isolate->heap()->RegisterExternalString(*obj);
}
return result;
}
}
+void Heap::RegisterExternalString(String* string) {
+ external_string_table_.AddString(string);
+}
+
+
void Heap::FinalizeExternalString(String* string) {
DCHECK(string->IsExternalString());
v8::String::ExternalStringResourceBase** resource_addr =
CALL_AND_RETRY_OR_DIE(ISOLATE, FUNCTION_CALL, return, return)
-void ExternalStringTable::AddString(String* string) {
+void Heap::ExternalStringTable::AddString(String* string) {
DCHECK(string->IsExternalString());
if (heap_->InNewSpace(string)) {
new_space_strings_.Add(string);
}
-void ExternalStringTable::Iterate(ObjectVisitor* v) {
+void Heap::ExternalStringTable::Iterate(ObjectVisitor* v) {
if (!new_space_strings_.is_empty()) {
Object** start = &new_space_strings_[0];
v->VisitPointers(start, start + new_space_strings_.length());
// Verify() is inline to avoid ifdef-s around its calls in release
// mode.
-void ExternalStringTable::Verify() {
+void Heap::ExternalStringTable::Verify() {
#ifdef DEBUG
for (int i = 0; i < new_space_strings_.length(); ++i) {
Object* obj = Object::cast(new_space_strings_[i]);
}
-void ExternalStringTable::AddOldString(String* string) {
+void Heap::ExternalStringTable::AddOldString(String* string) {
DCHECK(string->IsExternalString());
DCHECK(!heap_->InNewSpace(string));
old_space_strings_.Add(string);
}
-void ExternalStringTable::ShrinkNewStrings(int position) {
+void Heap::ExternalStringTable::ShrinkNewStrings(int position) {
new_space_strings_.Rewind(position);
#ifdef VERIFY_HEAP
if (FLAG_verify_heap) {
PRIVATE_SYMBOL_LIST(V)
// Forward declarations.
+class HeapObjectsFilter;
class HeapStats;
class Isolate;
class MemoryReducer;
class WeakObjectRetainer;
-typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,
- Object** pointer);
-
-
// A queue of objects promoted during scavenge. Each object is accompanied
// by it's size to avoid dereferencing a map pointer for scanning.
// The last page in to-space is used for the promotion queue. On conflict
HeapObject* object);
-// External strings table is a place where all external strings are
-// registered. We need to keep track of such strings to properly
-// finalize them.
-class ExternalStringTable {
- public:
- // Registers an external string.
- inline void AddString(String* string);
-
- inline void Iterate(ObjectVisitor* v);
-
- // Restores internal invariant and gets rid of collected strings.
- // Must be called after each Iterate() that modified the strings.
- void CleanUp();
-
- // Destroys all allocated memory.
- void TearDown();
-
- private:
- explicit ExternalStringTable(Heap* heap) : heap_(heap) {}
-
- friend class Heap;
-
- inline void Verify();
-
- inline void AddOldString(String* string);
-
- // Notifies the table that only a prefix of the new list is valid.
- inline void ShrinkNewStrings(int position);
-
- // To speed up scavenge collections new space string are kept
- // separate from old space strings.
- List<Object*> new_space_strings_;
- List<Object*> old_space_strings_;
-
- Heap* heap_;
-
- DISALLOW_COPY_AND_ASSIGN(ExternalStringTable);
-};
-
-
enum ArrayStorageAllocationMode {
DONT_INITIALIZE_ARRAY_ELEMENTS,
INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE
// index.
void MoveElements(FixedArray* array, int dst_index, int src_index, int len);
- // Finalizes an external string by deleting the associated external
- // data and clearing the resource pointer.
- inline void FinalizeExternalString(String* string);
-
// Initialize a filler object to keep the ability to iterate over the heap
// when introducing gaps within pages.
void CreateFillerObjectAt(Address addr, int size);
return &mark_compact_collector_;
}
- ExternalStringTable* external_string_table() {
- return &external_string_table_;
- }
-
// ===========================================================================
// Root set access. ==========================================================
// ===========================================================================
IncrementalMarking* incremental_marking() { return &incremental_marking_; }
// ===========================================================================
+ // External string table API. ================================================
+ // ===========================================================================
+
+ // Registers an external string.
+ inline void RegisterExternalString(String* string);
+
+ // Finalizes an external string by deleting the associated external
+ // data and clearing the resource pointer.
+ inline void FinalizeExternalString(String* string);
+
+ // ===========================================================================
// Methods checking/returning the space of a given object/address. ===========
// ===========================================================================
private:
class UnmapFreeMemoryTask;
+ // External strings table is a place where all external strings are
+ // registered. We need to keep track of such strings to properly
+ // finalize them.
+ class ExternalStringTable {
+ public:
+ // Registers an external string.
+ inline void AddString(String* string);
+
+ inline void Iterate(ObjectVisitor* v);
+
+ // Restores internal invariant and gets rid of collected strings.
+ // Must be called after each Iterate() that modified the strings.
+ void CleanUp();
+
+ // Destroys all allocated memory.
+ void TearDown();
+
+ private:
+ explicit ExternalStringTable(Heap* heap) : heap_(heap) {}
+
+ inline void Verify();
+
+ inline void AddOldString(String* string);
+
+ // Notifies the table that only a prefix of the new list is valid.
+ inline void ShrinkNewStrings(int position);
+
+ // To speed up scavenge collections new space string are kept
+ // separate from old space strings.
+ List<Object*> new_space_strings_;
+ List<Object*> old_space_strings_;
+
+ Heap* heap_;
+
+ friend class Heap;
+
+ DISALLOW_COPY_AND_ASSIGN(ExternalStringTable);
+ };
+
struct StrongRootsList;
struct StringTypeTable {
bool pass_isolate;
};
+ typedef String* (*ExternalStringTableUpdaterCallback)(Heap* heap,
+ Object** pointer);
+
static const int kInitialStringTableSize = 2048;
static const int kInitialEvalCacheSize = 64;
static const int kInitialNumberStringCacheSize = 256;
// nodes filtering uses GC marks, it can't be used during MS/MC GC
// phases. Also, it is forbidden to interrupt iteration in this mode,
// as this will leave heap objects marked (and thus, unusable).
-class HeapObjectsFilter;
-
class HeapIterator BASE_EMBEDDED {
public:
enum HeapObjectsFiltering { kNoFiltering, kFilterUnreachable };
projects / platform / upstream / v8.git / commitdiff