blob: 7ce9263125d563d84f21838a0ae9f26b5535abc9 [file] [log] [blame]
ulan@chromium.org2efb9002012-01-19 15:36:35 +00001// Copyright 2012 the V8 project authors. All rights reserved.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6// * Redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer.
8// * Redistributions in binary form must reproduce the above
9// copyright notice, this list of conditions and the following
10// disclaimer in the documentation and/or other materials provided
11// with the distribution.
12// * Neither the name of Google Inc. nor the names of its
13// contributors may be used to endorse or promote products derived
14// from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#include "v8.h"
29
30#include "accessors.h"
31#include "api.h"
32#include "bootstrapper.h"
karlklose@chromium.org44bc7082011-04-11 12:33:05 +000033#include "codegen.h"
kasperl@chromium.orgb9123622008-09-17 14:05:56 +000034#include "compilation-cache.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000035#include "debug.h"
ricow@chromium.org4f693d62011-07-04 14:01:31 +000036#include "deoptimizer.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000037#include "global-handles.h"
fschneider@chromium.orgfb144a02011-05-04 12:43:48 +000038#include "heap-profiler.h"
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000039#include "incremental-marking.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000040#include "mark-compact.h"
41#include "natives.h"
ager@chromium.orgea4f62e2010-08-16 16:28:43 +000042#include "objects-visiting.h"
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000043#include "objects-visiting-inl.h"
fschneider@chromium.org7d10be52012-04-10 12:30:14 +000044#include "once.h"
kasperl@chromium.orga5551262010-12-07 12:49:48 +000045#include "runtime-profiler.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000046#include "scopeinfo.h"
ager@chromium.org3811b432009-10-28 14:53:37 +000047#include "snapshot.h"
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000048#include "store-buffer.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000049#include "v8threads.h"
ulan@chromium.org56c14af2012-09-20 12:51:09 +000050#include "v8utils.h"
kasperl@chromium.orga5551262010-12-07 12:49:48 +000051#include "vm-state-inl.h"
ricow@chromium.orgc9c80822010-04-21 08:22:37 +000052#if V8_TARGET_ARCH_ARM && !V8_INTERPRETED_REGEXP
ager@chromium.org18ad94b2009-09-02 08:22:29 +000053#include "regexp-macro-assembler.h"
ager@chromium.org3811b432009-10-28 14:53:37 +000054#include "arm/regexp-macro-assembler-arm.h"
ager@chromium.org18ad94b2009-09-02 08:22:29 +000055#endif
lrn@chromium.org7516f052011-03-30 08:52:27 +000056#if V8_TARGET_ARCH_MIPS && !V8_INTERPRETED_REGEXP
57#include "regexp-macro-assembler.h"
58#include "mips/regexp-macro-assembler-mips.h"
59#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000060
kasperl@chromium.org71affb52009-05-26 05:44:31 +000061namespace v8 {
62namespace internal {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000063
kasper.lund7276f142008-07-30 08:49:36 +000064
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000065Heap::Heap()
66 : isolate_(NULL),
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000067// semispace_size_ should be a power of 2 and old_generation_size_ should be
68// a multiple of Page::kPageSize.
mmassi@chromium.org7028c052012-06-13 11:51:58 +000069#if defined(V8_TARGET_ARCH_X64)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000070#define LUMP_OF_MEMORY (2 * MB)
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000071 code_range_size_(512*MB),
ager@chromium.orgeadaf222009-06-16 09:43:10 +000072#else
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000073#define LUMP_OF_MEMORY MB
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000074 code_range_size_(0),
ager@chromium.orgeadaf222009-06-16 09:43:10 +000075#endif
mmassi@chromium.org7028c052012-06-13 11:51:58 +000076#if defined(ANDROID)
77 reserved_semispace_size_(4 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
78 max_semispace_size_(4 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
79 initial_semispace_size_(Page::kPageSize),
80 max_old_generation_size_(192*MB),
81 max_executable_size_(max_old_generation_size_),
82#else
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000083 reserved_semispace_size_(8 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
84 max_semispace_size_(8 * Max(LUMP_OF_MEMORY, Page::kPageSize)),
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +000085 initial_semispace_size_(Page::kPageSize),
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000086 max_old_generation_size_(700ul * LUMP_OF_MEMORY),
rossberg@chromium.org2c067b12012-03-19 11:01:52 +000087 max_executable_size_(256l * LUMP_OF_MEMORY),
mmassi@chromium.org7028c052012-06-13 11:51:58 +000088#endif
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000089
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000090// Variables set based on semispace_size_ and old_generation_size_ in
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000091// ConfigureHeap (survived_since_last_expansion_, external_allocation_limit_)
ager@chromium.org3811b432009-10-28 14:53:37 +000092// Will be 4 * reserved_semispace_size_ to ensure that young
93// generation can be aligned to its size.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000094 survived_since_last_expansion_(0),
jkummerow@chromium.orgddda9e82011-07-06 11:27:02 +000095 sweep_generation_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000096 always_allocate_scope_depth_(0),
97 linear_allocation_scope_depth_(0),
98 contexts_disposed_(0),
danno@chromium.org88aa0582012-03-23 15:11:57 +000099 global_ic_age_(0),
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000100 flush_monomorphic_ics_(false),
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000101 scan_on_scavenge_pages_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000102 new_space_(this),
103 old_pointer_space_(NULL),
104 old_data_space_(NULL),
105 code_space_(NULL),
106 map_space_(NULL),
107 cell_space_(NULL),
108 lo_space_(NULL),
109 gc_state_(NOT_IN_GC),
erik.corry@gmail.comd6076d92011-06-06 09:39:18 +0000110 gc_post_processing_depth_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000111 ms_count_(0),
112 gc_count_(0),
rossberg@chromium.org2c067b12012-03-19 11:01:52 +0000113 remembered_unmapped_pages_index_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000114 unflattened_strings_length_(0),
kasper.lund7276f142008-07-30 08:49:36 +0000115#ifdef DEBUG
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000116 allocation_allowed_(true),
117 allocation_timeout_(0),
118 disallow_allocation_failure_(false),
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000119#endif // DEBUG
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +0000120 new_space_high_promotion_mode_active_(false),
ulan@chromium.orgd9e468a2012-06-25 09:47:40 +0000121 old_gen_promotion_limit_(kMinimumPromotionLimit),
122 old_gen_allocation_limit_(kMinimumAllocationLimit),
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000123 old_gen_limit_factor_(1),
124 size_of_old_gen_at_last_old_space_gc_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000125 external_allocation_limit_(0),
126 amount_of_external_allocated_memory_(0),
127 amount_of_external_allocated_memory_at_last_global_gc_(0),
128 old_gen_exhausted_(false),
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000129 store_buffer_rebuilder_(store_buffer()),
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000130 hidden_string_(NULL),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000131 global_gc_prologue_callback_(NULL),
132 global_gc_epilogue_callback_(NULL),
133 gc_safe_size_of_old_object_(NULL),
vegorov@chromium.org7304bca2011-05-16 12:14:13 +0000134 total_regexp_code_generated_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000135 tracer_(NULL),
136 young_survivors_after_last_gc_(0),
137 high_survival_rate_period_length_(0),
yangguo@chromium.orgfb377212012-11-16 14:43:43 +0000138 low_survival_rate_period_length_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000139 survival_rate_(0),
140 previous_survival_rate_trend_(Heap::STABLE),
141 survival_rate_trend_(Heap::STABLE),
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +0000142 max_gc_pause_(0.0),
143 total_gc_time_ms_(0.0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000144 max_alive_after_gc_(0),
145 min_in_mutator_(kMaxInt),
146 alive_after_last_gc_(0),
147 last_gc_end_timestamp_(0.0),
mstarzinger@chromium.orge3b8d0f2013-02-01 09:06:41 +0000148 marking_time_(0.0),
149 sweeping_time_(0.0),
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000150 store_buffer_(this),
151 marking_(this),
152 incremental_marking_(this),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000153 number_idle_notifications_(0),
154 last_idle_notification_gc_count_(0),
155 last_idle_notification_gc_count_init_(false),
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +0000156 mark_sweeps_since_idle_round_started_(0),
157 ms_count_at_last_idle_notification_(0),
158 gc_count_at_last_idle_gc_(0),
159 scavenges_since_last_idle_round_(kIdleScavengeThreshold),
danno@chromium.org94b0d6f2013-02-04 13:33:20 +0000160#ifdef VERIFY_HEAP
161 no_weak_embedded_maps_verification_scope_depth_(0),
162#endif
danno@chromium.orgc612e022011-11-10 11:38:15 +0000163 promotion_queue_(this),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000164 configured_(false),
yangguo@chromium.org304cc332012-07-24 07:59:48 +0000165 chunks_queued_for_free_(NULL),
166 relocation_mutex_(NULL) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000167 // Allow build-time customization of the max semispace size. Building
168 // V8 with snapshots and a non-default max semispace size is much
169 // easier if you can define it as part of the build environment.
170#if defined(V8_MAX_SEMISPACE_SIZE)
171 max_semispace_size_ = reserved_semispace_size_ = V8_MAX_SEMISPACE_SIZE;
172#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000173
lrn@chromium.orgac2828d2011-06-23 06:29:21 +0000174 intptr_t max_virtual = OS::MaxVirtualMemory();
175
176 if (max_virtual > 0) {
177 if (code_range_size_ > 0) {
178 // Reserve no more than 1/8 of the memory for the code range.
179 code_range_size_ = Min(code_range_size_, max_virtual >> 3);
180 }
181 }
182
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000183 memset(roots_, 0, sizeof(roots_[0]) * kRootListLength);
yangguo@chromium.org46839fb2012-08-28 09:06:19 +0000184 native_contexts_list_ = NULL;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000185 mark_compact_collector_.heap_ = this;
186 external_string_table_.heap_ = this;
yangguo@chromium.orgcb9affa2012-05-15 12:16:38 +0000187 // Put a dummy entry in the remembered pages so we can find the list the
188 // minidump even if there are no real unmapped pages.
189 RememberUnmappedPage(NULL, false);
jkummerow@chromium.org28583c92012-07-16 11:31:55 +0000190
191 ClearObjectStats(true);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000192}
193
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000194
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +0000195intptr_t Heap::Capacity() {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000196 if (!HasBeenSetUp()) return 0;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000197
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000198 return new_space_.Capacity() +
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000199 old_pointer_space_->Capacity() +
200 old_data_space_->Capacity() +
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000201 code_space_->Capacity() +
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000202 map_space_->Capacity() +
203 cell_space_->Capacity();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000204}
205
206
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +0000207intptr_t Heap::CommittedMemory() {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000208 if (!HasBeenSetUp()) return 0;
ager@chromium.org3811b432009-10-28 14:53:37 +0000209
210 return new_space_.CommittedMemory() +
211 old_pointer_space_->CommittedMemory() +
212 old_data_space_->CommittedMemory() +
213 code_space_->CommittedMemory() +
214 map_space_->CommittedMemory() +
215 cell_space_->CommittedMemory() +
216 lo_space_->Size();
217}
218
danno@chromium.org72204d52012-10-31 10:02:10 +0000219
220size_t Heap::CommittedPhysicalMemory() {
221 if (!HasBeenSetUp()) return 0;
222
223 return new_space_.CommittedPhysicalMemory() +
224 old_pointer_space_->CommittedPhysicalMemory() +
225 old_data_space_->CommittedPhysicalMemory() +
226 code_space_->CommittedPhysicalMemory() +
227 map_space_->CommittedPhysicalMemory() +
228 cell_space_->CommittedPhysicalMemory() +
229 lo_space_->CommittedPhysicalMemory();
230}
231
232
ager@chromium.org01fe7df2010-11-10 11:59:11 +0000233intptr_t Heap::CommittedMemoryExecutable() {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000234 if (!HasBeenSetUp()) return 0;
ager@chromium.org01fe7df2010-11-10 11:59:11 +0000235
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000236 return isolate()->memory_allocator()->SizeExecutable();
ager@chromium.org01fe7df2010-11-10 11:59:11 +0000237}
238
ager@chromium.org3811b432009-10-28 14:53:37 +0000239
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +0000240intptr_t Heap::Available() {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000241 if (!HasBeenSetUp()) return 0;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000242
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000243 return new_space_.Available() +
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000244 old_pointer_space_->Available() +
245 old_data_space_->Available() +
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000246 code_space_->Available() +
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000247 map_space_->Available() +
248 cell_space_->Available();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000249}
250
251
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000252bool Heap::HasBeenSetUp() {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000253 return old_pointer_space_ != NULL &&
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000254 old_data_space_ != NULL &&
255 code_space_ != NULL &&
256 map_space_ != NULL &&
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000257 cell_space_ != NULL &&
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000258 lo_space_ != NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000259}
260
261
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +0000262int Heap::GcSafeSizeOfOldObject(HeapObject* object) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000263 if (IntrusiveMarking::IsMarked(object)) {
264 return IntrusiveMarking::SizeOfMarkedObject(object);
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +0000265 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000266 return object->SizeFromMap(object->map());
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +0000267}
268
269
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000270GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space,
271 const char** reason) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000272 // Is global GC requested?
yangguo@chromium.orgefdb9d72012-04-26 08:21:05 +0000273 if (space != NEW_SPACE) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000274 isolate_->counters()->gc_compactor_caused_by_request()->Increment();
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000275 *reason = "GC in old space requested";
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000276 return MARK_COMPACTOR;
277 }
278
yangguo@chromium.orgefdb9d72012-04-26 08:21:05 +0000279 if (FLAG_gc_global || (FLAG_stress_compaction && (gc_count_ & 1) != 0)) {
280 *reason = "GC in old space forced by flags";
281 return MARK_COMPACTOR;
282 }
283
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000284 // Is enough data promoted to justify a global GC?
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000285 if (OldGenerationPromotionLimitReached()) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000286 isolate_->counters()->gc_compactor_caused_by_promoted_data()->Increment();
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000287 *reason = "promotion limit reached";
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000288 return MARK_COMPACTOR;
289 }
290
291 // Have allocation in OLD and LO failed?
292 if (old_gen_exhausted_) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000293 isolate_->counters()->
294 gc_compactor_caused_by_oldspace_exhaustion()->Increment();
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000295 *reason = "old generations exhausted";
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000296 return MARK_COMPACTOR;
297 }
298
299 // Is there enough space left in OLD to guarantee that a scavenge can
300 // succeed?
301 //
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000302 // Note that MemoryAllocator->MaxAvailable() undercounts the memory available
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000303 // for object promotion. It counts only the bytes that the memory
304 // allocator has not yet allocated from the OS and assigned to any space,
305 // and does not count available bytes already in the old space or code
306 // space. Undercounting is safe---we may get an unrequested full GC when
307 // a scavenge would have succeeded.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000308 if (isolate_->memory_allocator()->MaxAvailable() <= new_space_.Size()) {
309 isolate_->counters()->
310 gc_compactor_caused_by_oldspace_exhaustion()->Increment();
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000311 *reason = "scavenge might not succeed";
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000312 return MARK_COMPACTOR;
313 }
314
315 // Default
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000316 *reason = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000317 return SCAVENGER;
318}
319
320
321// TODO(1238405): Combine the infrastructure for --heap-stats and
322// --log-gc to avoid the complicated preprocessor and flag testing.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000323void Heap::ReportStatisticsBeforeGC() {
324 // Heap::ReportHeapStatistics will also log NewSpace statistics when
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000325 // compiled --log-gc is set. The following logic is used to avoid
326 // double logging.
327#ifdef DEBUG
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000328 if (FLAG_heap_stats || FLAG_log_gc) new_space_.CollectStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000329 if (FLAG_heap_stats) {
330 ReportHeapStatistics("Before GC");
331 } else if (FLAG_log_gc) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000332 new_space_.ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000333 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000334 if (FLAG_heap_stats || FLAG_log_gc) new_space_.ClearHistograms();
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000335#else
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000336 if (FLAG_log_gc) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000337 new_space_.CollectStatistics();
338 new_space_.ReportStatistics();
339 new_space_.ClearHistograms();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000340 }
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000341#endif // DEBUG
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000342}
343
344
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000345void Heap::PrintShortHeapStatistics() {
346 if (!FLAG_trace_gc_verbose) return;
rossberg@chromium.org657d53b2012-07-12 11:06:03 +0000347 PrintPID("Memory allocator, used: %6" V8_PTR_PREFIX "d KB"
348 ", available: %6" V8_PTR_PREFIX "d KB\n",
349 isolate_->memory_allocator()->Size() / KB,
350 isolate_->memory_allocator()->Available() / KB);
351 PrintPID("New space, used: %6" V8_PTR_PREFIX "d KB"
352 ", available: %6" V8_PTR_PREFIX "d KB"
353 ", committed: %6" V8_PTR_PREFIX "d KB\n",
354 new_space_.Size() / KB,
355 new_space_.Available() / KB,
356 new_space_.CommittedMemory() / KB);
357 PrintPID("Old pointers, used: %6" V8_PTR_PREFIX "d KB"
358 ", available: %6" V8_PTR_PREFIX "d KB"
359 ", committed: %6" V8_PTR_PREFIX "d KB\n",
360 old_pointer_space_->SizeOfObjects() / KB,
361 old_pointer_space_->Available() / KB,
362 old_pointer_space_->CommittedMemory() / KB);
363 PrintPID("Old data space, used: %6" V8_PTR_PREFIX "d KB"
364 ", available: %6" V8_PTR_PREFIX "d KB"
365 ", committed: %6" V8_PTR_PREFIX "d KB\n",
366 old_data_space_->SizeOfObjects() / KB,
367 old_data_space_->Available() / KB,
368 old_data_space_->CommittedMemory() / KB);
369 PrintPID("Code space, used: %6" V8_PTR_PREFIX "d KB"
370 ", available: %6" V8_PTR_PREFIX "d KB"
371 ", committed: %6" V8_PTR_PREFIX "d KB\n",
372 code_space_->SizeOfObjects() / KB,
373 code_space_->Available() / KB,
374 code_space_->CommittedMemory() / KB);
375 PrintPID("Map space, used: %6" V8_PTR_PREFIX "d KB"
376 ", available: %6" V8_PTR_PREFIX "d KB"
377 ", committed: %6" V8_PTR_PREFIX "d KB\n",
378 map_space_->SizeOfObjects() / KB,
379 map_space_->Available() / KB,
380 map_space_->CommittedMemory() / KB);
381 PrintPID("Cell space, used: %6" V8_PTR_PREFIX "d KB"
382 ", available: %6" V8_PTR_PREFIX "d KB"
383 ", committed: %6" V8_PTR_PREFIX "d KB\n",
384 cell_space_->SizeOfObjects() / KB,
385 cell_space_->Available() / KB,
386 cell_space_->CommittedMemory() / KB);
387 PrintPID("Large object space, used: %6" V8_PTR_PREFIX "d KB"
388 ", available: %6" V8_PTR_PREFIX "d KB"
389 ", committed: %6" V8_PTR_PREFIX "d KB\n",
390 lo_space_->SizeOfObjects() / KB,
391 lo_space_->Available() / KB,
392 lo_space_->CommittedMemory() / KB);
verwaest@chromium.org33e09c82012-10-10 17:07:22 +0000393 PrintPID("All spaces, used: %6" V8_PTR_PREFIX "d KB"
394 ", available: %6" V8_PTR_PREFIX "d KB"
395 ", committed: %6" V8_PTR_PREFIX "d KB\n",
396 this->SizeOfObjects() / KB,
397 this->Available() / KB,
398 this->CommittedMemory() / KB);
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +0000399 PrintPID("Total time spent in GC : %.1f ms\n", total_gc_time_ms_);
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000400}
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000401
402
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000403// TODO(1238405): Combine the infrastructure for --heap-stats and
404// --log-gc to avoid the complicated preprocessor and flag testing.
405void Heap::ReportStatisticsAfterGC() {
406 // Similar to the before GC, we use some complicated logic to ensure that
407 // NewSpace statistics are logged exactly once when --log-gc is turned on.
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000408#if defined(DEBUG)
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000409 if (FLAG_heap_stats) {
kasperl@chromium.org2abc4502009-07-02 07:00:29 +0000410 new_space_.CollectStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000411 ReportHeapStatistics("After GC");
412 } else if (FLAG_log_gc) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000413 new_space_.ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000414 }
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000415#else
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000416 if (FLAG_log_gc) new_space_.ReportStatistics();
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000417#endif // DEBUG
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000418}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000419
420
421void Heap::GarbageCollectionPrologue() {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000422 isolate_->transcendental_cache()->Clear();
ager@chromium.orgac091b72010-05-05 07:34:42 +0000423 ClearJSFunctionResultCaches();
kasper.lund7276f142008-07-30 08:49:36 +0000424 gc_count_++;
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +0000425 unflattened_strings_length_ = 0;
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000426
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +0000427 if (FLAG_flush_code && FLAG_flush_code_incrementally) {
428 mark_compact_collector()->EnableCodeFlushing(true);
429 }
430
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000431#ifdef VERIFY_HEAP
432 if (FLAG_verify_heap) {
433 Verify();
434 }
435#endif
436
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000437#ifdef DEBUG
438 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
439 allow_allocation(false);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000440
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000441 if (FLAG_gc_verbose) Print();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000442
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000443 ReportStatisticsBeforeGC();
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000444#endif // DEBUG
ager@chromium.org0ee099b2011-01-25 14:06:47 +0000445
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000446 store_buffer()->GCPrologue();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000447}
448
ulan@chromium.org56c14af2012-09-20 12:51:09 +0000449
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +0000450intptr_t Heap::SizeOfObjects() {
451 intptr_t total = 0;
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +0000452 AllSpaces spaces(this);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000453 for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +0000454 total += space->SizeOfObjects();
sgjesse@chromium.org911335c2009-08-19 12:59:44 +0000455 }
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000456 return total;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000457}
458
ulan@chromium.org56c14af2012-09-20 12:51:09 +0000459
460void Heap::RepairFreeListsAfterBoot() {
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +0000461 PagedSpaces spaces(this);
ulan@chromium.org56c14af2012-09-20 12:51:09 +0000462 for (PagedSpace* space = spaces.next();
463 space != NULL;
464 space = spaces.next()) {
465 space->RepairFreeListsAfterBoot();
466 }
467}
468
469
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000470void Heap::GarbageCollectionEpilogue() {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000471 store_buffer()->GCEpilogue();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000472
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000473 // In release mode, we only zap the from space under heap verification.
474 if (Heap::ShouldZapGarbage()) {
475 ZapFromSpace();
476 }
477
478#ifdef VERIFY_HEAP
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000479 if (FLAG_verify_heap) {
480 Verify();
481 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000482#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000483
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000484#ifdef DEBUG
485 allow_allocation(true);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000486 if (FLAG_print_global_handles) isolate_->global_handles()->Print();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000487 if (FLAG_print_handles) PrintHandles();
488 if (FLAG_gc_verbose) Print();
489 if (FLAG_code_stats) ReportCodeStatistics("After GC");
490#endif
491
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000492 isolate_->counters()->alive_after_last_gc()->Set(
493 static_cast<int>(SizeOfObjects()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000494
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000495 isolate_->counters()->string_table_capacity()->Set(
496 string_table()->Capacity());
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000497 isolate_->counters()->number_of_symbols()->Set(
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000498 string_table()->NumberOfElements());
jkummerow@chromium.org7a6fc812012-06-27 11:12:38 +0000499
verwaest@chromium.org753aee42012-07-17 16:15:42 +0000500 if (CommittedMemory() > 0) {
501 isolate_->counters()->external_fragmentation_total()->AddSample(
502 static_cast<int>(100 - (SizeOfObjects() * 100.0) / CommittedMemory()));
mstarzinger@chromium.org471f2f12012-08-10 14:46:33 +0000503
504 isolate_->counters()->heap_fraction_map_space()->AddSample(
505 static_cast<int>(
506 (map_space()->CommittedMemory() * 100.0) / CommittedMemory()));
507 isolate_->counters()->heap_fraction_cell_space()->AddSample(
508 static_cast<int>(
509 (cell_space()->CommittedMemory() * 100.0) / CommittedMemory()));
510
511 isolate_->counters()->heap_sample_total_committed()->AddSample(
512 static_cast<int>(CommittedMemory() / KB));
513 isolate_->counters()->heap_sample_total_used()->AddSample(
514 static_cast<int>(SizeOfObjects() / KB));
515 isolate_->counters()->heap_sample_map_space_committed()->AddSample(
516 static_cast<int>(map_space()->CommittedMemory() / KB));
517 isolate_->counters()->heap_sample_cell_space_committed()->AddSample(
518 static_cast<int>(cell_space()->CommittedMemory() / KB));
jkummerow@chromium.org28583c92012-07-16 11:31:55 +0000519 }
verwaest@chromium.org753aee42012-07-17 16:15:42 +0000520
521#define UPDATE_COUNTERS_FOR_SPACE(space) \
522 isolate_->counters()->space##_bytes_available()->Set( \
523 static_cast<int>(space()->Available())); \
524 isolate_->counters()->space##_bytes_committed()->Set( \
525 static_cast<int>(space()->CommittedMemory())); \
526 isolate_->counters()->space##_bytes_used()->Set( \
527 static_cast<int>(space()->SizeOfObjects()));
528#define UPDATE_FRAGMENTATION_FOR_SPACE(space) \
529 if (space()->CommittedMemory() > 0) { \
530 isolate_->counters()->external_fragmentation_##space()->AddSample( \
531 static_cast<int>(100 - \
532 (space()->SizeOfObjects() * 100.0) / space()->CommittedMemory())); \
533 }
534#define UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(space) \
535 UPDATE_COUNTERS_FOR_SPACE(space) \
536 UPDATE_FRAGMENTATION_FOR_SPACE(space)
537
jkummerow@chromium.org28583c92012-07-16 11:31:55 +0000538 UPDATE_COUNTERS_FOR_SPACE(new_space)
verwaest@chromium.org753aee42012-07-17 16:15:42 +0000539 UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(old_pointer_space)
540 UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(old_data_space)
541 UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(code_space)
542 UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(map_space)
543 UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(cell_space)
544 UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE(lo_space)
jkummerow@chromium.org28583c92012-07-16 11:31:55 +0000545#undef UPDATE_COUNTERS_FOR_SPACE
verwaest@chromium.org753aee42012-07-17 16:15:42 +0000546#undef UPDATE_FRAGMENTATION_FOR_SPACE
547#undef UPDATE_COUNTERS_AND_FRAGMENTATION_FOR_SPACE
jkummerow@chromium.org7a6fc812012-06-27 11:12:38 +0000548
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000549#if defined(DEBUG)
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000550 ReportStatisticsAfterGC();
whesse@chromium.org030d38e2011-07-13 13:23:34 +0000551#endif // DEBUG
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000552#ifdef ENABLE_DEBUGGER_SUPPORT
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000553 isolate_->debug()->AfterGarbageCollection();
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +0000554#endif // ENABLE_DEBUGGER_SUPPORT
yangguo@chromium.org46a2a512013-01-18 16:29:40 +0000555
556 error_object_list_.DeferredFormatStackTrace(isolate());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000557}
558
559
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000560void Heap::CollectAllGarbage(int flags, const char* gc_reason) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000561 // Since we are ignoring the return value, the exact choice of space does
562 // not matter, so long as we do not specify NEW_SPACE, which would not
563 // cause a full GC.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000564 mark_compact_collector_.SetFlags(flags);
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000565 CollectGarbage(OLD_POINTER_SPACE, gc_reason);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000566 mark_compact_collector_.SetFlags(kNoGCFlags);
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000567}
568
569
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000570void Heap::CollectAllAvailableGarbage(const char* gc_reason) {
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000571 // Since we are ignoring the return value, the exact choice of space does
572 // not matter, so long as we do not specify NEW_SPACE, which would not
573 // cause a full GC.
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000574 // Major GC would invoke weak handle callbacks on weakly reachable
575 // handles, but won't collect weakly reachable objects until next
576 // major GC. Therefore if we collect aggressively and weak handle callback
577 // has been invoked, we rerun major GC to release objects which become
578 // garbage.
579 // Note: as weak callbacks can execute arbitrary code, we cannot
580 // hope that eventually there will be no weak callbacks invocations.
581 // Therefore stop recollecting after several attempts.
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000582 mark_compact_collector()->SetFlags(kMakeHeapIterableMask |
583 kReduceMemoryFootprintMask);
danno@chromium.orgc612e022011-11-10 11:38:15 +0000584 isolate_->compilation_cache()->Clear();
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000585 const int kMaxNumberOfAttempts = 7;
586 for (int attempt = 0; attempt < kMaxNumberOfAttempts; attempt++) {
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000587 if (!CollectGarbage(OLD_POINTER_SPACE, MARK_COMPACTOR, gc_reason, NULL)) {
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000588 break;
589 }
590 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000591 mark_compact_collector()->SetFlags(kNoGCFlags);
danno@chromium.orgc612e022011-11-10 11:38:15 +0000592 new_space_.Shrink();
danno@chromium.orgbf0c8202011-12-27 10:09:42 +0000593 UncommitFromSpace();
danno@chromium.orgc612e022011-11-10 11:38:15 +0000594 incremental_marking()->UncommitMarkingDeque();
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000595}
596
597
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000598bool Heap::CollectGarbage(AllocationSpace space,
599 GarbageCollector collector,
600 const char* gc_reason,
601 const char* collector_reason) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000602 // The VM is in the GC state until exiting this function.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000603 VMState state(isolate_, GC);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000604
605#ifdef DEBUG
606 // Reset the allocation timeout to the GC interval, but make sure to
607 // allow at least a few allocations after a collection. The reason
608 // for this is that we have a lot of allocation sequences and we
609 // assume that a garbage collection will allow the subsequent
610 // allocation attempts to go through.
611 allocation_timeout_ = Max(6, FLAG_gc_interval);
612#endif
613
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000614 if (collector == SCAVENGER && !incremental_marking()->IsStopped()) {
615 if (FLAG_trace_incremental_marking) {
616 PrintF("[IncrementalMarking] Scavenge during marking.\n");
617 }
618 }
619
620 if (collector == MARK_COMPACTOR &&
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +0000621 !mark_compact_collector()->abort_incremental_marking() &&
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000622 !incremental_marking()->IsStopped() &&
623 !incremental_marking()->should_hurry() &&
624 FLAG_incremental_marking_steps) {
fschneider@chromium.org7d10be52012-04-10 12:30:14 +0000625 // Make progress in incremental marking.
626 const intptr_t kStepSizeWhenDelayedByScavenge = 1 * MB;
627 incremental_marking()->Step(kStepSizeWhenDelayedByScavenge,
628 IncrementalMarking::NO_GC_VIA_STACK_GUARD);
629 if (!incremental_marking()->IsComplete()) {
630 if (FLAG_trace_incremental_marking) {
631 PrintF("[IncrementalMarking] Delaying MarkSweep.\n");
632 }
633 collector = SCAVENGER;
634 collector_reason = "incremental marking delaying mark-sweep";
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000635 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000636 }
637
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000638 bool next_gc_likely_to_collect_more = false;
639
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000640 { GCTracer tracer(this, gc_reason, collector_reason);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000641 GarbageCollectionPrologue();
kasper.lund7276f142008-07-30 08:49:36 +0000642 // The GC count was incremented in the prologue. Tell the tracer about
643 // it.
644 tracer.set_gc_count(gc_count_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000645
kasper.lund7276f142008-07-30 08:49:36 +0000646 // Tell the tracer which collector we've selected.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000647 tracer.set_collector(collector);
648
ulan@chromium.org8e8d8822012-11-23 14:36:46 +0000649 {
650 HistogramTimerScope histogram_timer_scope(
651 (collector == SCAVENGER) ? isolate_->counters()->gc_scavenger()
652 : isolate_->counters()->gc_compactor());
653 next_gc_likely_to_collect_more =
654 PerformGarbageCollection(collector, &tracer);
655 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000656
657 GarbageCollectionEpilogue();
658 }
659
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +0000660 // Start incremental marking for the next cycle. The heap snapshot
661 // generator needs incremental marking to stay off after it aborted.
662 if (!mark_compact_collector()->abort_incremental_marking() &&
663 incremental_marking()->IsStopped() &&
664 incremental_marking()->WorthActivating() &&
665 NextGCIsLikelyToBeFull()) {
666 incremental_marking()->Start();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000667 }
668
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000669 return next_gc_likely_to_collect_more;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000670}
671
672
kasper.lund7276f142008-07-30 08:49:36 +0000673void Heap::PerformScavenge() {
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000674 GCTracer tracer(this, NULL, NULL);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000675 if (incremental_marking()->IsStopped()) {
676 PerformGarbageCollection(SCAVENGER, &tracer);
677 } else {
678 PerformGarbageCollection(MARK_COMPACTOR, &tracer);
679 }
kasper.lund7276f142008-07-30 08:49:36 +0000680}
681
682
jkummerow@chromium.org59297c72013-01-09 16:32:23 +0000683void Heap::MoveElements(FixedArray* array,
684 int dst_index,
685 int src_index,
686 int len) {
687 if (len == 0) return;
688
689 ASSERT(array->map() != HEAP->fixed_cow_array_map());
690 Object** dst_objects = array->data_start() + dst_index;
691 memmove(dst_objects,
692 array->data_start() + src_index,
693 len * kPointerSize);
694 if (!InNewSpace(array)) {
695 for (int i = 0; i < len; i++) {
696 // TODO(hpayer): check store buffer for entries
697 if (InNewSpace(dst_objects[i])) {
698 RecordWrite(array->address(), array->OffsetOfElementAt(dst_index + i));
699 }
700 }
701 }
702 incremental_marking()->RecordWrites(array);
703}
704
705
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000706#ifdef VERIFY_HEAP
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000707// Helper class for verifying the string table.
708class StringTableVerifier : public ObjectVisitor {
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000709 public:
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000710 void VisitPointers(Object** start, Object** end) {
711 // Visit all HeapObject pointers in [start, end).
712 for (Object** p = start; p < end; p++) {
713 if ((*p)->IsHeapObject()) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000714 // Check that the string is actually internalized.
715 CHECK((*p)->IsTheHole() || (*p)->IsUndefined() ||
716 (*p)->IsInternalizedString());
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000717 }
718 }
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000719 }
720};
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000721
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000722
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000723static void VerifyStringTable() {
724 StringTableVerifier verifier;
725 HEAP->string_table()->IterateElements(&verifier);
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000726}
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000727#endif // VERIFY_HEAP
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000728
729
erik.corry@gmail.combbceb572012-03-09 10:52:05 +0000730static bool AbortIncrementalMarkingAndCollectGarbage(
731 Heap* heap,
732 AllocationSpace space,
733 const char* gc_reason = NULL) {
734 heap->mark_compact_collector()->SetFlags(Heap::kAbortIncrementalMarkingMask);
735 bool result = heap->CollectGarbage(space, gc_reason);
736 heap->mark_compact_collector()->SetFlags(Heap::kNoGCFlags);
737 return result;
738}
739
740
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000741void Heap::ReserveSpace(
ulan@chromium.org56c14af2012-09-20 12:51:09 +0000742 int *sizes,
743 Address *locations_out) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000744 bool gc_performed = true;
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000745 int counter = 0;
746 static const int kThreshold = 20;
747 while (gc_performed && counter++ < kThreshold) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000748 gc_performed = false;
ulan@chromium.org56c14af2012-09-20 12:51:09 +0000749 ASSERT(NEW_SPACE == FIRST_PAGED_SPACE - 1);
750 for (int space = NEW_SPACE; space <= LAST_PAGED_SPACE; space++) {
751 if (sizes[space] != 0) {
752 MaybeObject* allocation;
753 if (space == NEW_SPACE) {
754 allocation = new_space()->AllocateRaw(sizes[space]);
755 } else {
756 allocation = paged_space(space)->AllocateRaw(sizes[space]);
757 }
758 FreeListNode* node;
759 if (!allocation->To<FreeListNode>(&node)) {
760 if (space == NEW_SPACE) {
761 Heap::CollectGarbage(NEW_SPACE,
762 "failed to reserve space in the new space");
763 } else {
764 AbortIncrementalMarkingAndCollectGarbage(
765 this,
766 static_cast<AllocationSpace>(space),
767 "failed to reserve space in paged space");
768 }
769 gc_performed = true;
770 break;
771 } else {
772 // Mark with a free list node, in case we have a GC before
773 // deserializing.
774 node->set_size(this, sizes[space]);
775 locations_out[space] = node->address();
776 }
777 }
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000778 }
779 }
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +0000780
781 if (gc_performed) {
782 // Failed to reserve the space after several attempts.
783 V8::FatalProcessOutOfMemory("Heap::ReserveSpace");
784 }
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000785}
786
787
ager@chromium.orgadd848f2009-08-13 12:44:13 +0000788void Heap::EnsureFromSpaceIsCommitted() {
789 if (new_space_.CommitFromSpaceIfNeeded()) return;
790
791 // Committing memory to from space failed.
ager@chromium.orgadd848f2009-08-13 12:44:13 +0000792 // Memory is exhausted and we will die.
793 V8::FatalProcessOutOfMemory("Committing semi space failed.");
794}
795
796
fschneider@chromium.orge03fb642010-11-01 12:34:09 +0000797void Heap::ClearJSFunctionResultCaches() {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000798 if (isolate_->bootstrapper()->IsActive()) return;
ager@chromium.orgac091b72010-05-05 07:34:42 +0000799
yangguo@chromium.org46839fb2012-08-28 09:06:19 +0000800 Object* context = native_contexts_list_;
fschneider@chromium.orge03fb642010-11-01 12:34:09 +0000801 while (!context->IsUndefined()) {
ricow@chromium.org7ad65222011-12-19 12:13:11 +0000802 // Get the caches for this context. GC can happen when the context
803 // is not fully initialized, so the caches can be undefined.
804 Object* caches_or_undefined =
805 Context::cast(context)->get(Context::JSFUNCTION_RESULT_CACHES_INDEX);
806 if (!caches_or_undefined->IsUndefined()) {
807 FixedArray* caches = FixedArray::cast(caches_or_undefined);
808 // Clear the caches:
809 int length = caches->length();
810 for (int i = 0; i < length; i++) {
811 JSFunctionResultCache::cast(caches->get(i))->Clear();
812 }
ager@chromium.orgac091b72010-05-05 07:34:42 +0000813 }
fschneider@chromium.orge03fb642010-11-01 12:34:09 +0000814 // Get the next context:
815 context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
ager@chromium.orgac091b72010-05-05 07:34:42 +0000816 }
ager@chromium.orgac091b72010-05-05 07:34:42 +0000817}
818
819
ricow@chromium.org65fae842010-08-25 15:26:24 +0000820void Heap::ClearNormalizedMapCaches() {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000821 if (isolate_->bootstrapper()->IsActive() &&
822 !incremental_marking()->IsMarking()) {
823 return;
824 }
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000825
yangguo@chromium.org46839fb2012-08-28 09:06:19 +0000826 Object* context = native_contexts_list_;
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000827 while (!context->IsUndefined()) {
ricow@chromium.org7ad65222011-12-19 12:13:11 +0000828 // GC can happen when the context is not fully initialized,
829 // so the cache can be undefined.
830 Object* cache =
831 Context::cast(context)->get(Context::NORMALIZED_MAP_CACHE_INDEX);
832 if (!cache->IsUndefined()) {
833 NormalizedMapCache::cast(cache)->Clear();
834 }
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000835 context = Context::cast(context)->get(Context::NEXT_CONTEXT_LINK);
836 }
ricow@chromium.org65fae842010-08-25 15:26:24 +0000837}
838
839
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000840void Heap::UpdateSurvivalRateTrend(int start_new_space_size) {
841 double survival_rate =
842 (static_cast<double>(young_survivors_after_last_gc_) * 100) /
843 start_new_space_size;
844
yangguo@chromium.org659ceec2012-01-26 07:37:54 +0000845 if (survival_rate > kYoungSurvivalRateHighThreshold) {
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000846 high_survival_rate_period_length_++;
847 } else {
848 high_survival_rate_period_length_ = 0;
849 }
850
yangguo@chromium.org659ceec2012-01-26 07:37:54 +0000851 if (survival_rate < kYoungSurvivalRateLowThreshold) {
852 low_survival_rate_period_length_++;
853 } else {
854 low_survival_rate_period_length_ = 0;
855 }
856
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000857 double survival_rate_diff = survival_rate_ - survival_rate;
858
859 if (survival_rate_diff > kYoungSurvivalRateAllowedDeviation) {
860 set_survival_rate_trend(DECREASING);
861 } else if (survival_rate_diff < -kYoungSurvivalRateAllowedDeviation) {
862 set_survival_rate_trend(INCREASING);
863 } else {
864 set_survival_rate_trend(STABLE);
865 }
866
867 survival_rate_ = survival_rate;
868}
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000869
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000870bool Heap::PerformGarbageCollection(GarbageCollector collector,
lrn@chromium.org303ada72010-10-27 09:33:13 +0000871 GCTracer* tracer) {
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000872 bool next_gc_likely_to_collect_more = false;
873
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000874 if (collector != SCAVENGER) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000875 PROFILE(isolate_, CodeMovingGCEvent());
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000876 }
877
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000878#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +0000879 if (FLAG_verify_heap) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +0000880 VerifyStringTable();
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +0000881 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +0000882#endif
883
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +0000884 GCType gc_type =
885 collector == MARK_COMPACTOR ? kGCTypeMarkSweepCompact : kGCTypeScavenge;
886
yangguo@chromium.org46a2a512013-01-18 16:29:40 +0000887 {
888 GCTracer::Scope scope(tracer, GCTracer::Scope::EXTERNAL);
889 VMState state(isolate_, EXTERNAL);
yangguo@chromium.org003650e2013-01-24 16:31:08 +0000890 CallGCPrologueCallbacks(gc_type);
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +0000891 }
892
ager@chromium.orgadd848f2009-08-13 12:44:13 +0000893 EnsureFromSpaceIsCommitted();
ager@chromium.orgce5e87b2010-03-10 10:24:18 +0000894
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +0000895 int start_new_space_size = Heap::new_space()->SizeAsInt();
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000896
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000897 if (IsHighSurvivalRate()) {
898 // We speed up the incremental marker if it is running so that it
899 // does not fall behind the rate of promotion, which would cause a
900 // constantly growing old space.
901 incremental_marking()->NotifyOfHighPromotionRate();
902 }
903
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000904 if (collector == MARK_COMPACTOR) {
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +0000905 // Perform mark-sweep with optional compaction.
kasper.lund7276f142008-07-30 08:49:36 +0000906 MarkCompact(tracer);
jkummerow@chromium.orgddda9e82011-07-06 11:27:02 +0000907 sweep_generation_++;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000908 bool high_survival_rate_during_scavenges = IsHighSurvivalRate() &&
909 IsStableOrIncreasingSurvivalTrend();
910
911 UpdateSurvivalRateTrend(start_new_space_size);
912
jkummerow@chromium.org212d9642012-05-11 15:02:09 +0000913 size_of_old_gen_at_last_old_space_gc_ = PromotedSpaceSizeOfObjects();
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000914
lrn@chromium.org303ada72010-10-27 09:33:13 +0000915 if (high_survival_rate_during_scavenges &&
916 IsStableOrIncreasingSurvivalTrend()) {
917 // Stable high survival rates of young objects both during partial and
918 // full collection indicate that mutator is either building or modifying
919 // a structure with a long lifetime.
920 // In this case we aggressively raise old generation memory limits to
921 // postpone subsequent mark-sweep collection and thus trade memory
922 // space for the mutation speed.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000923 old_gen_limit_factor_ = 2;
924 } else {
925 old_gen_limit_factor_ = 1;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000926 }
927
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000928 old_gen_promotion_limit_ =
ulan@chromium.orgd9e468a2012-06-25 09:47:40 +0000929 OldGenPromotionLimit(size_of_old_gen_at_last_old_space_gc_);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000930 old_gen_allocation_limit_ =
ulan@chromium.orgd9e468a2012-06-25 09:47:40 +0000931 OldGenAllocationLimit(size_of_old_gen_at_last_old_space_gc_);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000932
lrn@chromium.org303ada72010-10-27 09:33:13 +0000933 old_gen_exhausted_ = false;
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +0000934 } else {
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +0000935 tracer_ = tracer;
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +0000936 Scavenge();
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +0000937 tracer_ = NULL;
fschneider@chromium.org40b9da32010-06-28 11:29:21 +0000938
939 UpdateSurvivalRateTrend(start_new_space_size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000940 }
ager@chromium.org439e85a2009-08-26 13:15:29 +0000941
yangguo@chromium.org659ceec2012-01-26 07:37:54 +0000942 if (!new_space_high_promotion_mode_active_ &&
943 new_space_.Capacity() == new_space_.MaximumCapacity() &&
944 IsStableOrIncreasingSurvivalTrend() &&
945 IsHighSurvivalRate()) {
946 // Stable high survival rates even though young generation is at
947 // maximum capacity indicates that most objects will be promoted.
948 // To decrease scavenger pauses and final mark-sweep pauses, we
949 // have to limit maximal capacity of the young generation.
950 new_space_high_promotion_mode_active_ = true;
951 if (FLAG_trace_gc) {
rossberg@chromium.org657d53b2012-07-12 11:06:03 +0000952 PrintPID("Limited new space size due to high promotion rate: %d MB\n",
953 new_space_.InitialCapacity() / MB);
yangguo@chromium.org659ceec2012-01-26 07:37:54 +0000954 }
955 } else if (new_space_high_promotion_mode_active_ &&
956 IsStableOrDecreasingSurvivalTrend() &&
957 IsLowSurvivalRate()) {
958 // Decreasing low survival rates might indicate that the above high
959 // promotion mode is over and we should allow the young generation
960 // to grow again.
961 new_space_high_promotion_mode_active_ = false;
962 if (FLAG_trace_gc) {
rossberg@chromium.org657d53b2012-07-12 11:06:03 +0000963 PrintPID("Unlimited new space size due to low promotion rate: %d MB\n",
964 new_space_.MaximumCapacity() / MB);
yangguo@chromium.org659ceec2012-01-26 07:37:54 +0000965 }
966 }
967
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +0000968 if (new_space_high_promotion_mode_active_ &&
969 new_space_.Capacity() > new_space_.InitialCapacity()) {
970 new_space_.Shrink();
971 }
972
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000973 isolate_->counters()->objs_since_last_young()->Set(0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000974
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +0000975 // Callbacks that fire after this point might trigger nested GCs and
976 // restart incremental marking, the assertion can't be moved down.
977 ASSERT(collector == SCAVENGER || incremental_marking()->IsStopped());
978
erik.corry@gmail.comd6076d92011-06-06 09:39:18 +0000979 gc_post_processing_depth_++;
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +0000980 { DisableAssertNoAllocation allow_allocation;
lrn@chromium.org303ada72010-10-27 09:33:13 +0000981 GCTracer::Scope scope(tracer, GCTracer::Scope::EXTERNAL);
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000982 next_gc_likely_to_collect_more =
rossberg@chromium.orgcddc71f2012-12-07 12:40:13 +0000983 isolate_->global_handles()->PostGarbageCollectionProcessing(
984 collector, tracer);
lrn@chromium.org303ada72010-10-27 09:33:13 +0000985 }
erik.corry@gmail.comd6076d92011-06-06 09:39:18 +0000986 gc_post_processing_depth_--;
lrn@chromium.org303ada72010-10-27 09:33:13 +0000987
ager@chromium.org3811b432009-10-28 14:53:37 +0000988 // Update relocatables.
989 Relocatable::PostGarbageCollectionProcessing();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000990
kasper.lund7276f142008-07-30 08:49:36 +0000991 if (collector == MARK_COMPACTOR) {
992 // Register the amount of external allocated memory.
993 amount_of_external_allocated_memory_at_last_global_gc_ =
994 amount_of_external_allocated_memory_;
995 }
996
yangguo@chromium.org46a2a512013-01-18 16:29:40 +0000997 {
998 GCTracer::Scope scope(tracer, GCTracer::Scope::EXTERNAL);
999 VMState state(isolate_, EXTERNAL);
yangguo@chromium.org003650e2013-01-24 16:31:08 +00001000 CallGCEpilogueCallbacks(gc_type);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001001 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001002
1003#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00001004 if (FLAG_verify_heap) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001005 VerifyStringTable();
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00001006 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001007#endif
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +00001008
1009 return next_gc_likely_to_collect_more;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001010}
1011
1012
yangguo@chromium.org003650e2013-01-24 16:31:08 +00001013void Heap::CallGCPrologueCallbacks(GCType gc_type) {
1014 if (gc_type == kGCTypeMarkSweepCompact && global_gc_prologue_callback_) {
1015 global_gc_prologue_callback_();
1016 }
1017 for (int i = 0; i < gc_prologue_callbacks_.length(); ++i) {
1018 if (gc_type & gc_prologue_callbacks_[i].gc_type) {
1019 gc_prologue_callbacks_[i].callback(gc_type, kNoGCCallbackFlags);
1020 }
1021 }
1022}
1023
1024
1025void Heap::CallGCEpilogueCallbacks(GCType gc_type) {
1026 for (int i = 0; i < gc_epilogue_callbacks_.length(); ++i) {
1027 if (gc_type & gc_epilogue_callbacks_[i].gc_type) {
1028 gc_epilogue_callbacks_[i].callback(gc_type, kNoGCCallbackFlags);
1029 }
1030 }
1031 if (gc_type == kGCTypeMarkSweepCompact && global_gc_epilogue_callback_) {
1032 global_gc_epilogue_callback_();
1033 }
1034}
1035
1036
kasper.lund7276f142008-07-30 08:49:36 +00001037void Heap::MarkCompact(GCTracer* tracer) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001038 gc_state_ = MARK_COMPACT;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001039 LOG(isolate_, ResourceEvent("markcompact", "begin"));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001040
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001041 mark_compact_collector_.Prepare(tracer);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001042
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001043 ms_count_++;
1044 tracer->set_full_gc_count(ms_count_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001045
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001046 MarkCompactPrologue();
vegorov@chromium.org2356e6f2010-06-09 09:38:56 +00001047
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001048 mark_compact_collector_.CollectGarbage();
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001049
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001050 LOG(isolate_, ResourceEvent("markcompact", "end"));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001051
1052 gc_state_ = NOT_IN_GC;
1053
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001054 isolate_->counters()->objs_since_last_full()->Set(0);
kasperl@chromium.org8b2bb262010-03-01 09:46:28 +00001055
1056 contexts_disposed_ = 0;
ulan@chromium.org2efb9002012-01-19 15:36:35 +00001057
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001058 flush_monomorphic_ics_ = false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001059}
1060
1061
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001062void Heap::MarkCompactPrologue() {
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001063 // At any old GC clear the keyed lookup cache to enable collection of unused
1064 // maps.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001065 isolate_->keyed_lookup_cache()->Clear();
1066 isolate_->context_slot_cache()->Clear();
1067 isolate_->descriptor_lookup_cache()->Clear();
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00001068 RegExpResultsCache::Clear(string_split_cache());
1069 RegExpResultsCache::Clear(regexp_multiple_cache());
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001070
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001071 isolate_->compilation_cache()->MarkCompactPrologue();
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001072
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00001073 CompletelyClearInstanceofCache();
1074
danno@chromium.orgfa458e42012-02-01 10:48:36 +00001075 FlushNumberStringCache();
jkummerow@chromium.orge297f592011-06-08 10:05:15 +00001076 if (FLAG_cleanup_code_caches_at_gc) {
1077 polymorphic_code_cache()->set_cache(undefined_value());
1078 }
ricow@chromium.org65fae842010-08-25 15:26:24 +00001079
1080 ClearNormalizedMapCaches();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001081}
1082
1083
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001084Object* Heap::FindCodeObject(Address a) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001085 return isolate()->inner_pointer_to_code_cache()->
1086 GcSafeFindCodeForInnerPointer(a);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001087}
1088
1089
1090// Helper class for copying HeapObjects
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001091class ScavengeVisitor: public ObjectVisitor {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001092 public:
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001093 explicit ScavengeVisitor(Heap* heap) : heap_(heap) {}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001094
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001095 void VisitPointer(Object** p) { ScavengePointer(p); }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001096
1097 void VisitPointers(Object** start, Object** end) {
1098 // Copy all HeapObject pointers in [start, end)
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001099 for (Object** p = start; p < end; p++) ScavengePointer(p);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001100 }
1101
1102 private:
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001103 void ScavengePointer(Object** p) {
1104 Object* object = *p;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001105 if (!heap_->InNewSpace(object)) return;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001106 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
1107 reinterpret_cast<HeapObject*>(object));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001108 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001109
1110 Heap* heap_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001111};
1112
1113
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001114#ifdef VERIFY_HEAP
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001115// Visitor class to verify pointers in code or data space do not point into
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001116// new space.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001117class VerifyNonPointerSpacePointersVisitor: public ObjectVisitor {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001118 public:
1119 void VisitPointers(Object** start, Object**end) {
1120 for (Object** current = start; current < end; current++) {
1121 if ((*current)->IsHeapObject()) {
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001122 CHECK(!HEAP->InNewSpace(HeapObject::cast(*current)));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001123 }
1124 }
1125 }
1126};
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001127
1128
1129static void VerifyNonPointerSpacePointers() {
1130 // Verify that there are no pointers to new space in spaces where we
1131 // do not expect them.
1132 VerifyNonPointerSpacePointersVisitor v;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001133 HeapObjectIterator code_it(HEAP->code_space());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001134 for (HeapObject* object = code_it.Next();
1135 object != NULL; object = code_it.Next())
christian.plesner.hansen@gmail.com2bc58ef2009-09-22 10:00:30 +00001136 object->Iterate(&v);
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001137
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001138 // The old data space was normally swept conservatively so that the iterator
1139 // doesn't work, so we normally skip the next bit.
1140 if (!HEAP->old_data_space()->was_swept_conservatively()) {
1141 HeapObjectIterator data_it(HEAP->old_data_space());
1142 for (HeapObject* object = data_it.Next();
1143 object != NULL; object = data_it.Next())
1144 object->Iterate(&v);
1145 }
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001146}
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001147#endif // VERIFY_HEAP
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001148
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001149
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001150void Heap::CheckNewSpaceExpansionCriteria() {
1151 if (new_space_.Capacity() < new_space_.MaximumCapacity() &&
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001152 survived_since_last_expansion_ > new_space_.Capacity() &&
1153 !new_space_high_promotion_mode_active_) {
1154 // Grow the size of new space if there is room to grow, enough data
1155 // has survived scavenge since the last expansion and we are not in
1156 // high promotion mode.
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001157 new_space_.Grow();
1158 survived_since_last_expansion_ = 0;
1159 }
1160}
1161
1162
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +00001163static bool IsUnscavengedHeapObject(Heap* heap, Object** p) {
1164 return heap->InNewSpace(*p) &&
1165 !HeapObject::cast(*p)->map_word().IsForwardingAddress();
1166}
1167
1168
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001169void Heap::ScavengeStoreBufferCallback(
1170 Heap* heap,
1171 MemoryChunk* page,
1172 StoreBufferEvent event) {
1173 heap->store_buffer_rebuilder_.Callback(page, event);
1174}
1175
1176
1177void StoreBufferRebuilder::Callback(MemoryChunk* page, StoreBufferEvent event) {
1178 if (event == kStoreBufferStartScanningPagesEvent) {
1179 start_of_current_page_ = NULL;
1180 current_page_ = NULL;
1181 } else if (event == kStoreBufferScanningPageEvent) {
1182 if (current_page_ != NULL) {
1183 // If this page already overflowed the store buffer during this iteration.
1184 if (current_page_->scan_on_scavenge()) {
1185 // Then we should wipe out the entries that have been added for it.
1186 store_buffer_->SetTop(start_of_current_page_);
1187 } else if (store_buffer_->Top() - start_of_current_page_ >=
1188 (store_buffer_->Limit() - store_buffer_->Top()) >> 2) {
1189 // Did we find too many pointers in the previous page? The heuristic is
1190 // that no page can take more then 1/5 the remaining slots in the store
1191 // buffer.
1192 current_page_->set_scan_on_scavenge(true);
1193 store_buffer_->SetTop(start_of_current_page_);
1194 } else {
1195 // In this case the page we scanned took a reasonable number of slots in
1196 // the store buffer. It has now been rehabilitated and is no longer
1197 // marked scan_on_scavenge.
1198 ASSERT(!current_page_->scan_on_scavenge());
1199 }
1200 }
1201 start_of_current_page_ = store_buffer_->Top();
1202 current_page_ = page;
1203 } else if (event == kStoreBufferFullEvent) {
1204 // The current page overflowed the store buffer again. Wipe out its entries
1205 // in the store buffer and mark it scan-on-scavenge again. This may happen
1206 // several times while scanning.
1207 if (current_page_ == NULL) {
1208 // Store Buffer overflowed while scanning promoted objects. These are not
1209 // in any particular page, though they are likely to be clustered by the
1210 // allocation routines.
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00001211 store_buffer_->EnsureSpace(StoreBuffer::kStoreBufferSize);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001212 } else {
1213 // Store Buffer overflowed while scanning a particular old space page for
1214 // pointers to new space.
1215 ASSERT(current_page_ == page);
1216 ASSERT(page != NULL);
1217 current_page_->set_scan_on_scavenge(true);
1218 ASSERT(start_of_current_page_ != store_buffer_->Top());
1219 store_buffer_->SetTop(start_of_current_page_);
1220 }
1221 } else {
1222 UNREACHABLE();
1223 }
1224}
1225
1226
danno@chromium.orgc612e022011-11-10 11:38:15 +00001227void PromotionQueue::Initialize() {
1228 // Assumes that a NewSpacePage exactly fits a number of promotion queue
1229 // entries (where each is a pair of intptr_t). This allows us to simplify
1230 // the test fpr when to switch pages.
1231 ASSERT((Page::kPageSize - MemoryChunk::kBodyOffset) % (2 * kPointerSize)
1232 == 0);
1233 limit_ = reinterpret_cast<intptr_t*>(heap_->new_space()->ToSpaceStart());
1234 front_ = rear_ =
1235 reinterpret_cast<intptr_t*>(heap_->new_space()->ToSpaceEnd());
1236 emergency_stack_ = NULL;
1237 guard_ = false;
1238}
1239
1240
1241void PromotionQueue::RelocateQueueHead() {
1242 ASSERT(emergency_stack_ == NULL);
1243
1244 Page* p = Page::FromAllocationTop(reinterpret_cast<Address>(rear_));
1245 intptr_t* head_start = rear_;
1246 intptr_t* head_end =
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00001247 Min(front_, reinterpret_cast<intptr_t*>(p->area_end()));
danno@chromium.orgc612e022011-11-10 11:38:15 +00001248
1249 int entries_count =
1250 static_cast<int>(head_end - head_start) / kEntrySizeInWords;
1251
1252 emergency_stack_ = new List<Entry>(2 * entries_count);
1253
1254 while (head_start != head_end) {
1255 int size = static_cast<int>(*(head_start++));
1256 HeapObject* obj = reinterpret_cast<HeapObject*>(*(head_start++));
1257 emergency_stack_->Add(Entry(obj, size));
1258 }
1259 rear_ = head_end;
1260}
1261
1262
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001263class ScavengeWeakObjectRetainer : public WeakObjectRetainer {
1264 public:
1265 explicit ScavengeWeakObjectRetainer(Heap* heap) : heap_(heap) { }
1266
1267 virtual Object* RetainAs(Object* object) {
1268 if (!heap_->InFromSpace(object)) {
1269 return object;
1270 }
1271
1272 MapWord map_word = HeapObject::cast(object)->map_word();
1273 if (map_word.IsForwardingAddress()) {
1274 return map_word.ToForwardingAddress();
1275 }
1276 return NULL;
1277 }
1278
1279 private:
1280 Heap* heap_;
1281};
1282
1283
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001284void Heap::Scavenge() {
yangguo@chromium.org304cc332012-07-24 07:59:48 +00001285 RelocationLock relocation_lock(this);
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001286
1287#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00001288 if (FLAG_verify_heap) VerifyNonPointerSpacePointers();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001289#endif
1290
1291 gc_state_ = SCAVENGE;
1292
1293 // Implements Cheney's copying algorithm
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001294 LOG(isolate_, ResourceEvent("scavenge", "begin"));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001295
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001296 // Clear descriptor cache.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001297 isolate_->descriptor_lookup_cache()->Clear();
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001298
ager@chromium.orgeadaf222009-06-16 09:43:10 +00001299 // Used for updating survived_since_last_expansion_ at function end.
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00001300 intptr_t survived_watermark = PromotedSpaceSizeOfObjects();
ager@chromium.orgeadaf222009-06-16 09:43:10 +00001301
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001302 CheckNewSpaceExpansionCriteria();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001303
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001304 SelectScavengingVisitorsTable();
1305
1306 incremental_marking()->PrepareForScavenge();
1307
mstarzinger@chromium.orge3b8d0f2013-02-01 09:06:41 +00001308 paged_space(OLD_DATA_SPACE)->EnsureSweeperProgress(new_space_.Size());
1309 paged_space(OLD_POINTER_SPACE)->EnsureSweeperProgress(new_space_.Size());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001310
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001311 // Flip the semispaces. After flipping, to space is empty, from space has
1312 // live objects.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001313 new_space_.Flip();
1314 new_space_.ResetAllocationInfo();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001315
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001316 // We need to sweep newly copied objects which can be either in the
1317 // to space or promoted to the old generation. For to-space
1318 // objects, we treat the bottom of the to space as a queue. Newly
1319 // copied and unswept objects lie between a 'front' mark and the
1320 // allocation pointer.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001321 //
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001322 // Promoted objects can go into various old-generation spaces, and
1323 // can be allocated internally in the spaces (from the free list).
1324 // We treat the top of the to space as a queue of addresses of
1325 // promoted objects. The addresses of newly promoted and unswept
1326 // objects lie between a 'front' mark and a 'rear' mark that is
1327 // updated as a side effect of promoting an object.
1328 //
1329 // There is guaranteed to be enough room at the top of the to space
1330 // for the addresses of promoted objects: every object promoted
1331 // frees up its size in bytes from the top of the new space, and
1332 // objects are at least one pointer in size.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001333 Address new_space_front = new_space_.ToSpaceStart();
danno@chromium.orgc612e022011-11-10 11:38:15 +00001334 promotion_queue_.Initialize();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001335
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001336#ifdef DEBUG
1337 store_buffer()->Clean();
1338#endif
1339
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001340 ScavengeVisitor scavenge_visitor(this);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001341 // Copy roots.
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001342 IterateRoots(&scavenge_visitor, VISIT_ALL_IN_SCAVENGE);
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001343
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001344 // Copy objects reachable from the old generation.
1345 {
1346 StoreBufferRebuildScope scope(this,
1347 store_buffer(),
1348 &ScavengeStoreBufferCallback);
1349 store_buffer()->IteratePointersToNewSpace(&ScavengeObject);
1350 }
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001351
1352 // Copy objects reachable from cells by scavenging cell values directly.
1353 HeapObjectIterator cell_iterator(cell_space_);
jkummerow@chromium.org000f7fb2012-08-01 11:14:42 +00001354 for (HeapObject* heap_object = cell_iterator.Next();
1355 heap_object != NULL;
1356 heap_object = cell_iterator.Next()) {
1357 if (heap_object->IsJSGlobalPropertyCell()) {
1358 JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(heap_object);
1359 Address value_address = cell->ValueAddress();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001360 scavenge_visitor.VisitPointer(reinterpret_cast<Object**>(value_address));
1361 }
1362 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001363
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001364 // Copy objects reachable from the code flushing candidates list.
1365 MarkCompactCollector* collector = mark_compact_collector();
1366 if (collector->is_code_flushing_enabled()) {
1367 collector->code_flusher()->IteratePointersToFromSpace(&scavenge_visitor);
1368 }
1369
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001370 // Scavenge object reachable from the native contexts list directly.
1371 scavenge_visitor.VisitPointer(BitCast<Object**>(&native_contexts_list_));
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001372
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001373 new_space_front = DoScavenge(&scavenge_visitor, new_space_front);
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00001374
mmassi@chromium.org49a44672012-12-04 13:52:03 +00001375 while (isolate()->global_handles()->IterateObjectGroups(
1376 &scavenge_visitor, &IsUnscavengedHeapObject)) {
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00001377 new_space_front = DoScavenge(&scavenge_visitor, new_space_front);
1378 }
1379 isolate()->global_handles()->RemoveObjectGroups();
yangguo@chromium.org003650e2013-01-24 16:31:08 +00001380 isolate()->global_handles()->RemoveImplicitRefGroups();
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00001381
jkummerow@chromium.orge297f592011-06-08 10:05:15 +00001382 isolate_->global_handles()->IdentifyNewSpaceWeakIndependentHandles(
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +00001383 &IsUnscavengedHeapObject);
jkummerow@chromium.orge297f592011-06-08 10:05:15 +00001384 isolate_->global_handles()->IterateNewSpaceWeakIndependentRoots(
1385 &scavenge_visitor);
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +00001386 new_space_front = DoScavenge(&scavenge_visitor, new_space_front);
1387
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001388 UpdateNewSpaceReferencesInExternalStringTable(
1389 &UpdateNewSpaceReferenceInExternalStringTableEntry);
1390
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00001391 error_object_list_.UpdateReferencesInNewSpace(this);
1392
danno@chromium.orgc612e022011-11-10 11:38:15 +00001393 promotion_queue_.Destroy();
1394
yangguo@chromium.org78d1ad42012-02-09 13:53:47 +00001395 if (!FLAG_watch_ic_patching) {
1396 isolate()->runtime_profiler()->UpdateSamplesAfterScavenge();
1397 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001398 incremental_marking()->UpdateMarkingDequeAfterScavenge();
ager@chromium.org0ee099b2011-01-25 14:06:47 +00001399
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001400 ScavengeWeakObjectRetainer weak_object_retainer(this);
1401 ProcessWeakReferences(&weak_object_retainer);
1402
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001403 ASSERT(new_space_front == new_space_.top());
1404
1405 // Set age mark.
1406 new_space_.set_age_mark(new_space_.top());
1407
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001408 new_space_.LowerInlineAllocationLimit(
1409 new_space_.inline_allocation_limit_step());
1410
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001411 // Update how much has survived scavenge.
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00001412 IncrementYoungSurvivorsCounter(static_cast<int>(
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00001413 (PromotedSpaceSizeOfObjects() - survived_watermark) + new_space_.Size()));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001414
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001415 LOG(isolate_, ResourceEvent("scavenge", "end"));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001416
1417 gc_state_ = NOT_IN_GC;
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00001418
1419 scavenges_since_last_idle_round_++;
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001420}
1421
1422
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001423String* Heap::UpdateNewSpaceReferenceInExternalStringTableEntry(Heap* heap,
1424 Object** p) {
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001425 MapWord first_word = HeapObject::cast(*p)->map_word();
1426
1427 if (!first_word.IsForwardingAddress()) {
1428 // Unreachable external string can be finalized.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001429 heap->FinalizeExternalString(String::cast(*p));
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001430 return NULL;
1431 }
1432
1433 // String is still reachable.
1434 return String::cast(first_word.ToForwardingAddress());
1435}
1436
1437
1438void Heap::UpdateNewSpaceReferencesInExternalStringTable(
1439 ExternalStringTableUpdaterCallback updater_func) {
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001440#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00001441 if (FLAG_verify_heap) {
1442 external_string_table_.Verify();
1443 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00001444#endif
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001445
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001446 if (external_string_table_.new_space_strings_.is_empty()) return;
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001447
danno@chromium.org2ab0c3b2012-10-05 08:50:56 +00001448 Object** start = &external_string_table_.new_space_strings_[0];
1449 Object** end = start + external_string_table_.new_space_strings_.length();
1450 Object** last = start;
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001451
danno@chromium.org2ab0c3b2012-10-05 08:50:56 +00001452 for (Object** p = start; p < end; ++p) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001453 ASSERT(InFromSpace(*p));
1454 String* target = updater_func(this, p);
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001455
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00001456 if (target == NULL) continue;
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001457
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001458 ASSERT(target->IsExternalString());
1459
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001460 if (InNewSpace(target)) {
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001461 // String is still in new space. Update the table entry.
1462 *last = target;
1463 ++last;
1464 } else {
1465 // String got promoted. Move it to the old string list.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001466 external_string_table_.AddOldString(target);
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001467 }
1468 }
1469
danno@chromium.org2ab0c3b2012-10-05 08:50:56 +00001470 ASSERT(last <= end);
1471 external_string_table_.ShrinkNewStrings(static_cast<int>(last - start));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001472}
1473
1474
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001475void Heap::UpdateReferencesInExternalStringTable(
1476 ExternalStringTableUpdaterCallback updater_func) {
1477
1478 // Update old space string references.
1479 if (external_string_table_.old_space_strings_.length() > 0) {
danno@chromium.org2ab0c3b2012-10-05 08:50:56 +00001480 Object** start = &external_string_table_.old_space_strings_[0];
1481 Object** end = start + external_string_table_.old_space_strings_.length();
1482 for (Object** p = start; p < end; ++p) *p = updater_func(this, p);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001483 }
1484
1485 UpdateNewSpaceReferencesInExternalStringTable(updater_func);
1486}
1487
1488
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001489static Object* ProcessFunctionWeakReferences(Heap* heap,
1490 Object* function,
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001491 WeakObjectRetainer* retainer,
1492 bool record_slots) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001493 Object* undefined = heap->undefined_value();
1494 Object* head = undefined;
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001495 JSFunction* tail = NULL;
1496 Object* candidate = function;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001497 while (candidate != undefined) {
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001498 // Check whether to keep the candidate in the list.
1499 JSFunction* candidate_function = reinterpret_cast<JSFunction*>(candidate);
1500 Object* retain = retainer->RetainAs(candidate);
1501 if (retain != NULL) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001502 if (head == undefined) {
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001503 // First element in the list.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001504 head = retain;
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001505 } else {
1506 // Subsequent elements in the list.
1507 ASSERT(tail != NULL);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001508 tail->set_next_function_link(retain);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001509 if (record_slots) {
1510 Object** next_function =
1511 HeapObject::RawField(tail, JSFunction::kNextFunctionLinkOffset);
1512 heap->mark_compact_collector()->RecordSlot(
1513 next_function, next_function, retain);
1514 }
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001515 }
1516 // Retained function is new tail.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001517 candidate_function = reinterpret_cast<JSFunction*>(retain);
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001518 tail = candidate_function;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001519
1520 ASSERT(retain->IsUndefined() || retain->IsJSFunction());
1521
1522 if (retain == undefined) break;
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001523 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001524
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001525 // Move to next element in the list.
1526 candidate = candidate_function->next_function_link();
1527 }
1528
1529 // Terminate the list if there is one or more elements.
1530 if (tail != NULL) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001531 tail->set_next_function_link(undefined);
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001532 }
1533
1534 return head;
1535}
1536
1537
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001538void Heap::ProcessWeakReferences(WeakObjectRetainer* retainer) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001539 Object* undefined = undefined_value();
1540 Object* head = undefined;
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001541 Context* tail = NULL;
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001542 Object* candidate = native_contexts_list_;
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001543
1544 // We don't record weak slots during marking or scavenges.
1545 // Instead we do it once when we complete mark-compact cycle.
1546 // Note that write barrier has no effect if we are already in the middle of
1547 // compacting mark-sweep cycle and we have to record slots manually.
1548 bool record_slots =
1549 gc_state() == MARK_COMPACT &&
1550 mark_compact_collector()->is_compacting();
1551
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001552 while (candidate != undefined) {
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001553 // Check whether to keep the candidate in the list.
1554 Context* candidate_context = reinterpret_cast<Context*>(candidate);
1555 Object* retain = retainer->RetainAs(candidate);
1556 if (retain != NULL) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001557 if (head == undefined) {
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001558 // First element in the list.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001559 head = retain;
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001560 } else {
1561 // Subsequent elements in the list.
1562 ASSERT(tail != NULL);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001563 tail->set_unchecked(this,
1564 Context::NEXT_CONTEXT_LINK,
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001565 retain,
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001566 UPDATE_WRITE_BARRIER);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001567
1568 if (record_slots) {
1569 Object** next_context =
1570 HeapObject::RawField(
1571 tail, FixedArray::SizeFor(Context::NEXT_CONTEXT_LINK));
1572 mark_compact_collector()->RecordSlot(
1573 next_context, next_context, retain);
1574 }
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001575 }
1576 // Retained context is new tail.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001577 candidate_context = reinterpret_cast<Context*>(retain);
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001578 tail = candidate_context;
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001579
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001580 if (retain == undefined) break;
1581
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001582 // Process the weak list of optimized functions for the context.
1583 Object* function_list_head =
1584 ProcessFunctionWeakReferences(
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001585 this,
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001586 candidate_context->get(Context::OPTIMIZED_FUNCTIONS_LIST),
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001587 retainer,
1588 record_slots);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001589 candidate_context->set_unchecked(this,
1590 Context::OPTIMIZED_FUNCTIONS_LIST,
kasperl@chromium.orga5551262010-12-07 12:49:48 +00001591 function_list_head,
1592 UPDATE_WRITE_BARRIER);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001593 if (record_slots) {
1594 Object** optimized_functions =
1595 HeapObject::RawField(
1596 tail, FixedArray::SizeFor(Context::OPTIMIZED_FUNCTIONS_LIST));
1597 mark_compact_collector()->RecordSlot(
1598 optimized_functions, optimized_functions, function_list_head);
1599 }
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001600 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001601
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001602 // Move to next element in the list.
1603 candidate = candidate_context->get(Context::NEXT_CONTEXT_LINK);
1604 }
1605
1606 // Terminate the list if there is one or more elements.
1607 if (tail != NULL) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001608 tail->set_unchecked(this,
1609 Context::NEXT_CONTEXT_LINK,
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001610 Heap::undefined_value(),
1611 UPDATE_WRITE_BARRIER);
1612 }
1613
1614 // Update the head of the list of contexts.
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001615 native_contexts_list_ = head;
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001616}
1617
1618
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00001619void Heap::VisitExternalResources(v8::ExternalResourceVisitor* visitor) {
1620 AssertNoAllocation no_allocation;
1621
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001622 // Both the external string table and the string table may contain
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001623 // external strings, but neither lists them exhaustively, nor is the
1624 // intersection set empty. Therefore we iterate over the external string
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001625 // table first, ignoring internalized strings, and then over the
1626 // internalized string table.
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001627
1628 class ExternalStringTableVisitorAdapter : public ObjectVisitor {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00001629 public:
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001630 explicit ExternalStringTableVisitorAdapter(
1631 v8::ExternalResourceVisitor* visitor) : visitor_(visitor) {}
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00001632 virtual void VisitPointers(Object** start, Object** end) {
1633 for (Object** p = start; p < end; p++) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001634 // Visit non-internalized external strings,
1635 // since internalized strings are listed in the string table.
1636 if (!(*p)->IsInternalizedString()) {
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001637 ASSERT((*p)->IsExternalString());
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00001638 visitor_->VisitExternalString(Utils::ToLocal(
1639 Handle<String>(String::cast(*p))));
1640 }
1641 }
1642 }
1643 private:
1644 v8::ExternalResourceVisitor* visitor_;
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001645 } external_string_table_visitor(visitor);
1646
1647 external_string_table_.Iterate(&external_string_table_visitor);
1648
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001649 class StringTableVisitorAdapter : public ObjectVisitor {
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001650 public:
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001651 explicit StringTableVisitorAdapter(
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001652 v8::ExternalResourceVisitor* visitor) : visitor_(visitor) {}
1653 virtual void VisitPointers(Object** start, Object** end) {
1654 for (Object** p = start; p < end; p++) {
1655 if ((*p)->IsExternalString()) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001656 ASSERT((*p)->IsInternalizedString());
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001657 visitor_->VisitExternalString(Utils::ToLocal(
1658 Handle<String>(String::cast(*p))));
1659 }
1660 }
1661 }
1662 private:
1663 v8::ExternalResourceVisitor* visitor_;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001664 } string_table_visitor(visitor);
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00001665
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00001666 string_table()->IterateElements(&string_table_visitor);
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00001667}
1668
1669
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001670class NewSpaceScavenger : public StaticNewSpaceVisitor<NewSpaceScavenger> {
1671 public:
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001672 static inline void VisitPointer(Heap* heap, Object** p) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001673 Object* object = *p;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001674 if (!heap->InNewSpace(object)) return;
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001675 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
1676 reinterpret_cast<HeapObject*>(object));
1677 }
1678};
1679
1680
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001681Address Heap::DoScavenge(ObjectVisitor* scavenge_visitor,
1682 Address new_space_front) {
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001683 do {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001684 SemiSpace::AssertValidRange(new_space_front, new_space_.top());
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001685 // The addresses new_space_front and new_space_.top() define a
1686 // queue of unprocessed copied objects. Process them until the
1687 // queue is empty.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001688 while (new_space_front != new_space_.top()) {
1689 if (!NewSpacePage::IsAtEnd(new_space_front)) {
1690 HeapObject* object = HeapObject::FromAddress(new_space_front);
1691 new_space_front +=
1692 NewSpaceScavenger::IterateBody(object->map(), object);
1693 } else {
1694 new_space_front =
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00001695 NewSpacePage::FromLimit(new_space_front)->next_page()->area_start();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001696 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001697 }
1698
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001699 // Promote and process all the to-be-promoted objects.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001700 {
1701 StoreBufferRebuildScope scope(this,
1702 store_buffer(),
1703 &ScavengeStoreBufferCallback);
1704 while (!promotion_queue()->is_empty()) {
1705 HeapObject* target;
1706 int size;
1707 promotion_queue()->remove(&target, &size);
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001708
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001709 // Promoted object might be already partially visited
1710 // during old space pointer iteration. Thus we search specificly
1711 // for pointers to from semispace instead of looking for pointers
1712 // to new space.
1713 ASSERT(!target->IsMap());
1714 IterateAndMarkPointersToFromSpace(target->address(),
1715 target->address() + size,
1716 &ScavengeObject);
1717 }
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +00001718 }
1719
1720 // Take another spin if there are now unswept objects in new space
1721 // (there are currently no more unswept promoted objects).
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001722 } while (new_space_front != new_space_.top());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001723
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00001724 return new_space_front;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001725}
1726
1727
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001728STATIC_ASSERT((FixedDoubleArray::kHeaderSize & kDoubleAlignmentMask) == 0);
1729
1730
1731INLINE(static HeapObject* EnsureDoubleAligned(Heap* heap,
1732 HeapObject* object,
1733 int size));
1734
1735static HeapObject* EnsureDoubleAligned(Heap* heap,
1736 HeapObject* object,
1737 int size) {
1738 if ((OffsetFrom(object->address()) & kDoubleAlignmentMask) != 0) {
1739 heap->CreateFillerObjectAt(object->address(), kPointerSize);
1740 return HeapObject::FromAddress(object->address() + kPointerSize);
1741 } else {
1742 heap->CreateFillerObjectAt(object->address() + size - kPointerSize,
1743 kPointerSize);
1744 return object;
1745 }
1746}
1747
1748
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001749enum LoggingAndProfiling {
1750 LOGGING_AND_PROFILING_ENABLED,
1751 LOGGING_AND_PROFILING_DISABLED
1752};
1753
1754
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001755enum MarksHandling { TRANSFER_MARKS, IGNORE_MARKS };
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001756
1757
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001758template<MarksHandling marks_handling,
1759 LoggingAndProfiling logging_and_profiling_mode>
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001760class ScavengingVisitor : public StaticVisitorBase {
1761 public:
1762 static void Initialize() {
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00001763 table_.Register(kVisitSeqOneByteString, &EvacuateSeqOneByteString);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001764 table_.Register(kVisitSeqTwoByteString, &EvacuateSeqTwoByteString);
1765 table_.Register(kVisitShortcutCandidate, &EvacuateShortcutCandidate);
1766 table_.Register(kVisitByteArray, &EvacuateByteArray);
1767 table_.Register(kVisitFixedArray, &EvacuateFixedArray);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001768 table_.Register(kVisitFixedDoubleArray, &EvacuateFixedDoubleArray);
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001769
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00001770 table_.Register(kVisitNativeContext,
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00001771 &ObjectEvacuationStrategy<POINTER_OBJECT>::
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001772 template VisitSpecialized<Context::kSize>);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001773
1774 table_.Register(kVisitConsString,
1775 &ObjectEvacuationStrategy<POINTER_OBJECT>::
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001776 template VisitSpecialized<ConsString::kSize>);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001777
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00001778 table_.Register(kVisitSlicedString,
1779 &ObjectEvacuationStrategy<POINTER_OBJECT>::
1780 template VisitSpecialized<SlicedString::kSize>);
1781
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001782 table_.Register(kVisitSharedFunctionInfo,
1783 &ObjectEvacuationStrategy<POINTER_OBJECT>::
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001784 template VisitSpecialized<SharedFunctionInfo::kSize>);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001785
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00001786 table_.Register(kVisitJSWeakMap,
1787 &ObjectEvacuationStrategy<POINTER_OBJECT>::
1788 Visit);
1789
jkummerow@chromium.orgddda9e82011-07-06 11:27:02 +00001790 table_.Register(kVisitJSRegExp,
1791 &ObjectEvacuationStrategy<POINTER_OBJECT>::
1792 Visit);
1793
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001794 if (marks_handling == IGNORE_MARKS) {
1795 table_.Register(kVisitJSFunction,
1796 &ObjectEvacuationStrategy<POINTER_OBJECT>::
1797 template VisitSpecialized<JSFunction::kSize>);
1798 } else {
1799 table_.Register(kVisitJSFunction, &EvacuateJSFunction);
1800 }
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00001801
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001802 table_.RegisterSpecializations<ObjectEvacuationStrategy<DATA_OBJECT>,
1803 kVisitDataObject,
1804 kVisitDataObjectGeneric>();
1805
1806 table_.RegisterSpecializations<ObjectEvacuationStrategy<POINTER_OBJECT>,
1807 kVisitJSObject,
1808 kVisitJSObjectGeneric>();
1809
1810 table_.RegisterSpecializations<ObjectEvacuationStrategy<POINTER_OBJECT>,
1811 kVisitStruct,
1812 kVisitStructGeneric>();
1813 }
1814
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001815 static VisitorDispatchTable<ScavengingCallback>* GetTable() {
1816 return &table_;
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001817 }
1818
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001819 private:
1820 enum ObjectContents { DATA_OBJECT, POINTER_OBJECT };
1821 enum SizeRestriction { SMALL, UNKNOWN_SIZE };
1822
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001823 static void RecordCopiedObject(Heap* heap, HeapObject* obj) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001824 bool should_record = false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001825#ifdef DEBUG
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001826 should_record = FLAG_heap_stats;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001827#endif
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001828 should_record = should_record || FLAG_log_gc;
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001829 if (should_record) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001830 if (heap->new_space()->Contains(obj)) {
1831 heap->new_space()->RecordAllocation(obj);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001832 } else {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001833 heap->new_space()->RecordPromotion(obj);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001834 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001835 }
1836 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001837
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001838 // Helper function used by CopyObject to copy a source object to an
1839 // allocated target object and update the forwarding pointer in the source
1840 // object. Returns the target object.
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001841 INLINE(static void MigrateObject(Heap* heap,
1842 HeapObject* source,
1843 HeapObject* target,
1844 int size)) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001845 // Copy the content of source to target.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001846 heap->CopyBlock(target->address(), source->address(), size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001847
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001848 // Set the forwarding address.
1849 source->set_map_word(MapWord::FromForwardingAddress(target));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001850
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001851 if (logging_and_profiling_mode == LOGGING_AND_PROFILING_ENABLED) {
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001852 // Update NewSpace stats if necessary.
1853 RecordCopiedObject(heap, target);
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001854 HEAP_PROFILE(heap, ObjectMoveEvent(source->address(), target->address()));
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001855 Isolate* isolate = heap->isolate();
yangguo@chromium.org355cfd12012-08-29 15:32:24 +00001856 if (isolate->logger()->is_logging_code_events() ||
erik.corry@gmail.com3847bd52011-04-27 10:38:56 +00001857 CpuProfiler::is_profiling(isolate)) {
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001858 if (target->IsSharedFunctionInfo()) {
1859 PROFILE(isolate, SharedFunctionInfoMoveEvent(
1860 source->address(), target->address()));
1861 }
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00001862 }
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00001863 }
1864
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001865 if (marks_handling == TRANSFER_MARKS) {
1866 if (Marking::TransferColor(source, target)) {
ulan@chromium.org2efb9002012-01-19 15:36:35 +00001867 MemoryChunk::IncrementLiveBytesFromGC(target->address(), size);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001868 }
1869 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001870 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001871
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001872
1873 template<ObjectContents object_contents,
1874 SizeRestriction size_restriction,
1875 int alignment>
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001876 static inline void EvacuateObject(Map* map,
1877 HeapObject** slot,
1878 HeapObject* object,
1879 int object_size) {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00001880 SLOW_ASSERT((size_restriction != SMALL) ||
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00001881 (object_size <= Page::kMaxNonCodeHeapObjectSize));
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00001882 SLOW_ASSERT(object->Size() == object_size);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001883
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001884 int allocation_size = object_size;
1885 if (alignment != kObjectAlignment) {
1886 ASSERT(alignment == kDoubleAlignment);
1887 allocation_size += kPointerSize;
1888 }
1889
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001890 Heap* heap = map->GetHeap();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001891 if (heap->ShouldBePromoted(object->address(), object_size)) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00001892 MaybeObject* maybe_result;
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001893
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001894 if ((size_restriction != SMALL) &&
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001895 (allocation_size > Page::kMaxNonCodeHeapObjectSize)) {
1896 maybe_result = heap->lo_space()->AllocateRaw(allocation_size,
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001897 NOT_EXECUTABLE);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001898 } else {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001899 if (object_contents == DATA_OBJECT) {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001900 maybe_result = heap->old_data_space()->AllocateRaw(allocation_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001901 } else {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001902 maybe_result =
1903 heap->old_pointer_space()->AllocateRaw(allocation_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001904 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001905 }
1906
lrn@chromium.org303ada72010-10-27 09:33:13 +00001907 Object* result = NULL; // Initialization to please compiler.
1908 if (maybe_result->ToObject(&result)) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001909 HeapObject* target = HeapObject::cast(result);
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001910
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001911 if (alignment != kObjectAlignment) {
1912 target = EnsureDoubleAligned(heap, target, allocation_size);
1913 }
1914
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001915 // Order is important: slot might be inside of the target if target
1916 // was allocated over a dead object and slot comes from the store
1917 // buffer.
1918 *slot = target;
1919 MigrateObject(heap, object, target, object_size);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001920
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001921 if (object_contents == POINTER_OBJECT) {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001922 if (map->instance_type() == JS_FUNCTION_TYPE) {
1923 heap->promotion_queue()->insert(
1924 target, JSFunction::kNonWeakFieldsEndOffset);
1925 } else {
1926 heap->promotion_queue()->insert(target, object_size);
1927 }
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001928 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001929
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00001930 heap->tracer()->increment_promoted_objects_size(object_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001931 return;
1932 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001933 }
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001934 MaybeObject* allocation = heap->new_space()->AllocateRaw(allocation_size);
danno@chromium.orgc612e022011-11-10 11:38:15 +00001935 heap->promotion_queue()->SetNewLimit(heap->new_space()->top());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001936 Object* result = allocation->ToObjectUnchecked();
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001937 HeapObject* target = HeapObject::cast(result);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001938
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001939 if (alignment != kObjectAlignment) {
1940 target = EnsureDoubleAligned(heap, target, allocation_size);
1941 }
1942
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00001943 // Order is important: slot might be inside of the target if target
1944 // was allocated over a dead object and slot comes from the store
1945 // buffer.
1946 *slot = target;
1947 MigrateObject(heap, object, target, object_size);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001948 return;
1949 }
1950
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001951
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00001952 static inline void EvacuateJSFunction(Map* map,
1953 HeapObject** slot,
1954 HeapObject* object) {
1955 ObjectEvacuationStrategy<POINTER_OBJECT>::
1956 template VisitSpecialized<JSFunction::kSize>(map, slot, object);
1957
1958 HeapObject* target = *slot;
1959 MarkBit mark_bit = Marking::MarkBitFrom(target);
1960 if (Marking::IsBlack(mark_bit)) {
1961 // This object is black and it might not be rescanned by marker.
1962 // We should explicitly record code entry slot for compaction because
1963 // promotion queue processing (IterateAndMarkPointersToFromSpace) will
1964 // miss it as it is not HeapObject-tagged.
1965 Address code_entry_slot =
1966 target->address() + JSFunction::kCodeEntryOffset;
1967 Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
1968 map->GetHeap()->mark_compact_collector()->
1969 RecordCodeEntrySlot(code_entry_slot, code);
1970 }
1971 }
1972
1973
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001974 static inline void EvacuateFixedArray(Map* map,
1975 HeapObject** slot,
1976 HeapObject* object) {
1977 int object_size = FixedArray::BodyDescriptor::SizeOf(map, object);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001978 EvacuateObject<POINTER_OBJECT, UNKNOWN_SIZE, kObjectAlignment>(map,
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001979 slot,
1980 object,
1981 object_size);
1982 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00001983
1984
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001985 static inline void EvacuateFixedDoubleArray(Map* map,
1986 HeapObject** slot,
1987 HeapObject* object) {
1988 int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
1989 int object_size = FixedDoubleArray::SizeFor(length);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00001990 EvacuateObject<DATA_OBJECT, UNKNOWN_SIZE, kDoubleAlignment>(
1991 map,
1992 slot,
1993 object,
1994 object_size);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00001995 }
1996
1997
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00001998 static inline void EvacuateByteArray(Map* map,
1999 HeapObject** slot,
2000 HeapObject* object) {
2001 int object_size = reinterpret_cast<ByteArray*>(object)->ByteArraySize();
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00002002 EvacuateObject<DATA_OBJECT, UNKNOWN_SIZE, kObjectAlignment>(
2003 map, slot, object, object_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002004 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002005
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002006
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00002007 static inline void EvacuateSeqOneByteString(Map* map,
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002008 HeapObject** slot,
2009 HeapObject* object) {
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00002010 int object_size = SeqOneByteString::cast(object)->
2011 SeqOneByteStringSize(map->instance_type());
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00002012 EvacuateObject<DATA_OBJECT, UNKNOWN_SIZE, kObjectAlignment>(
2013 map, slot, object, object_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002014 }
2015
2016
2017 static inline void EvacuateSeqTwoByteString(Map* map,
2018 HeapObject** slot,
2019 HeapObject* object) {
2020 int object_size = SeqTwoByteString::cast(object)->
2021 SeqTwoByteStringSize(map->instance_type());
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00002022 EvacuateObject<DATA_OBJECT, UNKNOWN_SIZE, kObjectAlignment>(
2023 map, slot, object, object_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002024 }
2025
2026
2027 static inline bool IsShortcutCandidate(int type) {
2028 return ((type & kShortcutTypeMask) == kShortcutTypeTag);
2029 }
2030
2031 static inline void EvacuateShortcutCandidate(Map* map,
2032 HeapObject** slot,
2033 HeapObject* object) {
2034 ASSERT(IsShortcutCandidate(map->instance_type()));
2035
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002036 Heap* heap = map->GetHeap();
2037
2038 if (marks_handling == IGNORE_MARKS &&
2039 ConsString::cast(object)->unchecked_second() ==
2040 heap->empty_string()) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002041 HeapObject* first =
2042 HeapObject::cast(ConsString::cast(object)->unchecked_first());
2043
2044 *slot = first;
2045
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002046 if (!heap->InNewSpace(first)) {
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002047 object->set_map_word(MapWord::FromForwardingAddress(first));
2048 return;
2049 }
2050
2051 MapWord first_word = first->map_word();
2052 if (first_word.IsForwardingAddress()) {
2053 HeapObject* target = first_word.ToForwardingAddress();
2054
2055 *slot = target;
2056 object->set_map_word(MapWord::FromForwardingAddress(target));
2057 return;
2058 }
2059
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002060 heap->DoScavengeObject(first->map(), slot, first);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002061 object->set_map_word(MapWord::FromForwardingAddress(*slot));
2062 return;
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002063 }
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002064
2065 int object_size = ConsString::kSize;
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00002066 EvacuateObject<POINTER_OBJECT, SMALL, kObjectAlignment>(
2067 map, slot, object, object_size);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002068 }
2069
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002070 template<ObjectContents object_contents>
2071 class ObjectEvacuationStrategy {
2072 public:
2073 template<int object_size>
2074 static inline void VisitSpecialized(Map* map,
2075 HeapObject** slot,
2076 HeapObject* object) {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00002077 EvacuateObject<object_contents, SMALL, kObjectAlignment>(
2078 map, slot, object, object_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002079 }
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002080
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002081 static inline void Visit(Map* map,
2082 HeapObject** slot,
2083 HeapObject* object) {
2084 int object_size = map->instance_size();
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00002085 EvacuateObject<object_contents, SMALL, kObjectAlignment>(
2086 map, slot, object, object_size);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002087 }
2088 };
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002089
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002090 static VisitorDispatchTable<ScavengingCallback> table_;
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002091};
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002092
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002093
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002094template<MarksHandling marks_handling,
2095 LoggingAndProfiling logging_and_profiling_mode>
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002096VisitorDispatchTable<ScavengingCallback>
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002097 ScavengingVisitor<marks_handling, logging_and_profiling_mode>::table_;
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002098
2099
2100static void InitializeScavengingVisitorsTables() {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002101 ScavengingVisitor<TRANSFER_MARKS,
2102 LOGGING_AND_PROFILING_DISABLED>::Initialize();
2103 ScavengingVisitor<IGNORE_MARKS, LOGGING_AND_PROFILING_DISABLED>::Initialize();
2104 ScavengingVisitor<TRANSFER_MARKS,
2105 LOGGING_AND_PROFILING_ENABLED>::Initialize();
2106 ScavengingVisitor<IGNORE_MARKS, LOGGING_AND_PROFILING_ENABLED>::Initialize();
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002107}
2108
2109
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002110void Heap::SelectScavengingVisitorsTable() {
2111 bool logging_and_profiling =
2112 isolate()->logger()->is_logging() ||
erik.corry@gmail.com3847bd52011-04-27 10:38:56 +00002113 CpuProfiler::is_profiling(isolate()) ||
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002114 (isolate()->heap_profiler() != NULL &&
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002115 isolate()->heap_profiler()->is_profiling());
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002116
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002117 if (!incremental_marking()->IsMarking()) {
2118 if (!logging_and_profiling) {
2119 scavenging_visitors_table_.CopyFrom(
2120 ScavengingVisitor<IGNORE_MARKS,
2121 LOGGING_AND_PROFILING_DISABLED>::GetTable());
2122 } else {
2123 scavenging_visitors_table_.CopyFrom(
2124 ScavengingVisitor<IGNORE_MARKS,
2125 LOGGING_AND_PROFILING_ENABLED>::GetTable());
2126 }
2127 } else {
2128 if (!logging_and_profiling) {
2129 scavenging_visitors_table_.CopyFrom(
2130 ScavengingVisitor<TRANSFER_MARKS,
2131 LOGGING_AND_PROFILING_DISABLED>::GetTable());
2132 } else {
2133 scavenging_visitors_table_.CopyFrom(
2134 ScavengingVisitor<TRANSFER_MARKS,
2135 LOGGING_AND_PROFILING_ENABLED>::GetTable());
2136 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002137
2138 if (incremental_marking()->IsCompacting()) {
2139 // When compacting forbid short-circuiting of cons-strings.
2140 // Scavenging code relies on the fact that new space object
2141 // can't be evacuated into evacuation candidate but
2142 // short-circuiting violates this assumption.
2143 scavenging_visitors_table_.Register(
2144 StaticVisitorBase::kVisitShortcutCandidate,
2145 scavenging_visitors_table_.GetVisitorById(
2146 StaticVisitorBase::kVisitConsString));
2147 }
kmillikin@chromium.orgc36ce6e2011-04-04 08:25:31 +00002148 }
2149}
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002150
2151
2152void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00002153 SLOW_ASSERT(HEAP->InFromSpace(object));
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002154 MapWord first_word = object->map_word();
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00002155 SLOW_ASSERT(!first_word.IsForwardingAddress());
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00002156 Map* map = first_word.ToMap();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002157 map->GetHeap()->DoScavengeObject(map, p, object);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002158}
2159
2160
lrn@chromium.org303ada72010-10-27 09:33:13 +00002161MaybeObject* Heap::AllocatePartialMap(InstanceType instance_type,
2162 int instance_size) {
2163 Object* result;
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00002164 MaybeObject* maybe_result = AllocateRawMap();
2165 if (!maybe_result->ToObject(&result)) return maybe_result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002166
2167 // Map::cast cannot be used due to uninitialized map field.
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002168 reinterpret_cast<Map*>(result)->set_map(raw_unchecked_meta_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002169 reinterpret_cast<Map*>(result)->set_instance_type(instance_type);
2170 reinterpret_cast<Map*>(result)->set_instance_size(instance_size);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002171 reinterpret_cast<Map*>(result)->set_visitor_id(
2172 StaticVisitorBase::GetVisitorId(instance_type, instance_size));
ager@chromium.org7c537e22008-10-16 08:43:32 +00002173 reinterpret_cast<Map*>(result)->set_inobject_properties(0);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00002174 reinterpret_cast<Map*>(result)->set_pre_allocated_property_fields(0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002175 reinterpret_cast<Map*>(result)->set_unused_property_fields(0);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00002176 reinterpret_cast<Map*>(result)->set_bit_field(0);
2177 reinterpret_cast<Map*>(result)->set_bit_field2(0);
verwaest@chromium.org06ab2ec2012-10-09 17:00:13 +00002178 int bit_field3 = Map::EnumLengthBits::encode(Map::kInvalidEnumCache) |
2179 Map::OwnsDescriptors::encode(true);
2180 reinterpret_cast<Map*>(result)->set_bit_field3(bit_field3);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002181 return result;
2182}
2183
2184
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002185MaybeObject* Heap::AllocateMap(InstanceType instance_type,
2186 int instance_size,
2187 ElementsKind elements_kind) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00002188 Object* result;
yangguo@chromium.org304cc332012-07-24 07:59:48 +00002189 MaybeObject* maybe_result = AllocateRawMap();
2190 if (!maybe_result->To(&result)) return maybe_result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002191
2192 Map* map = reinterpret_cast<Map*>(result);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00002193 map->set_map_no_write_barrier(meta_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002194 map->set_instance_type(instance_type);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00002195 map->set_visitor_id(
2196 StaticVisitorBase::GetVisitorId(instance_type, instance_size));
ricow@chromium.org27bf2882011-11-17 08:34:43 +00002197 map->set_prototype(null_value(), SKIP_WRITE_BARRIER);
2198 map->set_constructor(null_value(), SKIP_WRITE_BARRIER);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002199 map->set_instance_size(instance_size);
ager@chromium.org7c537e22008-10-16 08:43:32 +00002200 map->set_inobject_properties(0);
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002201 map->set_pre_allocated_property_fields(0);
ricow@chromium.org27bf2882011-11-17 08:34:43 +00002202 map->set_code_cache(empty_fixed_array(), SKIP_WRITE_BARRIER);
ulan@chromium.org2e04b582013-02-21 14:06:02 +00002203 map->set_dependent_code(DependentCode::cast(empty_fixed_array()),
2204 SKIP_WRITE_BARRIER);
danno@chromium.org81cac2b2012-07-10 11:28:27 +00002205 map->init_back_pointer(undefined_value());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002206 map->set_unused_property_fields(0);
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00002207 map->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002208 map->set_bit_field(0);
erik.corry@gmail.comd6076d92011-06-06 09:39:18 +00002209 map->set_bit_field2(1 << Map::kIsExtensible);
verwaest@chromium.org06ab2ec2012-10-09 17:00:13 +00002210 int bit_field3 = Map::EnumLengthBits::encode(Map::kInvalidEnumCache) |
2211 Map::OwnsDescriptors::encode(true);
yangguo@chromium.org355cfd12012-08-29 15:32:24 +00002212 map->set_bit_field3(bit_field3);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002213 map->set_elements_kind(elements_kind);
sgjesse@chromium.org846fb742009-12-18 08:56:33 +00002214
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002215 return map;
2216}
2217
2218
lrn@chromium.org303ada72010-10-27 09:33:13 +00002219MaybeObject* Heap::AllocateCodeCache() {
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00002220 CodeCache* code_cache;
2221 { MaybeObject* maybe_code_cache = AllocateStruct(CODE_CACHE_TYPE);
2222 if (!maybe_code_cache->To(&code_cache)) return maybe_code_cache;
lrn@chromium.org303ada72010-10-27 09:33:13 +00002223 }
ricow@chromium.org27bf2882011-11-17 08:34:43 +00002224 code_cache->set_default_cache(empty_fixed_array(), SKIP_WRITE_BARRIER);
2225 code_cache->set_normal_type_cache(undefined_value(), SKIP_WRITE_BARRIER);
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00002226 return code_cache;
2227}
2228
2229
jkummerow@chromium.orge297f592011-06-08 10:05:15 +00002230MaybeObject* Heap::AllocatePolymorphicCodeCache() {
2231 return AllocateStruct(POLYMORPHIC_CODE_CACHE_TYPE);
2232}
2233
2234
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002235MaybeObject* Heap::AllocateAccessorPair() {
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00002236 AccessorPair* accessors;
2237 { MaybeObject* maybe_accessors = AllocateStruct(ACCESSOR_PAIR_TYPE);
2238 if (!maybe_accessors->To(&accessors)) return maybe_accessors;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002239 }
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00002240 accessors->set_getter(the_hole_value(), SKIP_WRITE_BARRIER);
2241 accessors->set_setter(the_hole_value(), SKIP_WRITE_BARRIER);
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002242 return accessors;
2243}
2244
2245
jkummerow@chromium.orgf7a58842012-02-21 10:08:21 +00002246MaybeObject* Heap::AllocateTypeFeedbackInfo() {
2247 TypeFeedbackInfo* info;
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00002248 { MaybeObject* maybe_info = AllocateStruct(TYPE_FEEDBACK_INFO_TYPE);
2249 if (!maybe_info->To(&info)) return maybe_info;
jkummerow@chromium.orgf7a58842012-02-21 10:08:21 +00002250 }
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00002251 info->initialize_storage();
jkummerow@chromium.orgf7a58842012-02-21 10:08:21 +00002252 info->set_type_feedback_cells(TypeFeedbackCells::cast(empty_fixed_array()),
2253 SKIP_WRITE_BARRIER);
2254 return info;
2255}
2256
2257
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00002258MaybeObject* Heap::AllocateAliasedArgumentsEntry(int aliased_context_slot) {
2259 AliasedArgumentsEntry* entry;
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00002260 { MaybeObject* maybe_entry = AllocateStruct(ALIASED_ARGUMENTS_ENTRY_TYPE);
2261 if (!maybe_entry->To(&entry)) return maybe_entry;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00002262 }
2263 entry->set_aliased_context_slot(aliased_context_slot);
2264 return entry;
2265}
2266
2267
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002268const Heap::StringTypeTable Heap::string_type_table[] = {
2269#define STRING_TYPE_ELEMENT(type, size, name, camel_name) \
2270 {type, size, k##camel_name##MapRootIndex},
2271 STRING_TYPE_LIST(STRING_TYPE_ELEMENT)
2272#undef STRING_TYPE_ELEMENT
2273};
2274
2275
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002276const Heap::ConstantStringTable Heap::constant_string_table[] = {
2277#define CONSTANT_STRING_ELEMENT(name, contents) \
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002278 {contents, k##name##RootIndex},
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002279 INTERNALIZED_STRING_LIST(CONSTANT_STRING_ELEMENT)
2280#undef CONSTANT_STRING_ELEMENT
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002281};
2282
2283
2284const Heap::StructTable Heap::struct_table[] = {
2285#define STRUCT_TABLE_ELEMENT(NAME, Name, name) \
2286 { NAME##_TYPE, Name::kSize, k##Name##MapRootIndex },
2287 STRUCT_LIST(STRUCT_TABLE_ELEMENT)
2288#undef STRUCT_TABLE_ELEMENT
2289};
2290
2291
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002292bool Heap::CreateInitialMaps() {
lrn@chromium.org303ada72010-10-27 09:33:13 +00002293 Object* obj;
2294 { MaybeObject* maybe_obj = AllocatePartialMap(MAP_TYPE, Map::kSize);
2295 if (!maybe_obj->ToObject(&obj)) return false;
2296 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002297 // Map::cast cannot be used due to uninitialized map field.
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002298 Map* new_meta_map = reinterpret_cast<Map*>(obj);
2299 set_meta_map(new_meta_map);
2300 new_meta_map->set_map(new_meta_map);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002301
lrn@chromium.org303ada72010-10-27 09:33:13 +00002302 { MaybeObject* maybe_obj =
2303 AllocatePartialMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2304 if (!maybe_obj->ToObject(&obj)) return false;
2305 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002306 set_fixed_array_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002307
lrn@chromium.org303ada72010-10-27 09:33:13 +00002308 { MaybeObject* maybe_obj = AllocatePartialMap(ODDBALL_TYPE, Oddball::kSize);
2309 if (!maybe_obj->ToObject(&obj)) return false;
2310 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002311 set_oddball_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002312
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +00002313 // Allocate the empty array.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002314 { MaybeObject* maybe_obj = AllocateEmptyFixedArray();
2315 if (!maybe_obj->ToObject(&obj)) return false;
2316 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002317 set_empty_fixed_array(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002318
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002319 { MaybeObject* maybe_obj = Allocate(oddball_map(), OLD_POINTER_SPACE);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002320 if (!maybe_obj->ToObject(&obj)) return false;
2321 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002322 set_null_value(Oddball::cast(obj));
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002323 Oddball::cast(obj)->set_kind(Oddball::kNull);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002324
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002325 { MaybeObject* maybe_obj = Allocate(oddball_map(), OLD_POINTER_SPACE);
2326 if (!maybe_obj->ToObject(&obj)) return false;
2327 }
2328 set_undefined_value(Oddball::cast(obj));
2329 Oddball::cast(obj)->set_kind(Oddball::kUndefined);
2330 ASSERT(!InNewSpace(undefined_value()));
2331
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002332 // Allocate the empty descriptor array.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002333 { MaybeObject* maybe_obj = AllocateEmptyFixedArray();
2334 if (!maybe_obj->ToObject(&obj)) return false;
2335 }
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002336 set_empty_descriptor_array(DescriptorArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002337
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00002338 // Fix the instance_descriptors for the existing maps.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002339 meta_map()->set_code_cache(empty_fixed_array());
ulan@chromium.org2e04b582013-02-21 14:06:02 +00002340 meta_map()->set_dependent_code(DependentCode::cast(empty_fixed_array()));
danno@chromium.org81cac2b2012-07-10 11:28:27 +00002341 meta_map()->init_back_pointer(undefined_value());
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00002342 meta_map()->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002343
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002344 fixed_array_map()->set_code_cache(empty_fixed_array());
ulan@chromium.org2e04b582013-02-21 14:06:02 +00002345 fixed_array_map()->set_dependent_code(
2346 DependentCode::cast(empty_fixed_array()));
danno@chromium.org81cac2b2012-07-10 11:28:27 +00002347 fixed_array_map()->init_back_pointer(undefined_value());
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00002348 fixed_array_map()->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002349
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002350 oddball_map()->set_code_cache(empty_fixed_array());
ulan@chromium.org2e04b582013-02-21 14:06:02 +00002351 oddball_map()->set_dependent_code(DependentCode::cast(empty_fixed_array()));
danno@chromium.org81cac2b2012-07-10 11:28:27 +00002352 oddball_map()->init_back_pointer(undefined_value());
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00002353 oddball_map()->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002354
2355 // Fix prototype object for existing maps.
2356 meta_map()->set_prototype(null_value());
2357 meta_map()->set_constructor(null_value());
2358
2359 fixed_array_map()->set_prototype(null_value());
2360 fixed_array_map()->set_constructor(null_value());
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002361
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002362 oddball_map()->set_prototype(null_value());
2363 oddball_map()->set_constructor(null_value());
2364
lrn@chromium.org303ada72010-10-27 09:33:13 +00002365 { MaybeObject* maybe_obj =
2366 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2367 if (!maybe_obj->ToObject(&obj)) return false;
2368 }
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00002369 set_fixed_cow_array_map(Map::cast(obj));
2370 ASSERT(fixed_array_map() != fixed_cow_array_map());
2371
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00002372 { MaybeObject* maybe_obj =
2373 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2374 if (!maybe_obj->ToObject(&obj)) return false;
2375 }
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00002376 set_scope_info_map(Map::cast(obj));
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00002377
lrn@chromium.org303ada72010-10-27 09:33:13 +00002378 { MaybeObject* maybe_obj = AllocateMap(HEAP_NUMBER_TYPE, HeapNumber::kSize);
2379 if (!maybe_obj->ToObject(&obj)) return false;
2380 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002381 set_heap_number_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002382
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002383 { MaybeObject* maybe_obj = AllocateMap(SYMBOL_TYPE, Symbol::kSize);
2384 if (!maybe_obj->ToObject(&obj)) return false;
2385 }
2386 set_symbol_map(Map::cast(obj));
2387
ager@chromium.orgea91cc52011-05-23 06:06:11 +00002388 { MaybeObject* maybe_obj = AllocateMap(FOREIGN_TYPE, Foreign::kSize);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002389 if (!maybe_obj->ToObject(&obj)) return false;
2390 }
ager@chromium.orgea91cc52011-05-23 06:06:11 +00002391 set_foreign_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002392
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002393 for (unsigned i = 0; i < ARRAY_SIZE(string_type_table); i++) {
2394 const StringTypeTable& entry = string_type_table[i];
lrn@chromium.org303ada72010-10-27 09:33:13 +00002395 { MaybeObject* maybe_obj = AllocateMap(entry.type, entry.size);
2396 if (!maybe_obj->ToObject(&obj)) return false;
2397 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002398 roots_[entry.index] = Map::cast(obj);
2399 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002400
lrn@chromium.org303ada72010-10-27 09:33:13 +00002401 { MaybeObject* maybe_obj = AllocateMap(STRING_TYPE, kVariableSizeSentinel);
2402 if (!maybe_obj->ToObject(&obj)) return false;
2403 }
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002404 set_undetectable_string_map(Map::cast(obj));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002405 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002406
lrn@chromium.org303ada72010-10-27 09:33:13 +00002407 { MaybeObject* maybe_obj =
2408 AllocateMap(ASCII_STRING_TYPE, kVariableSizeSentinel);
2409 if (!maybe_obj->ToObject(&obj)) return false;
2410 }
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00002411 set_undetectable_ascii_string_map(Map::cast(obj));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002412 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002413
lrn@chromium.org303ada72010-10-27 09:33:13 +00002414 { MaybeObject* maybe_obj =
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00002415 AllocateMap(FIXED_DOUBLE_ARRAY_TYPE, kVariableSizeSentinel);
2416 if (!maybe_obj->ToObject(&obj)) return false;
2417 }
2418 set_fixed_double_array_map(Map::cast(obj));
2419
2420 { MaybeObject* maybe_obj =
lrn@chromium.org303ada72010-10-27 09:33:13 +00002421 AllocateMap(BYTE_ARRAY_TYPE, kVariableSizeSentinel);
2422 if (!maybe_obj->ToObject(&obj)) return false;
2423 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002424 set_byte_array_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002425
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002426 { MaybeObject* maybe_obj =
2427 AllocateMap(FREE_SPACE_TYPE, kVariableSizeSentinel);
2428 if (!maybe_obj->ToObject(&obj)) return false;
2429 }
2430 set_free_space_map(Map::cast(obj));
2431
kasperl@chromium.orga5551262010-12-07 12:49:48 +00002432 { MaybeObject* maybe_obj = AllocateByteArray(0, TENURED);
2433 if (!maybe_obj->ToObject(&obj)) return false;
2434 }
2435 set_empty_byte_array(ByteArray::cast(obj));
2436
lrn@chromium.org303ada72010-10-27 09:33:13 +00002437 { MaybeObject* maybe_obj =
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00002438 AllocateMap(EXTERNAL_PIXEL_ARRAY_TYPE, ExternalArray::kAlignedSize);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002439 if (!maybe_obj->ToObject(&obj)) return false;
2440 }
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00002441 set_external_pixel_array_map(Map::cast(obj));
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002442
lrn@chromium.org303ada72010-10-27 09:33:13 +00002443 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_BYTE_ARRAY_TYPE,
2444 ExternalArray::kAlignedSize);
2445 if (!maybe_obj->ToObject(&obj)) return false;
2446 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002447 set_external_byte_array_map(Map::cast(obj));
2448
lrn@chromium.org303ada72010-10-27 09:33:13 +00002449 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE,
2450 ExternalArray::kAlignedSize);
2451 if (!maybe_obj->ToObject(&obj)) return false;
2452 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002453 set_external_unsigned_byte_array_map(Map::cast(obj));
2454
lrn@chromium.org303ada72010-10-27 09:33:13 +00002455 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_SHORT_ARRAY_TYPE,
2456 ExternalArray::kAlignedSize);
2457 if (!maybe_obj->ToObject(&obj)) return false;
2458 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002459 set_external_short_array_map(Map::cast(obj));
2460
lrn@chromium.org303ada72010-10-27 09:33:13 +00002461 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE,
2462 ExternalArray::kAlignedSize);
2463 if (!maybe_obj->ToObject(&obj)) return false;
2464 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002465 set_external_unsigned_short_array_map(Map::cast(obj));
2466
lrn@chromium.org303ada72010-10-27 09:33:13 +00002467 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_INT_ARRAY_TYPE,
2468 ExternalArray::kAlignedSize);
2469 if (!maybe_obj->ToObject(&obj)) return false;
2470 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002471 set_external_int_array_map(Map::cast(obj));
2472
lrn@chromium.org303ada72010-10-27 09:33:13 +00002473 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_UNSIGNED_INT_ARRAY_TYPE,
2474 ExternalArray::kAlignedSize);
2475 if (!maybe_obj->ToObject(&obj)) return false;
2476 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002477 set_external_unsigned_int_array_map(Map::cast(obj));
2478
lrn@chromium.org303ada72010-10-27 09:33:13 +00002479 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_FLOAT_ARRAY_TYPE,
2480 ExternalArray::kAlignedSize);
2481 if (!maybe_obj->ToObject(&obj)) return false;
2482 }
ager@chromium.org3811b432009-10-28 14:53:37 +00002483 set_external_float_array_map(Map::cast(obj));
2484
whesse@chromium.org7b260152011-06-20 15:33:18 +00002485 { MaybeObject* maybe_obj =
2486 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2487 if (!maybe_obj->ToObject(&obj)) return false;
2488 }
2489 set_non_strict_arguments_elements_map(Map::cast(obj));
2490
erik.corry@gmail.com3847bd52011-04-27 10:38:56 +00002491 { MaybeObject* maybe_obj = AllocateMap(EXTERNAL_DOUBLE_ARRAY_TYPE,
2492 ExternalArray::kAlignedSize);
2493 if (!maybe_obj->ToObject(&obj)) return false;
2494 }
2495 set_external_double_array_map(Map::cast(obj));
2496
lrn@chromium.org303ada72010-10-27 09:33:13 +00002497 { MaybeObject* maybe_obj = AllocateMap(CODE_TYPE, kVariableSizeSentinel);
2498 if (!maybe_obj->ToObject(&obj)) return false;
2499 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002500 set_code_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002501
lrn@chromium.org303ada72010-10-27 09:33:13 +00002502 { MaybeObject* maybe_obj = AllocateMap(JS_GLOBAL_PROPERTY_CELL_TYPE,
2503 JSGlobalPropertyCell::kSize);
2504 if (!maybe_obj->ToObject(&obj)) return false;
2505 }
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002506 set_global_property_cell_map(Map::cast(obj));
2507
lrn@chromium.org303ada72010-10-27 09:33:13 +00002508 { MaybeObject* maybe_obj = AllocateMap(FILLER_TYPE, kPointerSize);
2509 if (!maybe_obj->ToObject(&obj)) return false;
2510 }
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002511 set_one_pointer_filler_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002512
lrn@chromium.org303ada72010-10-27 09:33:13 +00002513 { MaybeObject* maybe_obj = AllocateMap(FILLER_TYPE, 2 * kPointerSize);
2514 if (!maybe_obj->ToObject(&obj)) return false;
2515 }
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002516 set_two_pointer_filler_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002517
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002518 for (unsigned i = 0; i < ARRAY_SIZE(struct_table); i++) {
2519 const StructTable& entry = struct_table[i];
lrn@chromium.org303ada72010-10-27 09:33:13 +00002520 { MaybeObject* maybe_obj = AllocateMap(entry.type, entry.size);
2521 if (!maybe_obj->ToObject(&obj)) return false;
2522 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002523 roots_[entry.index] = Map::cast(obj);
2524 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002525
lrn@chromium.org303ada72010-10-27 09:33:13 +00002526 { MaybeObject* maybe_obj =
2527 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2528 if (!maybe_obj->ToObject(&obj)) return false;
2529 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002530 set_hash_table_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002531
lrn@chromium.org303ada72010-10-27 09:33:13 +00002532 { MaybeObject* maybe_obj =
2533 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2534 if (!maybe_obj->ToObject(&obj)) return false;
2535 }
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00002536 set_function_context_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002537
lrn@chromium.org303ada72010-10-27 09:33:13 +00002538 { MaybeObject* maybe_obj =
2539 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2540 if (!maybe_obj->ToObject(&obj)) return false;
2541 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002542 set_catch_context_map(Map::cast(obj));
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00002543
lrn@chromium.org303ada72010-10-27 09:33:13 +00002544 { MaybeObject* maybe_obj =
2545 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2546 if (!maybe_obj->ToObject(&obj)) return false;
2547 }
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00002548 set_with_context_map(Map::cast(obj));
2549
2550 { MaybeObject* maybe_obj =
2551 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2552 if (!maybe_obj->ToObject(&obj)) return false;
2553 }
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00002554 set_block_context_map(Map::cast(obj));
2555
2556 { MaybeObject* maybe_obj =
2557 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2558 if (!maybe_obj->ToObject(&obj)) return false;
2559 }
jkummerow@chromium.orgf7a58842012-02-21 10:08:21 +00002560 set_module_context_map(Map::cast(obj));
2561
2562 { MaybeObject* maybe_obj =
2563 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2564 if (!maybe_obj->ToObject(&obj)) return false;
2565 }
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00002566 set_global_context_map(Map::cast(obj));
2567
2568 { MaybeObject* maybe_obj =
2569 AllocateMap(FIXED_ARRAY_TYPE, kVariableSizeSentinel);
2570 if (!maybe_obj->ToObject(&obj)) return false;
2571 }
2572 Map* native_context_map = Map::cast(obj);
2573 native_context_map->set_dictionary_map(true);
2574 native_context_map->set_visitor_id(StaticVisitorBase::kVisitNativeContext);
2575 set_native_context_map(native_context_map);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002576
lrn@chromium.org303ada72010-10-27 09:33:13 +00002577 { MaybeObject* maybe_obj = AllocateMap(SHARED_FUNCTION_INFO_TYPE,
2578 SharedFunctionInfo::kAlignedSize);
2579 if (!maybe_obj->ToObject(&obj)) return false;
2580 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002581 set_shared_function_info_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002582
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00002583 { MaybeObject* maybe_obj = AllocateMap(JS_MESSAGE_OBJECT_TYPE,
2584 JSMessageObject::kSize);
2585 if (!maybe_obj->ToObject(&obj)) return false;
2586 }
2587 set_message_object_map(Map::cast(obj));
2588
yangguo@chromium.orgeeb44b62012-11-13 13:56:09 +00002589 Map* external_map;
2590 { MaybeObject* maybe_obj =
2591 AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize + kPointerSize);
2592 if (!maybe_obj->To(&external_map)) return false;
2593 }
2594 external_map->set_is_extensible(false);
2595 set_external_map(external_map);
2596
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002597 ASSERT(!InNewSpace(empty_fixed_array()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002598 return true;
2599}
2600
2601
lrn@chromium.org303ada72010-10-27 09:33:13 +00002602MaybeObject* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002603 // Statically ensure that it is safe to allocate heap numbers in paged
2604 // spaces.
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00002605 STATIC_ASSERT(HeapNumber::kSize <= Page::kNonCodeObjectAreaSize);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002606 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00002607
lrn@chromium.org303ada72010-10-27 09:33:13 +00002608 Object* result;
2609 { MaybeObject* maybe_result =
2610 AllocateRaw(HeapNumber::kSize, space, OLD_DATA_SPACE);
2611 if (!maybe_result->ToObject(&result)) return maybe_result;
2612 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002613
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00002614 HeapObject::cast(result)->set_map_no_write_barrier(heap_number_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002615 HeapNumber::cast(result)->set_value(value);
2616 return result;
2617}
2618
2619
lrn@chromium.org303ada72010-10-27 09:33:13 +00002620MaybeObject* Heap::AllocateHeapNumber(double value) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002621 // Use general version, if we're forced to always allocate.
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00002622 if (always_allocate()) return AllocateHeapNumber(value, TENURED);
2623
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002624 // This version of AllocateHeapNumber is optimized for
2625 // allocation in new space.
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00002626 STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxNonCodeHeapObjectSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002627 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002628 Object* result;
2629 { MaybeObject* maybe_result = new_space_.AllocateRaw(HeapNumber::kSize);
2630 if (!maybe_result->ToObject(&result)) return maybe_result;
2631 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00002632 HeapObject::cast(result)->set_map_no_write_barrier(heap_number_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002633 HeapNumber::cast(result)->set_value(value);
2634 return result;
2635}
2636
2637
lrn@chromium.org303ada72010-10-27 09:33:13 +00002638MaybeObject* Heap::AllocateJSGlobalPropertyCell(Object* value) {
2639 Object* result;
2640 { MaybeObject* maybe_result = AllocateRawCell();
2641 if (!maybe_result->ToObject(&result)) return maybe_result;
2642 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00002643 HeapObject::cast(result)->set_map_no_write_barrier(
2644 global_property_cell_map());
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002645 JSGlobalPropertyCell::cast(result)->set_value(value);
2646 return result;
2647}
2648
2649
lrn@chromium.org303ada72010-10-27 09:33:13 +00002650MaybeObject* Heap::CreateOddball(const char* to_string,
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002651 Object* to_number,
2652 byte kind) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00002653 Object* result;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002654 { MaybeObject* maybe_result = Allocate(oddball_map(), OLD_POINTER_SPACE);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002655 if (!maybe_result->ToObject(&result)) return maybe_result;
2656 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002657 return Oddball::cast(result)->Initialize(to_string, to_number, kind);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002658}
2659
2660
2661bool Heap::CreateApiObjects() {
2662 Object* obj;
2663
lrn@chromium.org303ada72010-10-27 09:33:13 +00002664 { MaybeObject* maybe_obj = AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
2665 if (!maybe_obj->ToObject(&obj)) return false;
2666 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002667 // Don't use Smi-only elements optimizations for objects with the neander
2668 // map. There are too many cases where element values are set directly with a
2669 // bottleneck to trap the Smi-only -> fast elements transition, and there
2670 // appears to be no benefit for optimize this case.
2671 Map* new_neander_map = Map::cast(obj);
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00002672 new_neander_map->set_elements_kind(TERMINAL_FAST_ELEMENTS_KIND);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002673 set_neander_map(new_neander_map);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002674
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002675 { MaybeObject* maybe_obj = AllocateJSObjectFromMap(neander_map());
lrn@chromium.org303ada72010-10-27 09:33:13 +00002676 if (!maybe_obj->ToObject(&obj)) return false;
2677 }
2678 Object* elements;
2679 { MaybeObject* maybe_elements = AllocateFixedArray(2);
2680 if (!maybe_elements->ToObject(&elements)) return false;
2681 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002682 FixedArray::cast(elements)->set(0, Smi::FromInt(0));
2683 JSObject::cast(obj)->set_elements(FixedArray::cast(elements));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002684 set_message_listeners(JSObject::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002685
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002686 return true;
2687}
2688
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002689
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002690void Heap::CreateJSEntryStub() {
2691 JSEntryStub stub;
hpayer@chromium.org8432c912013-02-28 15:55:26 +00002692 set_js_entry_code(*stub.GetCode(isolate()));
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002693}
2694
2695
2696void Heap::CreateJSConstructEntryStub() {
2697 JSConstructEntryStub stub;
hpayer@chromium.org8432c912013-02-28 15:55:26 +00002698 set_js_construct_entry_code(*stub.GetCode(isolate()));
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002699}
2700
2701
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002702void Heap::CreateFixedStubs() {
2703 // Here we create roots for fixed stubs. They are needed at GC
2704 // for cooking and uncooking (check out frames.cc).
2705 // The eliminates the need for doing dictionary lookup in the
2706 // stub cache for these stubs.
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00002707 HandleScope scope(isolate());
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002708 // gcc-4.4 has problem generating correct code of following snippet:
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00002709 // { JSEntryStub stub;
2710 // js_entry_code_ = *stub.GetCode();
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002711 // }
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00002712 // { JSConstructEntryStub stub;
2713 // js_construct_entry_code_ = *stub.GetCode();
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002714 // }
2715 // To workaround the problem, make separate functions without inlining.
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002716 Heap::CreateJSEntryStub();
2717 Heap::CreateJSConstructEntryStub();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002718
2719 // Create stubs that should be there, so we don't unexpectedly have to
2720 // create them if we need them during the creation of another stub.
2721 // Stub creation mixes raw pointers and handles in an unsafe manner so
2722 // we cannot create stubs while we are creating stubs.
hpayer@chromium.org8432c912013-02-28 15:55:26 +00002723 CodeStub::GenerateStubsAheadOfTime(isolate());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002724}
2725
2726
2727bool Heap::CreateInitialObjects() {
2728 Object* obj;
2729
2730 // The -0 value must be set before NumberFromDouble works.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002731 { MaybeObject* maybe_obj = AllocateHeapNumber(-0.0, TENURED);
2732 if (!maybe_obj->ToObject(&obj)) return false;
2733 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002734 set_minus_zero_value(HeapNumber::cast(obj));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002735 ASSERT(signbit(minus_zero_value()->Number()) != 0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002736
lrn@chromium.org303ada72010-10-27 09:33:13 +00002737 { MaybeObject* maybe_obj = AllocateHeapNumber(OS::nan_value(), TENURED);
2738 if (!maybe_obj->ToObject(&obj)) return false;
2739 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002740 set_nan_value(HeapNumber::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002741
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00002742 { MaybeObject* maybe_obj = AllocateHeapNumber(V8_INFINITY, TENURED);
2743 if (!maybe_obj->ToObject(&obj)) return false;
2744 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002745 set_infinity_value(HeapNumber::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002746
rossberg@chromium.orgfab14982012-01-05 15:02:15 +00002747 // The hole has not been created yet, but we want to put something
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002748 // predictable in the gaps in the string table, so lets make that Smi zero.
rossberg@chromium.orgfab14982012-01-05 15:02:15 +00002749 set_the_hole_value(reinterpret_cast<Oddball*>(Smi::FromInt(0)));
2750
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002751 // Allocate initial string table.
2752 { MaybeObject* maybe_obj = StringTable::Allocate(kInitialStringTableSize);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002753 if (!maybe_obj->ToObject(&obj)) return false;
2754 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002755 // Don't use set_string_table() due to asserts.
2756 roots_[kStringTableRootIndex] = obj;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002757
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002758 // Finish initializing oddballs after creating the string table.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002759 { MaybeObject* maybe_obj =
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002760 undefined_value()->Initialize("undefined",
2761 nan_value(),
2762 Oddball::kUndefined);
2763 if (!maybe_obj->ToObject(&obj)) return false;
2764 }
2765
2766 // Initialize the null_value.
2767 { MaybeObject* maybe_obj =
2768 null_value()->Initialize("null", Smi::FromInt(0), Oddball::kNull);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002769 if (!maybe_obj->ToObject(&obj)) return false;
2770 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002771
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002772 { MaybeObject* maybe_obj = CreateOddball("true",
2773 Smi::FromInt(1),
2774 Oddball::kTrue);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002775 if (!maybe_obj->ToObject(&obj)) return false;
2776 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002777 set_true_value(Oddball::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002778
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002779 { MaybeObject* maybe_obj = CreateOddball("false",
2780 Smi::FromInt(0),
2781 Oddball::kFalse);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002782 if (!maybe_obj->ToObject(&obj)) return false;
2783 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002784 set_false_value(Oddball::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002785
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002786 { MaybeObject* maybe_obj = CreateOddball("hole",
2787 Smi::FromInt(-1),
2788 Oddball::kTheHole);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002789 if (!maybe_obj->ToObject(&obj)) return false;
2790 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002791 set_the_hole_value(Oddball::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002792
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +00002793 { MaybeObject* maybe_obj = CreateOddball("arguments_marker",
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00002794 Smi::FromInt(-4),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002795 Oddball::kArgumentMarker);
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +00002796 if (!maybe_obj->ToObject(&obj)) return false;
2797 }
svenpanne@chromium.orga8bb4d92011-10-10 13:20:40 +00002798 set_arguments_marker(Oddball::cast(obj));
kmillikin@chromium.orgd2c22f02011-01-10 08:15:37 +00002799
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002800 { MaybeObject* maybe_obj = CreateOddball("no_interceptor_result_sentinel",
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00002801 Smi::FromInt(-2),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002802 Oddball::kOther);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002803 if (!maybe_obj->ToObject(&obj)) return false;
2804 }
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002805 set_no_interceptor_result_sentinel(obj);
2806
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002807 { MaybeObject* maybe_obj = CreateOddball("termination_exception",
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00002808 Smi::FromInt(-3),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002809 Oddball::kOther);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002810 if (!maybe_obj->ToObject(&obj)) return false;
2811 }
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +00002812 set_termination_exception(obj);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002813
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002814 for (unsigned i = 0; i < ARRAY_SIZE(constant_string_table); i++) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00002815 { MaybeObject* maybe_obj =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002816 InternalizeUtf8String(constant_string_table[i].contents);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002817 if (!maybe_obj->ToObject(&obj)) return false;
2818 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002819 roots_[constant_string_table[i].index] = String::cast(obj);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002820 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002821
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002822 // Allocate the hidden string which is used to identify the hidden properties
ager@chromium.org3b45ab52009-03-19 22:21:34 +00002823 // in JSObjects. The hash code has a special value so that it will not match
2824 // the empty string when searching for the property. It cannot be part of the
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002825 // loop above because it needs to be allocated manually with the special
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002826 // hash code in place. The hash code for the hidden_string is zero to ensure
ager@chromium.org3b45ab52009-03-19 22:21:34 +00002827 // that it will always be at the first entry in property descriptors.
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002828 { MaybeObject* maybe_obj = AllocateOneByteInternalizedString(
2829 OneByteVector("", 0), String::kEmptyStringHash);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002830 if (!maybe_obj->ToObject(&obj)) return false;
2831 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002832 hidden_string_ = String::cast(obj);
ager@chromium.org3b45ab52009-03-19 22:21:34 +00002833
ager@chromium.orgea91cc52011-05-23 06:06:11 +00002834 // Allocate the foreign for __proto__.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002835 { MaybeObject* maybe_obj =
ager@chromium.orgea91cc52011-05-23 06:06:11 +00002836 AllocateForeign((Address) &Accessors::ObjectPrototype);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002837 if (!maybe_obj->ToObject(&obj)) return false;
2838 }
ager@chromium.orgea91cc52011-05-23 06:06:11 +00002839 set_prototype_accessors(Foreign::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002840
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002841 // Allocate the code_stubs dictionary. The initial size is set to avoid
2842 // expanding the dictionary during bootstrapping.
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002843 { MaybeObject* maybe_obj = UnseededNumberDictionary::Allocate(128);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002844 if (!maybe_obj->ToObject(&obj)) return false;
2845 }
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002846 set_code_stubs(UnseededNumberDictionary::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002847
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00002848
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002849 // Allocate the non_monomorphic_cache used in stub-cache.cc. The initial size
2850 // is set to avoid expanding the dictionary during bootstrapping.
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002851 { MaybeObject* maybe_obj = UnseededNumberDictionary::Allocate(64);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002852 if (!maybe_obj->ToObject(&obj)) return false;
2853 }
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00002854 set_non_monomorphic_cache(UnseededNumberDictionary::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002855
jkummerow@chromium.orge297f592011-06-08 10:05:15 +00002856 { MaybeObject* maybe_obj = AllocatePolymorphicCodeCache();
2857 if (!maybe_obj->ToObject(&obj)) return false;
2858 }
2859 set_polymorphic_code_cache(PolymorphicCodeCache::cast(obj));
2860
sgjesse@chromium.org720dc0b2010-05-10 09:25:39 +00002861 set_instanceof_cache_function(Smi::FromInt(0));
2862 set_instanceof_cache_map(Smi::FromInt(0));
2863 set_instanceof_cache_answer(Smi::FromInt(0));
2864
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002865 CreateFixedStubs();
2866
erik.corry@gmail.comd88afa22010-09-15 12:33:05 +00002867 // Allocate the dictionary of intrinsic function names.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002868 { MaybeObject* maybe_obj = StringDictionary::Allocate(Runtime::kNumFunctions);
2869 if (!maybe_obj->ToObject(&obj)) return false;
2870 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002871 { MaybeObject* maybe_obj = Runtime::InitializeIntrinsicFunctionNames(this,
2872 obj);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002873 if (!maybe_obj->ToObject(&obj)) return false;
2874 }
erik.corry@gmail.comd88afa22010-09-15 12:33:05 +00002875 set_intrinsic_function_names(StringDictionary::cast(obj));
2876
danno@chromium.orgfa458e42012-02-01 10:48:36 +00002877 { MaybeObject* maybe_obj = AllocateInitialNumberStringCache();
2878 if (!maybe_obj->ToObject(&obj)) return false;
2879 }
2880 set_number_string_cache(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002881
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00002882 // Allocate cache for single character one byte strings.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002883 { MaybeObject* maybe_obj =
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00002884 AllocateFixedArray(String::kMaxOneByteCharCode + 1, TENURED);
lrn@chromium.org303ada72010-10-27 09:33:13 +00002885 if (!maybe_obj->ToObject(&obj)) return false;
2886 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002887 set_single_character_string_cache(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002888
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00002889 // Allocate cache for string split.
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002890 { MaybeObject* maybe_obj = AllocateFixedArray(
2891 RegExpResultsCache::kRegExpResultsCacheSize, TENURED);
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00002892 if (!maybe_obj->ToObject(&obj)) return false;
2893 }
2894 set_string_split_cache(FixedArray::cast(obj));
2895
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002896 { MaybeObject* maybe_obj = AllocateFixedArray(
2897 RegExpResultsCache::kRegExpResultsCacheSize, TENURED);
2898 if (!maybe_obj->ToObject(&obj)) return false;
2899 }
2900 set_regexp_multiple_cache(FixedArray::cast(obj));
2901
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002902 // Allocate cache for external strings pointing to native source code.
lrn@chromium.org303ada72010-10-27 09:33:13 +00002903 { MaybeObject* maybe_obj = AllocateFixedArray(Natives::GetBuiltinsCount());
2904 if (!maybe_obj->ToObject(&obj)) return false;
2905 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002906 set_natives_source_cache(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002907
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00002908 // Allocate object to hold object observation state.
2909 { MaybeObject* maybe_obj = AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
2910 if (!maybe_obj->ToObject(&obj)) return false;
2911 }
2912 { MaybeObject* maybe_obj = AllocateJSObjectFromMap(Map::cast(obj));
2913 if (!maybe_obj->ToObject(&obj)) return false;
2914 }
2915 set_observation_state(JSObject::cast(obj));
2916
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002917 // Handling of script id generation is in FACTORY->NewScript.
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002918 set_last_script_id(undefined_value());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00002919
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002920 // Initialize keyed lookup cache.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002921 isolate_->keyed_lookup_cache()->Clear();
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002922
2923 // Initialize context slot cache.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002924 isolate_->context_slot_cache()->Clear();
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002925
2926 // Initialize descriptor cache.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002927 isolate_->descriptor_lookup_cache()->Clear();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002928
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00002929 // Initialize compilation cache.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00002930 isolate_->compilation_cache()->Clear();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002931
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002932 return true;
2933}
2934
2935
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00002936bool Heap::RootCanBeWrittenAfterInitialization(Heap::RootListIndex root_index) {
2937 RootListIndex writable_roots[] = {
2938 kStoreBufferTopRootIndex,
2939 kStackLimitRootIndex,
ulan@chromium.org4121f232012-12-27 15:57:11 +00002940 kNumberStringCacheRootIndex,
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00002941 kInstanceofCacheFunctionRootIndex,
2942 kInstanceofCacheMapRootIndex,
2943 kInstanceofCacheAnswerRootIndex,
2944 kCodeStubsRootIndex,
2945 kNonMonomorphicCacheRootIndex,
2946 kPolymorphicCodeCacheRootIndex,
2947 kLastScriptIdRootIndex,
2948 kEmptyScriptRootIndex,
2949 kRealStackLimitRootIndex,
2950 kArgumentsAdaptorDeoptPCOffsetRootIndex,
2951 kConstructStubDeoptPCOffsetRootIndex,
2952 kGetterStubDeoptPCOffsetRootIndex,
2953 kSetterStubDeoptPCOffsetRootIndex,
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002954 kStringTableRootIndex,
mvstanton@chromium.orge4ac3ef2012-11-12 14:53:34 +00002955 };
2956
2957 for (unsigned int i = 0; i < ARRAY_SIZE(writable_roots); i++) {
2958 if (root_index == writable_roots[i])
2959 return true;
2960 }
2961 return false;
2962}
2963
2964
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002965Object* RegExpResultsCache::Lookup(Heap* heap,
2966 String* key_string,
2967 Object* key_pattern,
2968 ResultsCacheType type) {
2969 FixedArray* cache;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002970 if (!key_string->IsInternalizedString()) return Smi::FromInt(0);
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002971 if (type == STRING_SPLIT_SUBSTRINGS) {
2972 ASSERT(key_pattern->IsString());
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00002973 if (!key_pattern->IsInternalizedString()) return Smi::FromInt(0);
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002974 cache = heap->string_split_cache();
2975 } else {
2976 ASSERT(type == REGEXP_MULTIPLE_INDICES);
2977 ASSERT(key_pattern->IsFixedArray());
2978 cache = heap->regexp_multiple_cache();
2979 }
2980
2981 uint32_t hash = key_string->Hash();
2982 uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00002983 ~(kArrayEntriesPerCacheEntry - 1));
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002984 if (cache->get(index + kStringOffset) == key_string &&
2985 cache->get(index + kPatternOffset) == key_pattern) {
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00002986 return cache->get(index + kArrayOffset);
2987 }
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002988 index =
2989 ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
2990 if (cache->get(index + kStringOffset) == key_string &&
2991 cache->get(index + kPatternOffset) == key_pattern) {
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00002992 return cache->get(index + kArrayOffset);
2993 }
2994 return Smi::FromInt(0);
2995}
2996
2997
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00002998void RegExpResultsCache::Enter(Heap* heap,
2999 String* key_string,
3000 Object* key_pattern,
3001 FixedArray* value_array,
3002 ResultsCacheType type) {
3003 FixedArray* cache;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003004 if (!key_string->IsInternalizedString()) return;
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003005 if (type == STRING_SPLIT_SUBSTRINGS) {
3006 ASSERT(key_pattern->IsString());
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003007 if (!key_pattern->IsInternalizedString()) return;
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003008 cache = heap->string_split_cache();
3009 } else {
3010 ASSERT(type == REGEXP_MULTIPLE_INDICES);
3011 ASSERT(key_pattern->IsFixedArray());
3012 cache = heap->regexp_multiple_cache();
3013 }
3014
3015 uint32_t hash = key_string->Hash();
3016 uint32_t index = ((hash & (kRegExpResultsCacheSize - 1)) &
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00003017 ~(kArrayEntriesPerCacheEntry - 1));
3018 if (cache->get(index + kStringOffset) == Smi::FromInt(0)) {
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003019 cache->set(index + kStringOffset, key_string);
3020 cache->set(index + kPatternOffset, key_pattern);
3021 cache->set(index + kArrayOffset, value_array);
ricow@chromium.org55ee8072011-09-08 16:33:10 +00003022 } else {
3023 uint32_t index2 =
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003024 ((index + kArrayEntriesPerCacheEntry) & (kRegExpResultsCacheSize - 1));
ricow@chromium.org55ee8072011-09-08 16:33:10 +00003025 if (cache->get(index2 + kStringOffset) == Smi::FromInt(0)) {
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003026 cache->set(index2 + kStringOffset, key_string);
3027 cache->set(index2 + kPatternOffset, key_pattern);
3028 cache->set(index2 + kArrayOffset, value_array);
ricow@chromium.org55ee8072011-09-08 16:33:10 +00003029 } else {
3030 cache->set(index2 + kStringOffset, Smi::FromInt(0));
3031 cache->set(index2 + kPatternOffset, Smi::FromInt(0));
3032 cache->set(index2 + kArrayOffset, Smi::FromInt(0));
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003033 cache->set(index + kStringOffset, key_string);
3034 cache->set(index + kPatternOffset, key_pattern);
3035 cache->set(index + kArrayOffset, value_array);
ricow@chromium.org55ee8072011-09-08 16:33:10 +00003036 }
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00003037 }
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003038 // If the array is a reasonably short list of substrings, convert it into a
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003039 // list of internalized strings.
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003040 if (type == STRING_SPLIT_SUBSTRINGS && value_array->length() < 100) {
3041 for (int i = 0; i < value_array->length(); i++) {
3042 String* str = String::cast(value_array->get(i));
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003043 Object* internalized_str;
3044 MaybeObject* maybe_string = heap->InternalizeString(str);
3045 if (maybe_string->ToObject(&internalized_str)) {
3046 value_array->set(i, internalized_str);
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00003047 }
3048 }
3049 }
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003050 // Convert backing store to a copy-on-write array.
3051 value_array->set_map_no_write_barrier(heap->fixed_cow_array_map());
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00003052}
3053
3054
jkummerow@chromium.org78502a92012-09-06 13:50:42 +00003055void RegExpResultsCache::Clear(FixedArray* cache) {
3056 for (int i = 0; i < kRegExpResultsCacheSize; i++) {
jkummerow@chromium.org486075a2011-09-07 12:44:28 +00003057 cache->set(i, Smi::FromInt(0));
3058 }
3059}
3060
3061
danno@chromium.orgfa458e42012-02-01 10:48:36 +00003062MaybeObject* Heap::AllocateInitialNumberStringCache() {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003063 MaybeObject* maybe_obj =
danno@chromium.orgfa458e42012-02-01 10:48:36 +00003064 AllocateFixedArray(kInitialNumberStringCacheSize * 2, TENURED);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003065 return maybe_obj;
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003066}
3067
3068
danno@chromium.orgfa458e42012-02-01 10:48:36 +00003069int Heap::FullSizeNumberStringCacheLength() {
3070 // Compute the size of the number string cache based on the max newspace size.
3071 // The number string cache has a minimum size based on twice the initial cache
3072 // size to ensure that it is bigger after being made 'full size'.
3073 int number_string_cache_size = max_semispace_size_ / 512;
3074 number_string_cache_size = Max(kInitialNumberStringCacheSize * 2,
3075 Min(0x4000, number_string_cache_size));
3076 // There is a string and a number per entry so the length is twice the number
3077 // of entries.
3078 return number_string_cache_size * 2;
3079}
3080
3081
3082void Heap::AllocateFullSizeNumberStringCache() {
3083 // The idea is to have a small number string cache in the snapshot to keep
3084 // boot-time memory usage down. If we expand the number string cache already
3085 // while creating the snapshot then that didn't work out.
yangguo@chromium.org5a11aaf2012-06-20 11:29:00 +00003086 ASSERT(!Serializer::enabled() || FLAG_extra_code != NULL);
danno@chromium.orgfa458e42012-02-01 10:48:36 +00003087 MaybeObject* maybe_obj =
3088 AllocateFixedArray(FullSizeNumberStringCacheLength(), TENURED);
3089 Object* new_cache;
3090 if (maybe_obj->ToObject(&new_cache)) {
3091 // We don't bother to repopulate the cache with entries from the old cache.
3092 // It will be repopulated soon enough with new strings.
3093 set_number_string_cache(FixedArray::cast(new_cache));
3094 }
3095 // If allocation fails then we just return without doing anything. It is only
3096 // a cache, so best effort is OK here.
3097}
3098
3099
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003100void Heap::FlushNumberStringCache() {
3101 // Flush the number to string cache.
3102 int len = number_string_cache()->length();
3103 for (int i = 0; i < len; i++) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003104 number_string_cache()->set_undefined(this, i);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003105 }
3106}
3107
3108
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003109static inline int double_get_hash(double d) {
3110 DoubleRepresentation rep(d);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003111 return static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003112}
3113
3114
3115static inline int smi_get_hash(Smi* smi) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003116 return smi->value();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003117}
3118
3119
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003120Object* Heap::GetNumberStringCache(Object* number) {
3121 int hash;
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003122 int mask = (number_string_cache()->length() >> 1) - 1;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003123 if (number->IsSmi()) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003124 hash = smi_get_hash(Smi::cast(number)) & mask;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003125 } else {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003126 hash = double_get_hash(number->Number()) & mask;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003127 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003128 Object* key = number_string_cache()->get(hash * 2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003129 if (key == number) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003130 return String::cast(number_string_cache()->get(hash * 2 + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003131 } else if (key->IsHeapNumber() &&
3132 number->IsHeapNumber() &&
3133 key->Number() == number->Number()) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003134 return String::cast(number_string_cache()->get(hash * 2 + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003135 }
3136 return undefined_value();
3137}
3138
3139
3140void Heap::SetNumberStringCache(Object* number, String* string) {
3141 int hash;
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003142 int mask = (number_string_cache()->length() >> 1) - 1;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003143 if (number->IsSmi()) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003144 hash = smi_get_hash(Smi::cast(number)) & mask;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003145 } else {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003146 hash = double_get_hash(number->Number()) & mask;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003147 }
danno@chromium.orgfa458e42012-02-01 10:48:36 +00003148 if (number_string_cache()->get(hash * 2) != undefined_value() &&
3149 number_string_cache()->length() != FullSizeNumberStringCacheLength()) {
3150 // The first time we have a hash collision, we move to the full sized
3151 // number string cache.
3152 AllocateFullSizeNumberStringCache();
3153 return;
3154 }
3155 number_string_cache()->set(hash * 2, number);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003156 number_string_cache()->set(hash * 2 + 1, string);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003157}
3158
3159
lrn@chromium.org303ada72010-10-27 09:33:13 +00003160MaybeObject* Heap::NumberToString(Object* number,
3161 bool check_number_string_cache) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003162 isolate_->counters()->number_to_string_runtime()->Increment();
ager@chromium.org357bf652010-04-12 11:30:10 +00003163 if (check_number_string_cache) {
3164 Object* cached = GetNumberStringCache(number);
3165 if (cached != undefined_value()) {
3166 return cached;
3167 }
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00003168 }
3169
3170 char arr[100];
3171 Vector<char> buffer(arr, ARRAY_SIZE(arr));
3172 const char* str;
3173 if (number->IsSmi()) {
3174 int num = Smi::cast(number)->value();
3175 str = IntToCString(num, buffer);
3176 } else {
3177 double num = HeapNumber::cast(number)->value();
3178 str = DoubleToCString(num, buffer);
3179 }
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00003180
lrn@chromium.org303ada72010-10-27 09:33:13 +00003181 Object* js_string;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003182 MaybeObject* maybe_js_string = AllocateStringFromOneByte(CStrVector(str));
lrn@chromium.org303ada72010-10-27 09:33:13 +00003183 if (maybe_js_string->ToObject(&js_string)) {
3184 SetNumberStringCache(number, String::cast(js_string));
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00003185 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00003186 return maybe_js_string;
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00003187}
3188
3189
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003190MaybeObject* Heap::Uint32ToString(uint32_t value,
3191 bool check_number_string_cache) {
3192 Object* number;
3193 MaybeObject* maybe = NumberFromUint32(value);
3194 if (!maybe->To<Object>(&number)) return maybe;
3195 return NumberToString(number, check_number_string_cache);
3196}
3197
3198
ager@chromium.org3811b432009-10-28 14:53:37 +00003199Map* Heap::MapForExternalArrayType(ExternalArrayType array_type) {
3200 return Map::cast(roots_[RootIndexForExternalArrayType(array_type)]);
3201}
3202
3203
3204Heap::RootListIndex Heap::RootIndexForExternalArrayType(
3205 ExternalArrayType array_type) {
3206 switch (array_type) {
3207 case kExternalByteArray:
3208 return kExternalByteArrayMapRootIndex;
3209 case kExternalUnsignedByteArray:
3210 return kExternalUnsignedByteArrayMapRootIndex;
3211 case kExternalShortArray:
3212 return kExternalShortArrayMapRootIndex;
3213 case kExternalUnsignedShortArray:
3214 return kExternalUnsignedShortArrayMapRootIndex;
3215 case kExternalIntArray:
3216 return kExternalIntArrayMapRootIndex;
3217 case kExternalUnsignedIntArray:
3218 return kExternalUnsignedIntArrayMapRootIndex;
3219 case kExternalFloatArray:
3220 return kExternalFloatArrayMapRootIndex;
erik.corry@gmail.com3847bd52011-04-27 10:38:56 +00003221 case kExternalDoubleArray:
3222 return kExternalDoubleArrayMapRootIndex;
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00003223 case kExternalPixelArray:
3224 return kExternalPixelArrayMapRootIndex;
ager@chromium.org3811b432009-10-28 14:53:37 +00003225 default:
3226 UNREACHABLE();
3227 return kUndefinedValueRootIndex;
3228 }
3229}
3230
3231
lrn@chromium.org303ada72010-10-27 09:33:13 +00003232MaybeObject* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {
kmillikin@chromium.org4111b802010-05-03 10:34:42 +00003233 // We need to distinguish the minus zero value and this cannot be
3234 // done after conversion to int. Doing this by comparing bit
3235 // patterns is faster than using fpclassify() et al.
3236 static const DoubleRepresentation minus_zero(-0.0);
3237
3238 DoubleRepresentation rep(value);
3239 if (rep.bits == minus_zero.bits) {
3240 return AllocateHeapNumber(-0.0, pretenure);
3241 }
3242
3243 int int_value = FastD2I(value);
3244 if (value == int_value && Smi::IsValid(int_value)) {
3245 return Smi::FromInt(int_value);
3246 }
3247
3248 // Materialize the value in the heap.
3249 return AllocateHeapNumber(value, pretenure);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003250}
3251
3252
ager@chromium.orgea91cc52011-05-23 06:06:11 +00003253MaybeObject* Heap::AllocateForeign(Address address, PretenureFlag pretenure) {
3254 // Statically ensure that it is safe to allocate foreigns in paged spaces.
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00003255 STATIC_ASSERT(Foreign::kSize <= Page::kMaxNonCodeHeapObjectSize);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00003256 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00003257 Foreign* result;
3258 MaybeObject* maybe_result = Allocate(foreign_map(), space);
3259 if (!maybe_result->To(&result)) return maybe_result;
3260 result->set_foreign_address(address);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003261 return result;
3262}
3263
3264
lrn@chromium.org303ada72010-10-27 09:33:13 +00003265MaybeObject* Heap::AllocateSharedFunctionInfo(Object* name) {
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00003266 SharedFunctionInfo* share;
3267 MaybeObject* maybe = Allocate(shared_function_info_map(), OLD_POINTER_SPACE);
3268 if (!maybe->To<SharedFunctionInfo>(&share)) return maybe;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003269
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00003270 // Set pointer fields.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003271 share->set_name(name);
fschneider@chromium.org7979bbb2011-03-28 10:47:03 +00003272 Code* illegal = isolate_->builtins()->builtin(Builtins::kIllegal);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003273 share->set_code(illegal);
yangguo@chromium.org5a11aaf2012-06-20 11:29:00 +00003274 share->ClearOptimizedCodeMap();
hpayer@chromium.org8432c912013-02-28 15:55:26 +00003275 share->set_scope_info(ScopeInfo::Empty(isolate_));
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00003276 Code* construct_stub =
3277 isolate_->builtins()->builtin(Builtins::kJSConstructStubGeneric);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00003278 share->set_construct_stub(construct_stub);
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003279 share->set_instance_class_name(Object_string());
ricow@chromium.org27bf2882011-11-17 08:34:43 +00003280 share->set_function_data(undefined_value(), SKIP_WRITE_BARRIER);
3281 share->set_script(undefined_value(), SKIP_WRITE_BARRIER);
3282 share->set_debug_info(undefined_value(), SKIP_WRITE_BARRIER);
3283 share->set_inferred_name(empty_string(), SKIP_WRITE_BARRIER);
3284 share->set_initial_map(undefined_value(), SKIP_WRITE_BARRIER);
3285 share->set_this_property_assignments(undefined_value(), SKIP_WRITE_BARRIER);
svenpanne@chromium.orgb1df11d2012-02-08 10:26:21 +00003286 share->set_ast_node_count(0);
mmassi@chromium.org7028c052012-06-13 11:51:58 +00003287 share->set_stress_deopt_counter(FLAG_deopt_every_n_times);
3288 share->set_counters(0);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00003289
3290 // Set integer fields (smi or int, depending on the architecture).
3291 share->set_length(0);
3292 share->set_formal_parameter_count(0);
3293 share->set_expected_nof_properties(0);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003294 share->set_num_literals(0);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00003295 share->set_start_position_and_type(0);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003296 share->set_end_position(0);
3297 share->set_function_token_position(0);
kmillikin@chromium.org7c2628c2011-08-10 11:27:35 +00003298 // All compiler hints default to false or 0.
3299 share->set_compiler_hints(0);
3300 share->set_this_property_assignments_count(0);
3301 share->set_opt_count(0);
3302
3303 return share;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003304}
3305
3306
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00003307MaybeObject* Heap::AllocateJSMessageObject(String* type,
3308 JSArray* arguments,
3309 int start_position,
3310 int end_position,
3311 Object* script,
3312 Object* stack_trace,
3313 Object* stack_frames) {
3314 Object* result;
3315 { MaybeObject* maybe_result = Allocate(message_object_map(), NEW_SPACE);
3316 if (!maybe_result->ToObject(&result)) return maybe_result;
3317 }
3318 JSMessageObject* message = JSMessageObject::cast(result);
ricow@chromium.org27bf2882011-11-17 08:34:43 +00003319 message->set_properties(Heap::empty_fixed_array(), SKIP_WRITE_BARRIER);
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00003320 message->initialize_elements();
ricow@chromium.org27bf2882011-11-17 08:34:43 +00003321 message->set_elements(Heap::empty_fixed_array(), SKIP_WRITE_BARRIER);
kmillikin@chromium.org31b12772011-02-02 16:08:26 +00003322 message->set_type(type);
3323 message->set_arguments(arguments);
3324 message->set_start_position(start_position);
3325 message->set_end_position(end_position);
3326 message->set_script(script);
3327 message->set_stack_trace(stack_trace);
3328 message->set_stack_frames(stack_frames);
3329 return result;
3330}
3331
3332
3333
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003334// Returns true for a character in a range. Both limits are inclusive.
3335static inline bool Between(uint32_t character, uint32_t from, uint32_t to) {
3336 // This makes uses of the the unsigned wraparound.
3337 return character - from <= to - from;
3338}
3339
3340
lrn@chromium.org303ada72010-10-27 09:33:13 +00003341MUST_USE_RESULT static inline MaybeObject* MakeOrFindTwoCharacterString(
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003342 Heap* heap,
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00003343 uint16_t c1,
3344 uint16_t c2) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003345 String* result;
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003346 // Numeric strings have a different hash algorithm not known by
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003347 // LookupTwoCharsStringIfExists, so we skip this step for such strings.
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003348 if ((!Between(c1, '0', '9') || !Between(c2, '0', '9')) &&
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003349 heap->string_table()->LookupTwoCharsStringIfExists(c1, c2, &result)) {
3350 return result;
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003351 // Now we know the length is 2, we might as well make use of that fact
3352 // when building the new string.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003353 } else if (static_cast<unsigned>(c1 | c2) <= String::kMaxOneByteCharCodeU) {
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00003354 // We can do this.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003355 ASSERT(IsPowerOf2(String::kMaxOneByteCharCodeU + 1)); // because of this.
lrn@chromium.org303ada72010-10-27 09:33:13 +00003356 Object* result;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003357 { MaybeObject* maybe_result = heap->AllocateRawOneByteString(2);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003358 if (!maybe_result->ToObject(&result)) return maybe_result;
3359 }
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003360 uint8_t* dest = SeqOneByteString::cast(result)->GetChars();
3361 dest[0] = static_cast<uint8_t>(c1);
3362 dest[1] = static_cast<uint8_t>(c2);
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003363 return result;
3364 } else {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003365 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003366 { MaybeObject* maybe_result = heap->AllocateRawTwoByteString(2);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003367 if (!maybe_result->ToObject(&result)) return maybe_result;
3368 }
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003369 uc16* dest = SeqTwoByteString::cast(result)->GetChars();
3370 dest[0] = c1;
3371 dest[1] = c2;
3372 return result;
3373 }
3374}
3375
3376
lrn@chromium.org303ada72010-10-27 09:33:13 +00003377MaybeObject* Heap::AllocateConsString(String* first, String* second) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003378 int first_length = first->length();
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003379 if (first_length == 0) {
3380 return second;
3381 }
ager@chromium.org3e875802009-06-29 08:26:34 +00003382
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003383 int second_length = second->length();
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003384 if (second_length == 0) {
3385 return first;
3386 }
ager@chromium.org3e875802009-06-29 08:26:34 +00003387
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003388 int length = first_length + second_length;
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003389
3390 // Optimization for 2-byte strings often used as keys in a decompression
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003391 // dictionary. Check whether we already have the string in the string
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003392 // table to prevent creation of many unneccesary strings.
3393 if (length == 2) {
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00003394 uint16_t c1 = first->Get(0);
3395 uint16_t c2 = second->Get(0);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003396 return MakeOrFindTwoCharacterString(this, c1, c2);
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003397 }
3398
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003399 bool first_is_one_byte = first->IsOneByteRepresentation();
3400 bool second_is_one_byte = second->IsOneByteRepresentation();
3401 bool is_one_byte = first_is_one_byte && second_is_one_byte;
ager@chromium.org3e875802009-06-29 08:26:34 +00003402 // Make sure that an out of memory exception is thrown if the length
christian.plesner.hansen@gmail.com9d58c2b2009-10-16 11:48:38 +00003403 // of the new cons string is too large.
3404 if (length > String::kMaxLength || length < 0) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003405 isolate()->context()->mark_out_of_memory();
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003406 return Failure::OutOfMemoryException(0x4);
ager@chromium.org3e875802009-06-29 08:26:34 +00003407 }
3408
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003409 bool is_ascii_data_in_two_byte_string = false;
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003410 if (!is_one_byte) {
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003411 // At least one of the strings uses two-byte representation so we
ulan@chromium.org2efb9002012-01-19 15:36:35 +00003412 // can't use the fast case code for short ASCII strings below, but
3413 // we can try to save memory if all chars actually fit in ASCII.
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003414 is_ascii_data_in_two_byte_string =
3415 first->HasOnlyAsciiChars() && second->HasOnlyAsciiChars();
3416 if (is_ascii_data_in_two_byte_string) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003417 isolate_->counters()->string_add_runtime_ext_to_ascii()->Increment();
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003418 }
3419 }
3420
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003421 // If the resulting string is small make a flat string.
ulan@chromium.org2efb9002012-01-19 15:36:35 +00003422 if (length < ConsString::kMinLength) {
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003423 // Note that neither of the two inputs can be a slice because:
ulan@chromium.org2efb9002012-01-19 15:36:35 +00003424 STATIC_ASSERT(ConsString::kMinLength <= SlicedString::kMinLength);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003425 ASSERT(first->IsFlat());
3426 ASSERT(second->IsFlat());
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003427 if (is_one_byte) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003428 Object* result;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003429 { MaybeObject* maybe_result = AllocateRawOneByteString(length);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003430 if (!maybe_result->ToObject(&result)) return maybe_result;
3431 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003432 // Copy the characters into the new object.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003433 uint8_t* dest = SeqOneByteString::cast(result)->GetChars();
ager@chromium.org3e875802009-06-29 08:26:34 +00003434 // Copy first part.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003435 const uint8_t* src;
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003436 if (first->IsExternalString()) {
erikcorry0ad885c2011-11-21 13:51:57 +00003437 src = ExternalAsciiString::cast(first)->GetChars();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003438 } else {
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00003439 src = SeqOneByteString::cast(first)->GetChars();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003440 }
ager@chromium.org3e875802009-06-29 08:26:34 +00003441 for (int i = 0; i < first_length; i++) *dest++ = src[i];
3442 // Copy second part.
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003443 if (second->IsExternalString()) {
erikcorry0ad885c2011-11-21 13:51:57 +00003444 src = ExternalAsciiString::cast(second)->GetChars();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003445 } else {
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00003446 src = SeqOneByteString::cast(second)->GetChars();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003447 }
ager@chromium.org3e875802009-06-29 08:26:34 +00003448 for (int i = 0; i < second_length; i++) *dest++ = src[i];
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003449 return result;
3450 } else {
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003451 if (is_ascii_data_in_two_byte_string) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003452 Object* result;
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003453 { MaybeObject* maybe_result = AllocateRawOneByteString(length);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003454 if (!maybe_result->ToObject(&result)) return maybe_result;
3455 }
ricow@chromium.orgaa1b6162010-03-29 07:44:58 +00003456 // Copy the characters into the new object.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003457 uint8_t* dest = SeqOneByteString::cast(result)->GetChars();
ricow@chromium.orgaa1b6162010-03-29 07:44:58 +00003458 String::WriteToFlat(first, dest, 0, first_length);
3459 String::WriteToFlat(second, dest + first_length, 0, second_length);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003460 isolate_->counters()->string_add_runtime_ext_to_ascii()->Increment();
ricow@chromium.orgaa1b6162010-03-29 07:44:58 +00003461 return result;
3462 }
3463
lrn@chromium.org303ada72010-10-27 09:33:13 +00003464 Object* result;
3465 { MaybeObject* maybe_result = AllocateRawTwoByteString(length);
3466 if (!maybe_result->ToObject(&result)) return maybe_result;
3467 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003468 // Copy the characters into the new object.
3469 uc16* dest = SeqTwoByteString::cast(result)->GetChars();
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003470 String::WriteToFlat(first, dest, 0, first_length);
3471 String::WriteToFlat(second, dest + first_length, 0, second_length);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003472 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003473 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003474 }
3475
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003476 Map* map = (is_one_byte || is_ascii_data_in_two_byte_string) ?
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003477 cons_ascii_string_map() : cons_string_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003478
lrn@chromium.org303ada72010-10-27 09:33:13 +00003479 Object* result;
3480 { MaybeObject* maybe_result = Allocate(map, NEW_SPACE);
3481 if (!maybe_result->ToObject(&result)) return maybe_result;
3482 }
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00003483
3484 AssertNoAllocation no_gc;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003485 ConsString* cons_string = ConsString::cast(result);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00003486 WriteBarrierMode mode = cons_string->GetWriteBarrierMode(no_gc);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003487 cons_string->set_length(length);
3488 cons_string->set_hash_field(String::kEmptyHashField);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003489 cons_string->set_first(first, mode);
3490 cons_string->set_second(second, mode);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003491 return result;
3492}
3493
3494
lrn@chromium.org303ada72010-10-27 09:33:13 +00003495MaybeObject* Heap::AllocateSubString(String* buffer,
ager@chromium.org04921a82011-06-27 13:21:41 +00003496 int start,
3497 int end,
3498 PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003499 int length = end - start;
ulan@chromium.org2efb9002012-01-19 15:36:35 +00003500 if (length <= 0) {
ager@chromium.org04921a82011-06-27 13:21:41 +00003501 return empty_string();
3502 } else if (length == 1) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003503 return LookupSingleCharacterStringFromCode(buffer->Get(start));
ager@chromium.org6141cbe2009-11-20 12:14:52 +00003504 } else if (length == 2) {
3505 // Optimization for 2-byte strings often used as keys in a decompression
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003506 // dictionary. Check whether we already have the string in the string
3507 // table to prevent creation of many unnecessary strings.
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00003508 uint16_t c1 = buffer->Get(start);
3509 uint16_t c2 = buffer->Get(start + 1);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003510 return MakeOrFindTwoCharacterString(this, c1, c2);
ager@chromium.org7c537e22008-10-16 08:43:32 +00003511 }
3512
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003513 // Make an attempt to flatten the buffer to reduce access time.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00003514 buffer = buffer->TryFlattenGetString();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003515
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003516 if (!FLAG_string_slices ||
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003517 !buffer->IsFlat() ||
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003518 length < SlicedString::kMinLength ||
3519 pretenure == TENURED) {
3520 Object* result;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003521 // WriteToFlat takes care of the case when an indirect string has a
3522 // different encoding from its underlying string. These encodings may
3523 // differ because of externalization.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003524 bool is_one_byte = buffer->IsOneByteRepresentation();
3525 { MaybeObject* maybe_result = is_one_byte
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003526 ? AllocateRawOneByteString(length, pretenure)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003527 : AllocateRawTwoByteString(length, pretenure);
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003528 if (!maybe_result->ToObject(&result)) return maybe_result;
3529 }
3530 String* string_result = String::cast(result);
3531 // Copy the characters into the new object.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003532 if (is_one_byte) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003533 ASSERT(string_result->IsOneByteRepresentation());
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003534 uint8_t* dest = SeqOneByteString::cast(string_result)->GetChars();
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003535 String::WriteToFlat(buffer, dest, start, end);
3536 } else {
3537 ASSERT(string_result->IsTwoByteRepresentation());
3538 uc16* dest = SeqTwoByteString::cast(string_result)->GetChars();
3539 String::WriteToFlat(buffer, dest, start, end);
3540 }
3541 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003542 }
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003543
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003544 ASSERT(buffer->IsFlat());
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00003545#if VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00003546 if (FLAG_verify_heap) {
3547 buffer->StringVerify();
3548 }
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003549#endif
3550
3551 Object* result;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003552 // When slicing an indirect string we use its encoding for a newly created
3553 // slice and don't check the encoding of the underlying string. This is safe
3554 // even if the encodings are different because of externalization. If an
3555 // indirect ASCII string is pointing to a two-byte string, the two-byte char
3556 // codes of the underlying string must still fit into ASCII (because
3557 // externalization must not change char codes).
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00003558 { Map* map = buffer->IsOneByteRepresentation()
ricow@chromium.org4668a2c2011-08-29 10:41:00 +00003559 ? sliced_ascii_string_map()
3560 : sliced_string_map();
3561 MaybeObject* maybe_result = Allocate(map, NEW_SPACE);
3562 if (!maybe_result->ToObject(&result)) return maybe_result;
3563 }
3564
3565 AssertNoAllocation no_gc;
3566 SlicedString* sliced_string = SlicedString::cast(result);
3567 sliced_string->set_length(length);
3568 sliced_string->set_hash_field(String::kEmptyHashField);
3569 if (buffer->IsConsString()) {
3570 ConsString* cons = ConsString::cast(buffer);
3571 ASSERT(cons->second()->length() == 0);
3572 sliced_string->set_parent(cons->first());
3573 sliced_string->set_offset(start);
3574 } else if (buffer->IsSlicedString()) {
3575 // Prevent nesting sliced strings.
3576 SlicedString* parent_slice = SlicedString::cast(buffer);
3577 sliced_string->set_parent(parent_slice->parent());
3578 sliced_string->set_offset(start + parent_slice->offset());
3579 } else {
3580 sliced_string->set_parent(buffer);
3581 sliced_string->set_offset(start);
3582 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003583 ASSERT(sliced_string->parent()->IsSeqString() ||
3584 sliced_string->parent()->IsExternalString());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003585 return result;
3586}
3587
3588
lrn@chromium.org303ada72010-10-27 09:33:13 +00003589MaybeObject* Heap::AllocateExternalStringFromAscii(
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003590 const ExternalAsciiString::Resource* resource) {
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003591 size_t length = resource->length();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003592 if (length > static_cast<size_t>(String::kMaxLength)) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003593 isolate()->context()->mark_out_of_memory();
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003594 return Failure::OutOfMemoryException(0x5);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003595 }
3596
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00003597#ifndef ENABLE_LATIN_1
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +00003598 ASSERT(String::IsAscii(resource->data(), static_cast<int>(length)));
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00003599#endif // ENABLE_LATIN_1
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +00003600
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003601 Map* map = external_ascii_string_map();
lrn@chromium.org303ada72010-10-27 09:33:13 +00003602 Object* result;
3603 { MaybeObject* maybe_result = Allocate(map, NEW_SPACE);
3604 if (!maybe_result->ToObject(&result)) return maybe_result;
3605 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003606
3607 ExternalAsciiString* external_string = ExternalAsciiString::cast(result);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003608 external_string->set_length(static_cast<int>(length));
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003609 external_string->set_hash_field(String::kEmptyHashField);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003610 external_string->set_resource(resource);
3611
3612 return result;
3613}
3614
3615
lrn@chromium.org303ada72010-10-27 09:33:13 +00003616MaybeObject* Heap::AllocateExternalStringFromTwoByte(
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003617 const ExternalTwoByteString::Resource* resource) {
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003618 size_t length = resource->length();
3619 if (length > static_cast<size_t>(String::kMaxLength)) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003620 isolate()->context()->mark_out_of_memory();
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003621 return Failure::OutOfMemoryException(0x6);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003622 }
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003623
ricow@chromium.org5ad5ace2010-06-23 09:06:43 +00003624 // For small strings we check whether the resource contains only
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003625 // one byte characters. If yes, we use a different string map.
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00003626 static const size_t kAsciiCheckLengthLimit = 32;
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003627 bool is_one_byte = length <= kAsciiCheckLengthLimit &&
3628 String::IsOneByte(resource->data(), static_cast<int>(length));
3629 Map* map = is_one_byte ?
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003630 external_string_with_ascii_data_map() : external_string_map();
lrn@chromium.org303ada72010-10-27 09:33:13 +00003631 Object* result;
3632 { MaybeObject* maybe_result = Allocate(map, NEW_SPACE);
3633 if (!maybe_result->ToObject(&result)) return maybe_result;
3634 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003635
3636 ExternalTwoByteString* external_string = ExternalTwoByteString::cast(result);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00003637 external_string->set_length(static_cast<int>(length));
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00003638 external_string->set_hash_field(String::kEmptyHashField);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003639 external_string->set_resource(resource);
3640
3641 return result;
3642}
3643
3644
lrn@chromium.org303ada72010-10-27 09:33:13 +00003645MaybeObject* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003646 if (code <= String::kMaxOneByteCharCode) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003647 Object* value = single_character_string_cache()->get(code);
3648 if (value != undefined_value()) return value;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003649
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003650 uint8_t buffer[1];
3651 buffer[0] = static_cast<uint8_t>(code);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003652 Object* result;
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00003653 MaybeObject* maybe_result =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003654 InternalizeOneByteString(Vector<const uint8_t>(buffer, 1));
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003655
lrn@chromium.org303ada72010-10-27 09:33:13 +00003656 if (!maybe_result->ToObject(&result)) return maybe_result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003657 single_character_string_cache()->set(code, result);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003658 return result;
3659 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003660
lrn@chromium.org303ada72010-10-27 09:33:13 +00003661 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003662 { MaybeObject* maybe_result = AllocateRawTwoByteString(1);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003663 if (!maybe_result->ToObject(&result)) return maybe_result;
3664 }
ager@chromium.org870a0b62008-11-04 11:43:05 +00003665 String* answer = String::cast(result);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00003666 answer->Set(0, code);
ager@chromium.org870a0b62008-11-04 11:43:05 +00003667 return answer;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003668}
3669
3670
lrn@chromium.org303ada72010-10-27 09:33:13 +00003671MaybeObject* Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003672 if (length < 0 || length > ByteArray::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003673 return Failure::OutOfMemoryException(0x7);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003674 }
ager@chromium.orga74f0da2008-12-03 16:05:52 +00003675 if (pretenure == NOT_TENURED) {
3676 return AllocateByteArray(length);
3677 }
3678 int size = ByteArray::SizeFor(length);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003679 Object* result;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00003680 { MaybeObject* maybe_result = (size <= Page::kMaxNonCodeHeapObjectSize)
lrn@chromium.org303ada72010-10-27 09:33:13 +00003681 ? old_data_space_->AllocateRaw(size)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003682 : lo_space_->AllocateRaw(size, NOT_EXECUTABLE);
lrn@chromium.org303ada72010-10-27 09:33:13 +00003683 if (!maybe_result->ToObject(&result)) return maybe_result;
3684 }
ager@chromium.orga74f0da2008-12-03 16:05:52 +00003685
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003686 reinterpret_cast<ByteArray*>(result)->set_map_no_write_barrier(
3687 byte_array_map());
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003688 reinterpret_cast<ByteArray*>(result)->set_length(length);
ager@chromium.orga74f0da2008-12-03 16:05:52 +00003689 return result;
3690}
3691
3692
lrn@chromium.org303ada72010-10-27 09:33:13 +00003693MaybeObject* Heap::AllocateByteArray(int length) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003694 if (length < 0 || length > ByteArray::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00003695 return Failure::OutOfMemoryException(0x8);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003696 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003697 int size = ByteArray::SizeFor(length);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003698 AllocationSpace space =
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00003699 (size > Page::kMaxNonCodeHeapObjectSize) ? LO_SPACE : NEW_SPACE;
lrn@chromium.org303ada72010-10-27 09:33:13 +00003700 Object* result;
3701 { MaybeObject* maybe_result = AllocateRaw(size, space, OLD_DATA_SPACE);
3702 if (!maybe_result->ToObject(&result)) return maybe_result;
3703 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003704
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003705 reinterpret_cast<ByteArray*>(result)->set_map_no_write_barrier(
3706 byte_array_map());
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003707 reinterpret_cast<ByteArray*>(result)->set_length(length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003708 return result;
3709}
3710
3711
ager@chromium.org6f10e412009-02-13 10:11:16 +00003712void Heap::CreateFillerObjectAt(Address addr, int size) {
3713 if (size == 0) return;
3714 HeapObject* filler = HeapObject::FromAddress(addr);
3715 if (size == kPointerSize) {
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003716 filler->set_map_no_write_barrier(one_pointer_filler_map());
fschneider@chromium.org013f3e12010-04-26 13:27:52 +00003717 } else if (size == 2 * kPointerSize) {
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003718 filler->set_map_no_write_barrier(two_pointer_filler_map());
ager@chromium.org6f10e412009-02-13 10:11:16 +00003719 } else {
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003720 filler->set_map_no_write_barrier(free_space_map());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003721 FreeSpace::cast(filler)->set_size(size);
ager@chromium.org6f10e412009-02-13 10:11:16 +00003722 }
3723}
3724
3725
lrn@chromium.org303ada72010-10-27 09:33:13 +00003726MaybeObject* Heap::AllocateExternalArray(int length,
3727 ExternalArrayType array_type,
3728 void* external_pointer,
3729 PretenureFlag pretenure) {
ager@chromium.org3811b432009-10-28 14:53:37 +00003730 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
lrn@chromium.org303ada72010-10-27 09:33:13 +00003731 Object* result;
3732 { MaybeObject* maybe_result = AllocateRaw(ExternalArray::kAlignedSize,
3733 space,
3734 OLD_DATA_SPACE);
3735 if (!maybe_result->ToObject(&result)) return maybe_result;
3736 }
ager@chromium.org3811b432009-10-28 14:53:37 +00003737
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003738 reinterpret_cast<ExternalArray*>(result)->set_map_no_write_barrier(
ager@chromium.org3811b432009-10-28 14:53:37 +00003739 MapForExternalArrayType(array_type));
3740 reinterpret_cast<ExternalArray*>(result)->set_length(length);
3741 reinterpret_cast<ExternalArray*>(result)->set_external_pointer(
3742 external_pointer);
3743
3744 return result;
3745}
3746
3747
lrn@chromium.org303ada72010-10-27 09:33:13 +00003748MaybeObject* Heap::CreateCode(const CodeDesc& desc,
3749 Code::Flags flags,
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00003750 Handle<Object> self_reference,
3751 bool immovable) {
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003752 // Allocate ByteArray before the Code object, so that we do not risk
3753 // leaving uninitialized Code object (and breaking the heap).
jkummerow@chromium.org04e4f1e2011-11-14 13:36:17 +00003754 ByteArray* reloc_info;
3755 MaybeObject* maybe_reloc_info = AllocateByteArray(desc.reloc_size, TENURED);
3756 if (!maybe_reloc_info->To(&reloc_info)) return maybe_reloc_info;
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003757
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00003758 // Compute size.
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003759 int body_size = RoundUp(desc.instr_size, kObjectAlignment);
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00003760 int obj_size = Code::SizeFor(body_size);
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00003761 ASSERT(IsAligned(static_cast<intptr_t>(obj_size), kCodeAlignment));
lrn@chromium.org303ada72010-10-27 09:33:13 +00003762 MaybeObject* maybe_result;
danno@chromium.org4d3fe4e2011-03-10 10:14:28 +00003763 // Large code objects and code objects which should stay at a fixed address
3764 // are allocated in large object space.
ulan@chromium.org56c14af2012-09-20 12:51:09 +00003765 HeapObject* result;
3766 bool force_lo_space = obj_size > code_space()->AreaSize();
3767 if (force_lo_space) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003768 maybe_result = lo_space_->AllocateRaw(obj_size, EXECUTABLE);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003769 } else {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003770 maybe_result = code_space_->AllocateRaw(obj_size);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003771 }
ulan@chromium.org56c14af2012-09-20 12:51:09 +00003772 if (!maybe_result->To<HeapObject>(&result)) return maybe_result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003773
ulan@chromium.org56c14af2012-09-20 12:51:09 +00003774 if (immovable && !force_lo_space &&
3775 // Objects on the first page of each space are never moved.
3776 !code_space_->FirstPage()->Contains(result->address())) {
3777 // Discard the first code allocation, which was on a page where it could be
3778 // moved.
3779 CreateFillerObjectAt(result->address(), obj_size);
3780 maybe_result = lo_space_->AllocateRaw(obj_size, EXECUTABLE);
3781 if (!maybe_result->To<HeapObject>(&result)) return maybe_result;
3782 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003783
3784 // Initialize the object
ulan@chromium.org56c14af2012-09-20 12:51:09 +00003785 result->set_map_no_write_barrier(code_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003786 Code* code = Code::cast(result);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003787 ASSERT(!isolate_->code_range()->exists() ||
3788 isolate_->code_range()->contains(code->address()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003789 code->set_instruction_size(desc.instr_size);
jkummerow@chromium.org04e4f1e2011-11-14 13:36:17 +00003790 code->set_relocation_info(reloc_info);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003791 code->set_flags(flags);
sgjesse@chromium.orgc6c57182011-01-17 12:24:25 +00003792 if (code->is_call_stub() || code->is_keyed_call_stub()) {
3793 code->set_check_type(RECEIVER_MAP_CHECK);
3794 }
ricow@chromium.org27bf2882011-11-17 08:34:43 +00003795 code->set_deoptimization_data(empty_fixed_array(), SKIP_WRITE_BARRIER);
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00003796 code->InitializeTypeFeedbackInfoNoWriteBarrier(undefined_value());
ricow@chromium.org27bf2882011-11-17 08:34:43 +00003797 code->set_handler_table(empty_fixed_array(), SKIP_WRITE_BARRIER);
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00003798 code->set_gc_metadata(Smi::FromInt(0));
danno@chromium.org88aa0582012-03-23 15:11:57 +00003799 code->set_ic_age(global_ic_age_);
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +00003800 code->set_prologue_offset(kPrologueOffsetNotSet);
yangguo@chromium.org003650e2013-01-24 16:31:08 +00003801 if (code->kind() == Code::OPTIMIZED_FUNCTION) {
3802 code->set_marked_for_deoptimization(false);
3803 }
kasperl@chromium.org061ef742009-02-27 12:16:20 +00003804 // Allow self references to created code object by patching the handle to
3805 // point to the newly allocated Code object.
3806 if (!self_reference.is_null()) {
3807 *(self_reference.location()) = code;
ager@chromium.orga74f0da2008-12-03 16:05:52 +00003808 }
3809 // Migrate generated code.
3810 // The generated code can contain Object** values (typically from handles)
3811 // that are dereferenced during the copy to point directly to the actual heap
3812 // objects. These pointers can include references to the code object itself,
3813 // through the self_reference parameter.
3814 code->CopyFrom(desc);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003815
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00003816#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00003817 if (FLAG_verify_heap) {
3818 code->Verify();
3819 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003820#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003821 return code;
3822}
3823
3824
lrn@chromium.org303ada72010-10-27 09:33:13 +00003825MaybeObject* Heap::CopyCode(Code* code) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003826 // Allocate an object the same size as the code object.
3827 int obj_size = code->Size();
lrn@chromium.org303ada72010-10-27 09:33:13 +00003828 MaybeObject* maybe_result;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00003829 if (obj_size > code_space()->AreaSize()) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003830 maybe_result = lo_space_->AllocateRaw(obj_size, EXECUTABLE);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003831 } else {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003832 maybe_result = code_space_->AllocateRaw(obj_size);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003833 }
3834
lrn@chromium.org303ada72010-10-27 09:33:13 +00003835 Object* result;
3836 if (!maybe_result->ToObject(&result)) return maybe_result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003837
3838 // Copy code object.
3839 Address old_addr = code->address();
3840 Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00003841 CopyBlock(new_addr, old_addr, obj_size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003842 // Relocate the copy.
3843 Code* new_code = Code::cast(result);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003844 ASSERT(!isolate_->code_range()->exists() ||
3845 isolate_->code_range()->contains(code->address()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003846 new_code->Relocate(new_addr - old_addr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003847 return new_code;
3848}
3849
3850
lrn@chromium.org303ada72010-10-27 09:33:13 +00003851MaybeObject* Heap::CopyCode(Code* code, Vector<byte> reloc_info) {
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003852 // Allocate ByteArray before the Code object, so that we do not risk
3853 // leaving uninitialized Code object (and breaking the heap).
lrn@chromium.org303ada72010-10-27 09:33:13 +00003854 Object* reloc_info_array;
3855 { MaybeObject* maybe_reloc_info_array =
3856 AllocateByteArray(reloc_info.length(), TENURED);
3857 if (!maybe_reloc_info_array->ToObject(&reloc_info_array)) {
3858 return maybe_reloc_info_array;
3859 }
3860 }
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003861
3862 int new_body_size = RoundUp(code->instruction_size(), kObjectAlignment);
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003863
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00003864 int new_obj_size = Code::SizeFor(new_body_size);
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003865
3866 Address old_addr = code->address();
3867
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +00003868 size_t relocation_offset =
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003869 static_cast<size_t>(code->instruction_end() - old_addr);
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003870
lrn@chromium.org303ada72010-10-27 09:33:13 +00003871 MaybeObject* maybe_result;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00003872 if (new_obj_size > code_space()->AreaSize()) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003873 maybe_result = lo_space_->AllocateRaw(new_obj_size, EXECUTABLE);
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003874 } else {
lrn@chromium.org303ada72010-10-27 09:33:13 +00003875 maybe_result = code_space_->AllocateRaw(new_obj_size);
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003876 }
3877
lrn@chromium.org303ada72010-10-27 09:33:13 +00003878 Object* result;
3879 if (!maybe_result->ToObject(&result)) return maybe_result;
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003880
3881 // Copy code object.
3882 Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
3883
3884 // Copy header and instructions.
3885 memcpy(new_addr, old_addr, relocation_offset);
3886
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003887 Code* new_code = Code::cast(result);
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003888 new_code->set_relocation_info(ByteArray::cast(reloc_info_array));
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003889
erik.corry@gmail.com4a2e25e2010-07-07 12:22:46 +00003890 // Copy patched rinfo.
3891 memcpy(new_code->relocation_start(), reloc_info.start(), reloc_info.length());
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003892
3893 // Relocate the copy.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00003894 ASSERT(!isolate_->code_range()->exists() ||
3895 isolate_->code_range()->contains(code->address()));
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003896 new_code->Relocate(new_addr - old_addr);
3897
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00003898#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00003899 if (FLAG_verify_heap) {
3900 code->Verify();
3901 }
fschneider@chromium.org086aac62010-03-17 13:18:24 +00003902#endif
3903 return new_code;
3904}
3905
3906
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003907MaybeObject* Heap::AllocateWithAllocationSite(Map* map, AllocationSpace space,
3908 Handle<Object> allocation_site_info_payload) {
3909 ASSERT(gc_state_ == NOT_IN_GC);
3910 ASSERT(map->instance_type() != MAP_TYPE);
3911 // If allocation failures are disallowed, we may allocate in a different
3912 // space when new space is full and the object is not a large object.
3913 AllocationSpace retry_space =
3914 (space != NEW_SPACE) ? space : TargetSpaceId(map->instance_type());
3915 int size = map->instance_size() + AllocationSiteInfo::kSize;
3916 Object* result;
3917 MaybeObject* maybe_result = AllocateRaw(size, space, retry_space);
3918 if (!maybe_result->ToObject(&result)) return maybe_result;
3919 // No need for write barrier since object is white and map is in old space.
3920 HeapObject::cast(result)->set_map_no_write_barrier(map);
3921 AllocationSiteInfo* alloc_info = reinterpret_cast<AllocationSiteInfo*>(
3922 reinterpret_cast<Address>(result) + map->instance_size());
3923 alloc_info->set_map_no_write_barrier(allocation_site_info_map());
3924 alloc_info->set_payload(*allocation_site_info_payload, SKIP_WRITE_BARRIER);
3925 return result;
3926}
3927
3928
lrn@chromium.org303ada72010-10-27 09:33:13 +00003929MaybeObject* Heap::Allocate(Map* map, AllocationSpace space) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003930 ASSERT(gc_state_ == NOT_IN_GC);
3931 ASSERT(map->instance_type() != MAP_TYPE);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00003932 // If allocation failures are disallowed, we may allocate in a different
3933 // space when new space is full and the object is not a large object.
3934 AllocationSpace retry_space =
3935 (space != NEW_SPACE) ? space : TargetSpaceId(map->instance_type());
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003936 int size = map->instance_size();
lrn@chromium.org303ada72010-10-27 09:33:13 +00003937 Object* result;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003938 MaybeObject* maybe_result = AllocateRaw(size, space, retry_space);
3939 if (!maybe_result->ToObject(&result)) return maybe_result;
ricow@chromium.org27bf2882011-11-17 08:34:43 +00003940 // No need for write barrier since object is white and map is in old space.
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00003941 HeapObject::cast(result)->set_map_no_write_barrier(map);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003942 return result;
3943}
3944
3945
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003946void Heap::InitializeFunction(JSFunction* function,
3947 SharedFunctionInfo* shared,
3948 Object* prototype) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003949 ASSERT(!prototype->IsMap());
3950 function->initialize_properties();
3951 function->initialize_elements();
3952 function->set_shared(shared);
vegorov@chromium.org26c16f82010-08-11 13:41:03 +00003953 function->set_code(shared->code());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003954 function->set_prototype_or_initial_map(prototype);
3955 function->set_context(undefined_value());
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00003956 function->set_literals_or_bindings(empty_fixed_array());
kasperl@chromium.orga5551262010-12-07 12:49:48 +00003957 function->set_next_function_link(undefined_value());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003958}
3959
3960
lrn@chromium.org303ada72010-10-27 09:33:13 +00003961MaybeObject* Heap::AllocateFunctionPrototype(JSFunction* function) {
ager@chromium.orgddb913d2009-01-27 10:01:48 +00003962 // Allocate the prototype. Make sure to use the object function
3963 // from the function's context, since the function can be from a
3964 // different context.
3965 JSFunction* object_function =
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00003966 function->context()->native_context()->object_function();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00003967
3968 // Each function prototype gets a copy of the object function map.
3969 // This avoid unwanted sharing of maps between prototypes of different
3970 // constructors.
3971 Map* new_map;
3972 ASSERT(object_function->has_initial_map());
verwaest@chromium.orgde64f722012-08-16 15:44:54 +00003973 MaybeObject* maybe_map = object_function->initial_map()->Copy();
verwaest@chromium.org753aee42012-07-17 16:15:42 +00003974 if (!maybe_map->To(&new_map)) return maybe_map;
3975
lrn@chromium.org303ada72010-10-27 09:33:13 +00003976 Object* prototype;
verwaest@chromium.org753aee42012-07-17 16:15:42 +00003977 MaybeObject* maybe_prototype = AllocateJSObjectFromMap(new_map);
3978 if (!maybe_prototype->ToObject(&prototype)) return maybe_prototype;
3979
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003980 // When creating the prototype for the function we must set its
3981 // constructor to the function.
verwaest@chromium.org753aee42012-07-17 16:15:42 +00003982 MaybeObject* maybe_failure =
3983 JSObject::cast(prototype)->SetLocalPropertyIgnoreAttributes(
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00003984 constructor_string(), function, DONT_ENUM);
verwaest@chromium.org753aee42012-07-17 16:15:42 +00003985 if (maybe_failure->IsFailure()) return maybe_failure;
3986
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003987 return prototype;
3988}
3989
3990
lrn@chromium.org303ada72010-10-27 09:33:13 +00003991MaybeObject* Heap::AllocateFunction(Map* function_map,
3992 SharedFunctionInfo* shared,
3993 Object* prototype,
3994 PretenureFlag pretenure) {
sgjesse@chromium.org846fb742009-12-18 08:56:33 +00003995 AllocationSpace space =
3996 (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
lrn@chromium.org303ada72010-10-27 09:33:13 +00003997 Object* result;
3998 { MaybeObject* maybe_result = Allocate(function_map, space);
3999 if (!maybe_result->ToObject(&result)) return maybe_result;
4000 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004001 InitializeFunction(JSFunction::cast(result), shared, prototype);
4002 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004003}
4004
4005
lrn@chromium.org303ada72010-10-27 09:33:13 +00004006MaybeObject* Heap::AllocateArgumentsObject(Object* callee, int length) {
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00004007 // To get fast allocation and map sharing for arguments objects we
4008 // allocate them based on an arguments boilerplate.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004009
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004010 JSObject* boilerplate;
4011 int arguments_object_size;
4012 bool strict_mode_callee = callee->IsJSFunction() &&
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00004013 !JSFunction::cast(callee)->shared()->is_classic_mode();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004014 if (strict_mode_callee) {
4015 boilerplate =
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00004016 isolate()->context()->native_context()->
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004017 strict_mode_arguments_boilerplate();
4018 arguments_object_size = kArgumentsObjectSizeStrict;
4019 } else {
4020 boilerplate =
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00004021 isolate()->context()->native_context()->arguments_boilerplate();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004022 arguments_object_size = kArgumentsObjectSize;
4023 }
4024
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004025 // This calls Copy directly rather than using Heap::AllocateRaw so we
4026 // duplicate the check here.
4027 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
4028
sgjesse@chromium.org846fb742009-12-18 08:56:33 +00004029 // Check that the size of the boilerplate matches our
4030 // expectations. The ArgumentsAccessStub::GenerateNewObject relies
4031 // on the size being a known constant.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004032 ASSERT(arguments_object_size == boilerplate->map()->instance_size());
sgjesse@chromium.org846fb742009-12-18 08:56:33 +00004033
4034 // Do the allocation.
lrn@chromium.org303ada72010-10-27 09:33:13 +00004035 Object* result;
4036 { MaybeObject* maybe_result =
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004037 AllocateRaw(arguments_object_size, NEW_SPACE, OLD_POINTER_SPACE);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004038 if (!maybe_result->ToObject(&result)) return maybe_result;
4039 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004040
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004041 // Copy the content. The arguments boilerplate doesn't have any
4042 // fields that point to new space so it's safe to skip the write
4043 // barrier here.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004044 CopyBlock(HeapObject::cast(result)->address(),
4045 boilerplate->address(),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004046 JSObject::kHeaderSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004047
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004048 // Set the length property.
4049 JSObject::cast(result)->InObjectPropertyAtPut(kArgumentsLengthIndex,
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004050 Smi::FromInt(length),
4051 SKIP_WRITE_BARRIER);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004052 // Set the callee property for non-strict mode arguments object only.
4053 if (!strict_mode_callee) {
4054 JSObject::cast(result)->InObjectPropertyAtPut(kArgumentsCalleeIndex,
4055 callee);
4056 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004057
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004058 // Check the state of the object
4059 ASSERT(JSObject::cast(result)->HasFastProperties());
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00004060 ASSERT(JSObject::cast(result)->HasFastObjectElements());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004061
4062 return result;
4063}
4064
4065
fschneider@chromium.orgc20610a2010-09-22 09:44:58 +00004066static bool HasDuplicates(DescriptorArray* descriptors) {
4067 int count = descriptors->number_of_descriptors();
4068 if (count > 1) {
4069 String* prev_key = descriptors->GetKey(0);
4070 for (int i = 1; i != count; i++) {
4071 String* current_key = descriptors->GetKey(i);
4072 if (prev_key == current_key) return true;
4073 prev_key = current_key;
4074 }
4075 }
4076 return false;
4077}
4078
4079
lrn@chromium.org303ada72010-10-27 09:33:13 +00004080MaybeObject* Heap::AllocateInitialMap(JSFunction* fun) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004081 ASSERT(!fun->has_initial_map());
4082
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004083 // First create a new map with the size and number of in-object properties
4084 // suggested by the function.
4085 int instance_size = fun->shared()->CalculateInstanceSize();
4086 int in_object_properties = fun->shared()->CalculateInObjectProperties();
yangguo@chromium.org304cc332012-07-24 07:59:48 +00004087 Map* map;
4088 MaybeObject* maybe_map = AllocateMap(JS_OBJECT_TYPE, instance_size);
4089 if (!maybe_map->To(&map)) return maybe_map;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004090
4091 // Fetch or allocate prototype.
4092 Object* prototype;
4093 if (fun->has_instance_prototype()) {
4094 prototype = fun->instance_prototype();
4095 } else {
yangguo@chromium.org304cc332012-07-24 07:59:48 +00004096 MaybeObject* maybe_prototype = AllocateFunctionPrototype(fun);
4097 if (!maybe_prototype->To(&prototype)) return maybe_prototype;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004098 }
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004099 map->set_inobject_properties(in_object_properties);
4100 map->set_unused_property_fields(in_object_properties);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004101 map->set_prototype(prototype);
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00004102 ASSERT(map->has_fast_object_elements());
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004103
ager@chromium.org5c838252010-02-19 08:53:10 +00004104 // If the function has only simple this property assignments add
4105 // field descriptors for these to the initial map as the object
4106 // cannot be constructed without having these properties. Guard by
4107 // the inline_new flag so we only change the map if we generate a
4108 // specialized construct stub.
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004109 ASSERT(in_object_properties <= Map::kMaxPreAllocatedPropertyFields);
ager@chromium.org5c838252010-02-19 08:53:10 +00004110 if (fun->shared()->CanGenerateInlineConstructor(prototype)) {
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004111 int count = fun->shared()->this_property_assignments_count();
4112 if (count > in_object_properties) {
fschneider@chromium.orgc20610a2010-09-22 09:44:58 +00004113 // Inline constructor can only handle inobject properties.
4114 fun->shared()->ForbidInlineConstructor();
4115 } else {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004116 DescriptorArray* descriptors;
verwaest@chromium.orgde64f722012-08-16 15:44:54 +00004117 MaybeObject* maybe_descriptors = DescriptorArray::Allocate(count);
yangguo@chromium.org304cc332012-07-24 07:59:48 +00004118 if (!maybe_descriptors->To(&descriptors)) return maybe_descriptors;
4119
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004120 DescriptorArray::WhitenessWitness witness(descriptors);
fschneider@chromium.orgc20610a2010-09-22 09:44:58 +00004121 for (int i = 0; i < count; i++) {
4122 String* name = fun->shared()->GetThisPropertyAssignmentName(i);
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004123 ASSERT(name->IsInternalizedString());
rossberg@chromium.org657d53b2012-07-12 11:06:03 +00004124 FieldDescriptor field(name, i, NONE, i + 1);
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004125 descriptors->Set(i, &field, witness);
fschneider@chromium.orgc20610a2010-09-22 09:44:58 +00004126 }
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00004127 descriptors->Sort();
fschneider@chromium.orgc20610a2010-09-22 09:44:58 +00004128
4129 // The descriptors may contain duplicates because the compiler does not
4130 // guarantee the uniqueness of property names (it would have required
4131 // quadratic time). Once the descriptors are sorted we can check for
4132 // duplicates in linear time.
4133 if (HasDuplicates(descriptors)) {
4134 fun->shared()->ForbidInlineConstructor();
4135 } else {
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00004136 map->InitializeDescriptors(descriptors);
fschneider@chromium.orgc20610a2010-09-22 09:44:58 +00004137 map->set_pre_allocated_property_fields(count);
4138 map->set_unused_property_fields(in_object_properties - count);
4139 }
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004140 }
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004141 }
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004142
4143 fun->shared()->StartInobjectSlackTracking(map);
4144
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004145 return map;
4146}
4147
4148
4149void Heap::InitializeJSObjectFromMap(JSObject* obj,
4150 FixedArray* properties,
4151 Map* map) {
4152 obj->set_properties(properties);
4153 obj->initialize_elements();
4154 // TODO(1240798): Initialize the object's body using valid initial values
4155 // according to the object's initial map. For example, if the map's
4156 // instance type is JS_ARRAY_TYPE, the length field should be initialized
ulan@chromium.org2efb9002012-01-19 15:36:35 +00004157 // to a number (e.g. Smi::FromInt(0)) and the elements initialized to a
4158 // fixed array (e.g. Heap::empty_fixed_array()). Currently, the object
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004159 // verification code has to cope with (temporarily) invalid objects. See
4160 // for example, JSArray::JSArrayVerify).
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004161 Object* filler;
4162 // We cannot always fill with one_pointer_filler_map because objects
4163 // created from API functions expect their internal fields to be initialized
4164 // with undefined_value.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004165 // Pre-allocated fields need to be initialized with undefined_value as well
4166 // so that object accesses before the constructor completes (e.g. in the
4167 // debugger) will not cause a crash.
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004168 if (map->constructor()->IsJSFunction() &&
4169 JSFunction::cast(map->constructor())->shared()->
4170 IsInobjectSlackTrackingInProgress()) {
4171 // We might want to shrink the object later.
4172 ASSERT(obj->GetInternalFieldCount() == 0);
4173 filler = Heap::one_pointer_filler_map();
4174 } else {
4175 filler = Heap::undefined_value();
4176 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004177 obj->InitializeBody(map, Heap::undefined_value(), filler);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004178}
4179
4180
lrn@chromium.org303ada72010-10-27 09:33:13 +00004181MaybeObject* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004182 // JSFunctions should be allocated using AllocateFunction to be
4183 // properly initialized.
4184 ASSERT(map->instance_type() != JS_FUNCTION_TYPE);
4185
fschneider@chromium.org40b9da32010-06-28 11:29:21 +00004186 // Both types of global objects should be allocated using
4187 // AllocateGlobalObject to be properly initialized.
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004188 ASSERT(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
4189 ASSERT(map->instance_type() != JS_BUILTINS_OBJECT_TYPE);
4190
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004191 // Allocate the backing storage for the properties.
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00004192 int prop_size =
4193 map->pre_allocated_property_fields() +
4194 map->unused_property_fields() -
4195 map->inobject_properties();
4196 ASSERT(prop_size >= 0);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004197 Object* properties;
4198 { MaybeObject* maybe_properties = AllocateFixedArray(prop_size, pretenure);
4199 if (!maybe_properties->ToObject(&properties)) return maybe_properties;
4200 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004201
4202 // Allocate the JSObject.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00004203 AllocationSpace space =
4204 (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00004205 if (map->instance_size() > Page::kMaxNonCodeHeapObjectSize) space = LO_SPACE;
lrn@chromium.org303ada72010-10-27 09:33:13 +00004206 Object* obj;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004207 MaybeObject* maybe_obj = Allocate(map, space);
4208 if (!maybe_obj->To(&obj)) return maybe_obj;
4209
4210 // Initialize the JSObject.
4211 InitializeJSObjectFromMap(JSObject::cast(obj),
4212 FixedArray::cast(properties),
4213 map);
4214 ASSERT(JSObject::cast(obj)->HasFastElements());
4215 return obj;
4216}
4217
4218
4219MaybeObject* Heap::AllocateJSObjectFromMapWithAllocationSite(Map* map,
4220 Handle<Object> allocation_site_info_payload) {
4221 // JSFunctions should be allocated using AllocateFunction to be
4222 // properly initialized.
4223 ASSERT(map->instance_type() != JS_FUNCTION_TYPE);
4224
4225 // Both types of global objects should be allocated using
4226 // AllocateGlobalObject to be properly initialized.
4227 ASSERT(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
4228 ASSERT(map->instance_type() != JS_BUILTINS_OBJECT_TYPE);
4229
4230 // Allocate the backing storage for the properties.
4231 int prop_size =
4232 map->pre_allocated_property_fields() +
4233 map->unused_property_fields() -
4234 map->inobject_properties();
4235 ASSERT(prop_size >= 0);
4236 Object* properties;
4237 { MaybeObject* maybe_properties = AllocateFixedArray(prop_size);
4238 if (!maybe_properties->ToObject(&properties)) return maybe_properties;
lrn@chromium.org303ada72010-10-27 09:33:13 +00004239 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004240
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004241 // Allocate the JSObject.
4242 AllocationSpace space = NEW_SPACE;
4243 if (map->instance_size() > Page::kMaxNonCodeHeapObjectSize) space = LO_SPACE;
4244 Object* obj;
4245 MaybeObject* maybe_obj = AllocateWithAllocationSite(map, space,
4246 allocation_site_info_payload);
4247 if (!maybe_obj->To(&obj)) return maybe_obj;
4248
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004249 // Initialize the JSObject.
4250 InitializeJSObjectFromMap(JSObject::cast(obj),
4251 FixedArray::cast(properties),
4252 map);
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004253 ASSERT(JSObject::cast(obj)->HasFastElements());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004254 return obj;
4255}
4256
4257
lrn@chromium.org303ada72010-10-27 09:33:13 +00004258MaybeObject* Heap::AllocateJSObject(JSFunction* constructor,
4259 PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004260 // Allocate the initial map if absent.
4261 if (!constructor->has_initial_map()) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00004262 Object* initial_map;
4263 { MaybeObject* maybe_initial_map = AllocateInitialMap(constructor);
4264 if (!maybe_initial_map->ToObject(&initial_map)) return maybe_initial_map;
4265 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004266 constructor->set_initial_map(Map::cast(initial_map));
4267 Map::cast(initial_map)->set_constructor(constructor);
4268 }
4269 // Allocate the object based on the constructors initial map.
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004270 MaybeObject* result = AllocateJSObjectFromMap(
4271 constructor->initial_map(), pretenure);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004272#ifdef DEBUG
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004273 // Make sure result is NOT a global object if valid.
lrn@chromium.org303ada72010-10-27 09:33:13 +00004274 Object* non_failure;
4275 ASSERT(!result->ToObject(&non_failure) || !non_failure->IsGlobalObject());
4276#endif
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004277 return result;
4278}
4279
4280
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004281MaybeObject* Heap::AllocateJSObjectWithAllocationSite(JSFunction* constructor,
4282 Handle<Object> allocation_site_info_payload) {
4283 // Allocate the initial map if absent.
4284 if (!constructor->has_initial_map()) {
4285 Object* initial_map;
4286 { MaybeObject* maybe_initial_map = AllocateInitialMap(constructor);
4287 if (!maybe_initial_map->ToObject(&initial_map)) return maybe_initial_map;
4288 }
4289 constructor->set_initial_map(Map::cast(initial_map));
4290 Map::cast(initial_map)->set_constructor(constructor);
4291 }
4292 // Allocate the object based on the constructors initial map, or the payload
4293 // advice
4294 Map* initial_map = constructor->initial_map();
4295
4296 JSGlobalPropertyCell* cell = JSGlobalPropertyCell::cast(
4297 *allocation_site_info_payload);
4298 Smi* smi = Smi::cast(cell->value());
4299 ElementsKind to_kind = static_cast<ElementsKind>(smi->value());
4300 AllocationSiteMode mode = TRACK_ALLOCATION_SITE;
4301 if (to_kind != initial_map->elements_kind()) {
4302 MaybeObject* maybe_new_map = constructor->GetElementsTransitionMap(
4303 isolate(), to_kind);
4304 if (!maybe_new_map->To(&initial_map)) return maybe_new_map;
4305 // Possibly alter the mode, since we found an updated elements kind
4306 // in the type info cell.
4307 mode = AllocationSiteInfo::GetMode(to_kind);
4308 }
4309
4310 MaybeObject* result;
4311 if (mode == TRACK_ALLOCATION_SITE) {
4312 result = AllocateJSObjectFromMapWithAllocationSite(initial_map,
4313 allocation_site_info_payload);
4314 } else {
4315 result = AllocateJSObjectFromMap(initial_map, NOT_TENURED);
4316 }
4317#ifdef DEBUG
4318 // Make sure result is NOT a global object if valid.
4319 Object* non_failure;
4320 ASSERT(!result->ToObject(&non_failure) || !non_failure->IsGlobalObject());
4321#endif
4322 return result;
4323}
4324
4325
danno@chromium.org81cac2b2012-07-10 11:28:27 +00004326MaybeObject* Heap::AllocateJSModule(Context* context, ScopeInfo* scope_info) {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00004327 // Allocate a fresh map. Modules do not have a prototype.
4328 Map* map;
4329 MaybeObject* maybe_map = AllocateMap(JS_MODULE_TYPE, JSModule::kSize);
4330 if (!maybe_map->To(&map)) return maybe_map;
4331 // Allocate the object based on the map.
danno@chromium.org81cac2b2012-07-10 11:28:27 +00004332 JSModule* module;
4333 MaybeObject* maybe_module = AllocateJSObjectFromMap(map, TENURED);
4334 if (!maybe_module->To(&module)) return maybe_module;
4335 module->set_context(context);
4336 module->set_scope_info(scope_info);
4337 return module;
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00004338}
4339
4340
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004341MaybeObject* Heap::AllocateJSArrayAndStorage(
4342 ElementsKind elements_kind,
4343 int length,
4344 int capacity,
4345 ArrayStorageAllocationMode mode,
4346 PretenureFlag pretenure) {
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004347 MaybeObject* maybe_array = AllocateJSArray(elements_kind, pretenure);
4348 JSArray* array;
4349 if (!maybe_array->To(&array)) return maybe_array;
4350
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004351 // TODO(mvstanton): this body of code is duplicate with AllocateJSArrayStorage
4352 // for performance reasons.
4353 ASSERT(capacity >= length);
4354
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004355 if (capacity == 0) {
4356 array->set_length(Smi::FromInt(0));
4357 array->set_elements(empty_fixed_array());
4358 return array;
4359 }
4360
4361 FixedArrayBase* elms;
4362 MaybeObject* maybe_elms = NULL;
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004363 if (IsFastDoubleElementsKind(elements_kind)) {
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004364 if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
4365 maybe_elms = AllocateUninitializedFixedDoubleArray(capacity);
4366 } else {
4367 ASSERT(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
4368 maybe_elms = AllocateFixedDoubleArrayWithHoles(capacity);
4369 }
4370 } else {
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00004371 ASSERT(IsFastSmiOrObjectElementsKind(elements_kind));
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004372 if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
4373 maybe_elms = AllocateUninitializedFixedArray(capacity);
4374 } else {
4375 ASSERT(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
4376 maybe_elms = AllocateFixedArrayWithHoles(capacity);
4377 }
4378 }
4379 if (!maybe_elms->To(&elms)) return maybe_elms;
4380
4381 array->set_elements(elms);
4382 array->set_length(Smi::FromInt(length));
4383 return array;
4384}
4385
4386
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004387MaybeObject* Heap::AllocateJSArrayAndStorageWithAllocationSite(
4388 ElementsKind elements_kind,
4389 int length,
4390 int capacity,
4391 Handle<Object> allocation_site_payload,
4392 ArrayStorageAllocationMode mode) {
4393 MaybeObject* maybe_array = AllocateJSArrayWithAllocationSite(elements_kind,
4394 allocation_site_payload);
4395 JSArray* array;
4396 if (!maybe_array->To(&array)) return maybe_array;
4397 return AllocateJSArrayStorage(array, length, capacity, mode);
4398}
4399
4400
4401MaybeObject* Heap::AllocateJSArrayStorage(
4402 JSArray* array,
4403 int length,
4404 int capacity,
4405 ArrayStorageAllocationMode mode) {
4406 ASSERT(capacity >= length);
4407
4408 if (capacity == 0) {
4409 array->set_length(Smi::FromInt(0));
4410 array->set_elements(empty_fixed_array());
4411 return array;
4412 }
4413
4414 FixedArrayBase* elms;
4415 MaybeObject* maybe_elms = NULL;
4416 ElementsKind elements_kind = array->GetElementsKind();
4417 if (IsFastDoubleElementsKind(elements_kind)) {
4418 if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
4419 maybe_elms = AllocateUninitializedFixedDoubleArray(capacity);
4420 } else {
4421 ASSERT(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
4422 maybe_elms = AllocateFixedDoubleArrayWithHoles(capacity);
4423 }
4424 } else {
4425 ASSERT(IsFastSmiOrObjectElementsKind(elements_kind));
4426 if (mode == DONT_INITIALIZE_ARRAY_ELEMENTS) {
4427 maybe_elms = AllocateUninitializedFixedArray(capacity);
4428 } else {
4429 ASSERT(mode == INITIALIZE_ARRAY_ELEMENTS_WITH_HOLE);
4430 maybe_elms = AllocateFixedArrayWithHoles(capacity);
4431 }
4432 }
4433 if (!maybe_elms->To(&elms)) return maybe_elms;
4434
4435 array->set_elements(elms);
4436 array->set_length(Smi::FromInt(length));
4437 return array;
4438}
4439
4440
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004441MaybeObject* Heap::AllocateJSArrayWithElements(
4442 FixedArrayBase* elements,
4443 ElementsKind elements_kind,
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004444 int length,
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004445 PretenureFlag pretenure) {
4446 MaybeObject* maybe_array = AllocateJSArray(elements_kind, pretenure);
4447 JSArray* array;
4448 if (!maybe_array->To(&array)) return maybe_array;
4449
4450 array->set_elements(elements);
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004451 array->set_length(Smi::FromInt(length));
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00004452 array->ValidateElements();
danno@chromium.orgfa458e42012-02-01 10:48:36 +00004453 return array;
4454}
4455
4456
vegorov@chromium.org7304bca2011-05-16 12:14:13 +00004457MaybeObject* Heap::AllocateJSProxy(Object* handler, Object* prototype) {
4458 // Allocate map.
4459 // TODO(rossberg): Once we optimize proxies, think about a scheme to share
4460 // maps. Will probably depend on the identity of the handler object, too.
danno@chromium.org40cb8782011-05-25 07:58:50 +00004461 Map* map;
vegorov@chromium.org7304bca2011-05-16 12:14:13 +00004462 MaybeObject* maybe_map_obj = AllocateMap(JS_PROXY_TYPE, JSProxy::kSize);
danno@chromium.org40cb8782011-05-25 07:58:50 +00004463 if (!maybe_map_obj->To<Map>(&map)) return maybe_map_obj;
vegorov@chromium.org7304bca2011-05-16 12:14:13 +00004464 map->set_prototype(prototype);
vegorov@chromium.org7304bca2011-05-16 12:14:13 +00004465
4466 // Allocate the proxy object.
lrn@chromium.org34e60782011-09-15 07:25:40 +00004467 JSProxy* result;
vegorov@chromium.org7304bca2011-05-16 12:14:13 +00004468 MaybeObject* maybe_result = Allocate(map, NEW_SPACE);
lrn@chromium.org34e60782011-09-15 07:25:40 +00004469 if (!maybe_result->To<JSProxy>(&result)) return maybe_result;
4470 result->InitializeBody(map->instance_size(), Smi::FromInt(0));
4471 result->set_handler(handler);
ricow@chromium.org27bf2882011-11-17 08:34:43 +00004472 result->set_hash(undefined_value(), SKIP_WRITE_BARRIER);
lrn@chromium.org34e60782011-09-15 07:25:40 +00004473 return result;
4474}
4475
4476
4477MaybeObject* Heap::AllocateJSFunctionProxy(Object* handler,
4478 Object* call_trap,
4479 Object* construct_trap,
4480 Object* prototype) {
4481 // Allocate map.
4482 // TODO(rossberg): Once we optimize proxies, think about a scheme to share
4483 // maps. Will probably depend on the identity of the handler object, too.
4484 Map* map;
4485 MaybeObject* maybe_map_obj =
4486 AllocateMap(JS_FUNCTION_PROXY_TYPE, JSFunctionProxy::kSize);
4487 if (!maybe_map_obj->To<Map>(&map)) return maybe_map_obj;
4488 map->set_prototype(prototype);
4489
4490 // Allocate the proxy object.
4491 JSFunctionProxy* result;
4492 MaybeObject* maybe_result = Allocate(map, NEW_SPACE);
4493 if (!maybe_result->To<JSFunctionProxy>(&result)) return maybe_result;
4494 result->InitializeBody(map->instance_size(), Smi::FromInt(0));
4495 result->set_handler(handler);
ricow@chromium.org27bf2882011-11-17 08:34:43 +00004496 result->set_hash(undefined_value(), SKIP_WRITE_BARRIER);
lrn@chromium.org34e60782011-09-15 07:25:40 +00004497 result->set_call_trap(call_trap);
4498 result->set_construct_trap(construct_trap);
vegorov@chromium.org7304bca2011-05-16 12:14:13 +00004499 return result;
4500}
4501
4502
lrn@chromium.org303ada72010-10-27 09:33:13 +00004503MaybeObject* Heap::AllocateGlobalObject(JSFunction* constructor) {
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004504 ASSERT(constructor->has_initial_map());
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004505 Map* map = constructor->initial_map();
erik.corry@gmail.com88767242012-08-08 14:43:45 +00004506 ASSERT(map->is_dictionary_map());
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004507
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004508 // Make sure no field properties are described in the initial map.
4509 // This guarantees us that normalizing the properties does not
4510 // require us to change property values to JSGlobalPropertyCells.
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004511 ASSERT(map->NextFreePropertyIndex() == 0);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004512
4513 // Make sure we don't have a ton of pre-allocated slots in the
4514 // global objects. They will be unused once we normalize the object.
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004515 ASSERT(map->unused_property_fields() == 0);
4516 ASSERT(map->inobject_properties() == 0);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004517
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004518 // Initial size of the backing store to avoid resize of the storage during
4519 // bootstrapping. The size differs between the JS global object ad the
4520 // builtins object.
4521 int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004522
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004523 // Allocate a dictionary object for backing storage.
verwaest@chromium.orgb6d052d2012-07-27 08:03:27 +00004524 StringDictionary* dictionary;
4525 MaybeObject* maybe_dictionary =
4526 StringDictionary::Allocate(
verwaest@chromium.org33e09c82012-10-10 17:07:22 +00004527 map->NumberOfOwnDescriptors() * 2 + initial_size);
verwaest@chromium.orgb6d052d2012-07-27 08:03:27 +00004528 if (!maybe_dictionary->To(&dictionary)) return maybe_dictionary;
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004529
4530 // The global object might be created from an object template with accessors.
4531 // Fill these accessors into the dictionary.
4532 DescriptorArray* descs = map->instance_descriptors();
4533 for (int i = 0; i < descs->number_of_descriptors(); i++) {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00004534 PropertyDetails details = descs->GetDetails(i);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004535 ASSERT(details.type() == CALLBACKS); // Only accessors are expected.
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00004536 PropertyDetails d = PropertyDetails(details.attributes(),
4537 CALLBACKS,
4538 details.descriptor_index());
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004539 Object* value = descs->GetCallbacksObject(i);
verwaest@chromium.orgb6d052d2012-07-27 08:03:27 +00004540 MaybeObject* maybe_value = AllocateJSGlobalPropertyCell(value);
4541 if (!maybe_value->ToObject(&value)) return maybe_value;
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004542
verwaest@chromium.orgb6d052d2012-07-27 08:03:27 +00004543 MaybeObject* maybe_added = dictionary->Add(descs->GetKey(i), value, d);
4544 if (!maybe_added->To(&dictionary)) return maybe_added;
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004545 }
4546
4547 // Allocate the global object and initialize it with the backing store.
verwaest@chromium.orgb6d052d2012-07-27 08:03:27 +00004548 JSObject* global;
4549 MaybeObject* maybe_global = Allocate(map, OLD_POINTER_SPACE);
4550 if (!maybe_global->To(&global)) return maybe_global;
4551
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004552 InitializeJSObjectFromMap(global, dictionary, map);
4553
4554 // Create a new map for the global object.
rossberg@chromium.org657d53b2012-07-12 11:06:03 +00004555 Map* new_map;
verwaest@chromium.orgb6d052d2012-07-27 08:03:27 +00004556 MaybeObject* maybe_map = map->CopyDropDescriptors();
4557 if (!maybe_map->To(&new_map)) return maybe_map;
erik.corry@gmail.com88767242012-08-08 14:43:45 +00004558 new_map->set_dictionary_map(true);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004559
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00004560 // Set up the global object as a normalized object.
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004561 global->set_map(new_map);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00004562 global->set_properties(dictionary);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00004563
4564 // Make sure result is a global object with properties in dictionary.
4565 ASSERT(global->IsGlobalObject());
4566 ASSERT(!global->HasFastProperties());
4567 return global;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004568}
4569
4570
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004571MaybeObject* Heap::CopyJSObject(JSObject* source) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004572 // Never used to copy functions. If functions need to be copied we
4573 // have to be careful to clear the literals array.
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004574 SLOW_ASSERT(!source->IsJSFunction());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004575
4576 // Make the clone.
4577 Map* map = source->map();
4578 int object_size = map->instance_size();
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004579 Object* clone;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004580
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004581 WriteBarrierMode wb_mode = UPDATE_WRITE_BARRIER;
4582
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004583 // If we're forced to always allocate, we use the general allocation
4584 // functions which may leave us with an object in old space.
4585 if (always_allocate()) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00004586 { MaybeObject* maybe_clone =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004587 AllocateRaw(object_size, NEW_SPACE, OLD_POINTER_SPACE);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004588 if (!maybe_clone->ToObject(&clone)) return maybe_clone;
4589 }
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004590 Address clone_address = HeapObject::cast(clone)->address();
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004591 CopyBlock(clone_address,
4592 source->address(),
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004593 object_size);
4594 // Update write barrier for all fields that lie beyond the header.
vegorov@chromium.orgf8372902010-03-15 10:26:20 +00004595 RecordWrites(clone_address,
4596 JSObject::kHeaderSize,
antonm@chromium.org8e5e3382010-03-24 09:56:30 +00004597 (object_size - JSObject::kHeaderSize) / kPointerSize);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004598 } else {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004599 wb_mode = SKIP_WRITE_BARRIER;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004600
4601 { MaybeObject* maybe_clone = new_space_.AllocateRaw(object_size);
4602 if (!maybe_clone->ToObject(&clone)) return maybe_clone;
4603 }
4604 SLOW_ASSERT(InNewSpace(clone));
4605 // Since we know the clone is allocated in new space, we can copy
4606 // the contents without worrying about updating the write barrier.
4607 CopyBlock(HeapObject::cast(clone)->address(),
4608 source->address(),
4609 object_size);
4610 }
4611
4612 SLOW_ASSERT(
4613 JSObject::cast(clone)->GetElementsKind() == source->GetElementsKind());
4614 FixedArrayBase* elements = FixedArrayBase::cast(source->elements());
4615 FixedArray* properties = FixedArray::cast(source->properties());
4616 // Update elements if necessary.
4617 if (elements->length() > 0) {
4618 Object* elem;
4619 { MaybeObject* maybe_elem;
4620 if (elements->map() == fixed_cow_array_map()) {
4621 maybe_elem = FixedArray::cast(elements);
4622 } else if (source->HasFastDoubleElements()) {
4623 maybe_elem = CopyFixedDoubleArray(FixedDoubleArray::cast(elements));
4624 } else {
4625 maybe_elem = CopyFixedArray(FixedArray::cast(elements));
4626 }
4627 if (!maybe_elem->ToObject(&elem)) return maybe_elem;
4628 }
4629 JSObject::cast(clone)->set_elements(FixedArrayBase::cast(elem), wb_mode);
4630 }
4631 // Update properties if necessary.
4632 if (properties->length() > 0) {
4633 Object* prop;
4634 { MaybeObject* maybe_prop = CopyFixedArray(properties);
4635 if (!maybe_prop->ToObject(&prop)) return maybe_prop;
4636 }
4637 JSObject::cast(clone)->set_properties(FixedArray::cast(prop), wb_mode);
4638 }
4639 // Return the new clone.
4640 return clone;
4641}
4642
4643
4644MaybeObject* Heap::CopyJSObjectWithAllocationSite(JSObject* source) {
4645 // Never used to copy functions. If functions need to be copied we
4646 // have to be careful to clear the literals array.
4647 SLOW_ASSERT(!source->IsJSFunction());
4648
4649 // Make the clone.
4650 Map* map = source->map();
4651 int object_size = map->instance_size();
4652 Object* clone;
4653
4654 ASSERT(map->CanTrackAllocationSite());
4655 ASSERT(map->instance_type() == JS_ARRAY_TYPE);
4656 WriteBarrierMode wb_mode = UPDATE_WRITE_BARRIER;
4657
4658 // If we're forced to always allocate, we use the general allocation
4659 // functions which may leave us with an object in old space.
4660 int adjusted_object_size = object_size;
4661 if (always_allocate()) {
4662 // We'll only track origin if we are certain to allocate in new space
4663 const int kMinFreeNewSpaceAfterGC = InitialSemiSpaceSize() * 3/4;
4664 if ((object_size + AllocationSiteInfo::kSize) < kMinFreeNewSpaceAfterGC) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004665 adjusted_object_size += AllocationSiteInfo::kSize;
4666 }
4667
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004668 { MaybeObject* maybe_clone =
4669 AllocateRaw(adjusted_object_size, NEW_SPACE, OLD_POINTER_SPACE);
4670 if (!maybe_clone->ToObject(&clone)) return maybe_clone;
4671 }
4672 Address clone_address = HeapObject::cast(clone)->address();
4673 CopyBlock(clone_address,
4674 source->address(),
4675 object_size);
4676 // Update write barrier for all fields that lie beyond the header.
4677 int write_barrier_offset = adjusted_object_size > object_size
4678 ? JSArray::kSize + AllocationSiteInfo::kSize
4679 : JSObject::kHeaderSize;
4680 if (((object_size - write_barrier_offset) / kPointerSize) > 0) {
4681 RecordWrites(clone_address,
4682 write_barrier_offset,
4683 (object_size - write_barrier_offset) / kPointerSize);
4684 }
4685
4686 // Track allocation site information, if we failed to allocate it inline.
4687 if (InNewSpace(clone) &&
4688 adjusted_object_size == object_size) {
4689 MaybeObject* maybe_alloc_info =
4690 AllocateStruct(ALLOCATION_SITE_INFO_TYPE);
4691 AllocationSiteInfo* alloc_info;
4692 if (maybe_alloc_info->To(&alloc_info)) {
4693 alloc_info->set_map_no_write_barrier(allocation_site_info_map());
4694 alloc_info->set_payload(source, SKIP_WRITE_BARRIER);
4695 }
4696 }
4697 } else {
4698 wb_mode = SKIP_WRITE_BARRIER;
4699 adjusted_object_size += AllocationSiteInfo::kSize;
4700
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004701 { MaybeObject* maybe_clone = new_space_.AllocateRaw(adjusted_object_size);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004702 if (!maybe_clone->ToObject(&clone)) return maybe_clone;
4703 }
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004704 SLOW_ASSERT(InNewSpace(clone));
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004705 // Since we know the clone is allocated in new space, we can copy
ager@chromium.org32912102009-01-16 10:38:43 +00004706 // the contents without worrying about updating the write barrier.
ricow@chromium.org30ce4112010-05-31 10:38:25 +00004707 CopyBlock(HeapObject::cast(clone)->address(),
4708 source->address(),
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00004709 object_size);
4710 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004711
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004712 if (adjusted_object_size > object_size) {
4713 AllocationSiteInfo* alloc_info = reinterpret_cast<AllocationSiteInfo*>(
4714 reinterpret_cast<Address>(clone) + object_size);
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004715 alloc_info->set_map_no_write_barrier(allocation_site_info_map());
4716 alloc_info->set_payload(source, SKIP_WRITE_BARRIER);
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004717 }
4718
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004719 SLOW_ASSERT(
4720 JSObject::cast(clone)->GetElementsKind() == source->GetElementsKind());
ricow@chromium.org2c99e282011-07-28 09:15:17 +00004721 FixedArrayBase* elements = FixedArrayBase::cast(source->elements());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004722 FixedArray* properties = FixedArray::cast(source->properties());
4723 // Update elements if necessary.
ager@chromium.orgb26c50a2010-03-26 09:27:16 +00004724 if (elements->length() > 0) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00004725 Object* elem;
ricow@chromium.org2c99e282011-07-28 09:15:17 +00004726 { MaybeObject* maybe_elem;
4727 if (elements->map() == fixed_cow_array_map()) {
4728 maybe_elem = FixedArray::cast(elements);
4729 } else if (source->HasFastDoubleElements()) {
4730 maybe_elem = CopyFixedDoubleArray(FixedDoubleArray::cast(elements));
4731 } else {
4732 maybe_elem = CopyFixedArray(FixedArray::cast(elements));
4733 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00004734 if (!maybe_elem->ToObject(&elem)) return maybe_elem;
4735 }
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004736 JSObject::cast(clone)->set_elements(FixedArrayBase::cast(elem), wb_mode);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004737 }
4738 // Update properties if necessary.
4739 if (properties->length() > 0) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00004740 Object* prop;
4741 { MaybeObject* maybe_prop = CopyFixedArray(properties);
4742 if (!maybe_prop->ToObject(&prop)) return maybe_prop;
4743 }
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00004744 JSObject::cast(clone)->set_properties(FixedArray::cast(prop), wb_mode);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00004745 }
4746 // Return the new clone.
4747 return clone;
4748}
4749
4750
lrn@chromium.org34e60782011-09-15 07:25:40 +00004751MaybeObject* Heap::ReinitializeJSReceiver(
4752 JSReceiver* object, InstanceType type, int size) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004753 ASSERT(type >= FIRST_JS_OBJECT_TYPE);
lrn@chromium.org34e60782011-09-15 07:25:40 +00004754
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004755 // Allocate fresh map.
4756 // TODO(rossberg): Once we optimize proxies, cache these maps.
4757 Map* map;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004758 MaybeObject* maybe = AllocateMap(type, size);
4759 if (!maybe->To<Map>(&map)) return maybe;
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004760
lrn@chromium.org34e60782011-09-15 07:25:40 +00004761 // Check that the receiver has at least the size of the fresh object.
4762 int size_difference = object->map()->instance_size() - map->instance_size();
4763 ASSERT(size_difference >= 0);
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004764
4765 map->set_prototype(object->map()->prototype());
4766
4767 // Allocate the backing storage for the properties.
4768 int prop_size = map->unused_property_fields() - map->inobject_properties();
4769 Object* properties;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004770 maybe = AllocateFixedArray(prop_size, TENURED);
4771 if (!maybe->ToObject(&properties)) return maybe;
4772
4773 // Functions require some allocation, which might fail here.
4774 SharedFunctionInfo* shared = NULL;
4775 if (type == JS_FUNCTION_TYPE) {
4776 String* name;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004777 maybe =
4778 InternalizeOneByteString(STATIC_ASCII_VECTOR("<freezing call trap>"));
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004779 if (!maybe->To<String>(&name)) return maybe;
4780 maybe = AllocateSharedFunctionInfo(name);
4781 if (!maybe->To<SharedFunctionInfo>(&shared)) return maybe;
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004782 }
4783
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004784 // Because of possible retries of this function after failure,
4785 // we must NOT fail after this point, where we have changed the type!
4786
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004787 // Reset the map for the object.
4788 object->set_map(map);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004789 JSObject* jsobj = JSObject::cast(object);
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004790
4791 // Reinitialize the object from the constructor map.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004792 InitializeJSObjectFromMap(jsobj, FixedArray::cast(properties), map);
lrn@chromium.org34e60782011-09-15 07:25:40 +00004793
4794 // Functions require some minimal initialization.
4795 if (type == JS_FUNCTION_TYPE) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00004796 map->set_function_with_prototype(true);
4797 InitializeFunction(JSFunction::cast(object), shared, the_hole_value());
4798 JSFunction::cast(object)->set_context(
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00004799 isolate()->context()->native_context());
lrn@chromium.org34e60782011-09-15 07:25:40 +00004800 }
4801
4802 // Put in filler if the new object is smaller than the old.
4803 if (size_difference > 0) {
4804 CreateFillerObjectAt(
4805 object->address() + map->instance_size(), size_difference);
4806 }
4807
rossberg@chromium.org717967f2011-07-20 13:44:42 +00004808 return object;
4809}
4810
4811
lrn@chromium.org303ada72010-10-27 09:33:13 +00004812MaybeObject* Heap::ReinitializeJSGlobalProxy(JSFunction* constructor,
4813 JSGlobalProxy* object) {
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004814 ASSERT(constructor->has_initial_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004815 Map* map = constructor->initial_map();
4816
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004817 // Check that the already allocated object has the same size and type as
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004818 // objects allocated using the constructor.
4819 ASSERT(map->instance_size() == object->map()->instance_size());
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00004820 ASSERT(map->instance_type() == object->map()->instance_type());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004821
4822 // Allocate the backing storage for the properties.
ager@chromium.org7c537e22008-10-16 08:43:32 +00004823 int prop_size = map->unused_property_fields() - map->inobject_properties();
lrn@chromium.org303ada72010-10-27 09:33:13 +00004824 Object* properties;
4825 { MaybeObject* maybe_properties = AllocateFixedArray(prop_size, TENURED);
4826 if (!maybe_properties->ToObject(&properties)) return maybe_properties;
4827 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004828
4829 // Reset the map for the object.
4830 object->set_map(constructor->initial_map());
4831
4832 // Reinitialize the object from the constructor map.
4833 InitializeJSObjectFromMap(object, FixedArray::cast(properties), map);
4834 return object;
4835}
4836
4837
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00004838MaybeObject* Heap::AllocateStringFromOneByte(Vector<const uint8_t> string,
lrn@chromium.org303ada72010-10-27 09:33:13 +00004839 PretenureFlag pretenure) {
ulan@chromium.org56c14af2012-09-20 12:51:09 +00004840 int length = string.length();
4841 if (length == 1) {
ricow@chromium.org55ee8072011-09-08 16:33:10 +00004842 return Heap::LookupSingleCharacterStringFromCode(string[0]);
4843 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00004844 Object* result;
4845 { MaybeObject* maybe_result =
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00004846 AllocateRawOneByteString(string.length(), pretenure);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004847 if (!maybe_result->ToObject(&result)) return maybe_result;
4848 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004849
4850 // Copy the characters into the new object.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00004851 CopyChars(SeqOneByteString::cast(result)->GetChars(),
4852 string.start(),
4853 length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004854 return result;
4855}
4856
4857
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00004858MaybeObject* Heap::AllocateStringFromUtf8Slow(Vector<const char> string,
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00004859 int non_ascii_start,
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00004860 PretenureFlag pretenure) {
rossberg@chromium.org89e18f52012-10-22 13:09:53 +00004861 // Continue counting the number of characters in the UTF-8 string, starting
4862 // from the first non-ascii character or word.
ager@chromium.orga9aa5fa2011-04-13 08:46:07 +00004863 Access<UnicodeCache::Utf8Decoder>
4864 decoder(isolate_->unicode_cache()->utf8_decoder());
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004865 decoder->Reset(string.start() + non_ascii_start,
4866 string.length() - non_ascii_start);
4867 int utf16_length = decoder->Utf16Length();
4868 ASSERT(utf16_length > 0);
4869 // Allocate string.
lrn@chromium.org303ada72010-10-27 09:33:13 +00004870 Object* result;
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004871 {
4872 int chars = non_ascii_start + utf16_length;
4873 MaybeObject* maybe_result = AllocateRawTwoByteString(chars, pretenure);
lrn@chromium.org303ada72010-10-27 09:33:13 +00004874 if (!maybe_result->ToObject(&result)) return maybe_result;
4875 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004876 // Convert and copy the characters into the new object.
ulan@chromium.org56c14af2012-09-20 12:51:09 +00004877 SeqTwoByteString* twobyte = SeqTwoByteString::cast(result);
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004878 // Copy ascii portion.
4879 uint16_t* data = twobyte->GetChars();
4880 if (non_ascii_start != 0) {
4881 const char* ascii_data = string.start();
4882 for (int i = 0; i < non_ascii_start; i++) {
4883 *data++ = *ascii_data++;
yangguo@chromium.org154ff992012-03-13 08:09:54 +00004884 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004885 }
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004886 // Now write the remainder.
4887 decoder->WriteUtf16(data, utf16_length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004888 return result;
4889}
4890
4891
lrn@chromium.org303ada72010-10-27 09:33:13 +00004892MaybeObject* Heap::AllocateStringFromTwoByte(Vector<const uc16> string,
4893 PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004894 // Check if the string is an ASCII string.
lrn@chromium.org303ada72010-10-27 09:33:13 +00004895 Object* result;
ulan@chromium.org56c14af2012-09-20 12:51:09 +00004896 int length = string.length();
4897 const uc16* start = string.start();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004898
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00004899 if (String::IsOneByte(start, length)) {
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00004900 MaybeObject* maybe_result = AllocateRawOneByteString(length, pretenure);
ulan@chromium.org56c14af2012-09-20 12:51:09 +00004901 if (!maybe_result->ToObject(&result)) return maybe_result;
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004902 CopyChars(SeqOneByteString::cast(result)->GetChars(), start, length);
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00004903 } else { // It's not a one byte string.
ulan@chromium.org56c14af2012-09-20 12:51:09 +00004904 MaybeObject* maybe_result = AllocateRawTwoByteString(length, pretenure);
4905 if (!maybe_result->ToObject(&result)) return maybe_result;
4906 CopyChars(SeqTwoByteString::cast(result)->GetChars(), start, length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004907 }
4908 return result;
4909}
4910
4911
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004912Map* Heap::InternalizedStringMapForString(String* string) {
4913 // If the string is in new space it cannot be used as internalized.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004914 if (InNewSpace(string)) return NULL;
4915
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004916 // Find the corresponding internalized string map for strings.
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00004917 switch (string->map()->instance_type()) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004918 case STRING_TYPE: return internalized_string_map();
4919 case ASCII_STRING_TYPE: return ascii_internalized_string_map();
4920 case CONS_STRING_TYPE: return cons_internalized_string_map();
4921 case CONS_ASCII_STRING_TYPE: return cons_ascii_internalized_string_map();
4922 case EXTERNAL_STRING_TYPE: return external_internalized_string_map();
4923 case EXTERNAL_ASCII_STRING_TYPE:
4924 return external_ascii_internalized_string_map();
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00004925 case EXTERNAL_STRING_WITH_ASCII_DATA_TYPE:
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004926 return external_internalized_string_with_ascii_data_map();
4927 case SHORT_EXTERNAL_STRING_TYPE:
4928 return short_external_internalized_string_map();
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00004929 case SHORT_EXTERNAL_ASCII_STRING_TYPE:
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004930 return short_external_ascii_internalized_string_map();
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00004931 case SHORT_EXTERNAL_STRING_WITH_ASCII_DATA_TYPE:
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004932 return short_external_internalized_string_with_ascii_data_map();
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +00004933 default: return NULL; // No match found.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00004934 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004935}
4936
4937
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004938static inline void WriteOneByteData(Vector<const char> vector,
4939 uint8_t* chars,
4940 int len) {
4941 // Only works for ascii.
4942 ASSERT(vector.length() == len);
4943 memcpy(chars, vector.start(), len);
4944}
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004945
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004946static inline void WriteTwoByteData(Vector<const char> vector,
4947 uint16_t* chars,
4948 int len) {
4949 const uint8_t* stream = reinterpret_cast<const uint8_t*>(vector.start());
4950 unsigned stream_length = vector.length();
4951 while (stream_length != 0) {
4952 unsigned consumed = 0;
4953 uint32_t c = unibrow::Utf8::ValueOf(stream, stream_length, &consumed);
4954 ASSERT(c != unibrow::Utf8::kBadChar);
4955 ASSERT(consumed <= stream_length);
4956 stream_length -= consumed;
4957 stream += consumed;
4958 if (c > unibrow::Utf16::kMaxNonSurrogateCharCode) {
4959 len -= 2;
4960 if (len < 0) break;
4961 *chars++ = unibrow::Utf16::LeadSurrogate(c);
4962 *chars++ = unibrow::Utf16::TrailSurrogate(c);
4963 } else {
4964 len -= 1;
4965 if (len < 0) break;
4966 *chars++ = c;
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004967 }
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004968 }
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004969 ASSERT(stream_length == 0);
4970 ASSERT(len == 0);
4971}
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004972
4973
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004974static inline void WriteOneByteData(String* s, uint8_t* chars, int len) {
4975 ASSERT(s->length() == len);
4976 String::WriteToFlat(s, chars, 0, len);
4977}
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004978
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00004979static inline void WriteTwoByteData(String* s, uint16_t* chars, int len) {
4980 ASSERT(s->length() == len);
4981 String::WriteToFlat(s, chars, 0, len);
4982}
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004983
4984
4985template<bool is_one_byte, typename T>
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004986MaybeObject* Heap::AllocateInternalizedStringImpl(
4987 T t, int chars, uint32_t hash_field) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00004988 ASSERT(chars >= 0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004989 // Compute map and object size.
4990 int size;
4991 Map* map;
4992
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00004993 if (is_one_byte) {
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004994 if (chars > SeqOneByteString::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00004995 return Failure::OutOfMemoryException(0x9);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00004996 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00004997 map = ascii_internalized_string_map();
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00004998 size = SeqOneByteString::SizeFor(chars);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00004999 } else {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005000 if (chars > SeqTwoByteString::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005001 return Failure::OutOfMemoryException(0xa);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005002 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005003 map = internalized_string_map();
ager@chromium.org7c537e22008-10-16 08:43:32 +00005004 size = SeqTwoByteString::SizeFor(chars);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005005 }
5006
5007 // Allocate string.
lrn@chromium.org303ada72010-10-27 09:33:13 +00005008 Object* result;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005009 { MaybeObject* maybe_result = (size > Page::kMaxNonCodeHeapObjectSize)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005010 ? lo_space_->AllocateRaw(size, NOT_EXECUTABLE)
lrn@chromium.org303ada72010-10-27 09:33:13 +00005011 : old_data_space_->AllocateRaw(size);
5012 if (!maybe_result->ToObject(&result)) return maybe_result;
5013 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005014
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005015 reinterpret_cast<HeapObject*>(result)->set_map_no_write_barrier(map);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005016 // Set length and hash fields of the allocated string.
ager@chromium.org870a0b62008-11-04 11:43:05 +00005017 String* answer = String::cast(result);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005018 answer->set_length(chars);
5019 answer->set_hash_field(hash_field);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005020
ager@chromium.org870a0b62008-11-04 11:43:05 +00005021 ASSERT_EQ(size, answer->Size());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005022
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00005023 if (is_one_byte) {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00005024 WriteOneByteData(t, SeqOneByteString::cast(answer)->GetChars(), chars);
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00005025 } else {
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00005026 WriteTwoByteData(t, SeqTwoByteString::cast(answer)->GetChars(), chars);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005027 }
ager@chromium.org870a0b62008-11-04 11:43:05 +00005028 return answer;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005029}
5030
5031
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00005032// Need explicit instantiations.
5033template
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005034MaybeObject* Heap::AllocateInternalizedStringImpl<true>(String*, int, uint32_t);
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00005035template
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005036MaybeObject* Heap::AllocateInternalizedStringImpl<false>(
5037 String*, int, uint32_t);
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00005038template
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005039MaybeObject* Heap::AllocateInternalizedStringImpl<false>(
5040 Vector<const char>, int, uint32_t);
yangguo@chromium.orga6bbcc82012-12-21 12:35:02 +00005041
5042
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00005043MaybeObject* Heap::AllocateRawOneByteString(int length,
5044 PretenureFlag pretenure) {
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00005045 if (length < 0 || length > SeqOneByteString::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005046 return Failure::OutOfMemoryException(0xb);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005047 }
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00005048
yangguo@chromium.orgfb377212012-11-16 14:43:43 +00005049 int size = SeqOneByteString::SizeFor(length);
5050 ASSERT(size <= SeqOneByteString::kMaxSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005051
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005052 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
5053 AllocationSpace retry_space = OLD_DATA_SPACE;
5054
ager@chromium.org5aa501c2009-06-23 07:57:28 +00005055 if (space == NEW_SPACE) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005056 if (size > kMaxObjectSizeInNewSpace) {
5057 // Allocate in large object space, retry space will be ignored.
5058 space = LO_SPACE;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005059 } else if (size > Page::kMaxNonCodeHeapObjectSize) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005060 // Allocate in new space, retry in large object space.
5061 retry_space = LO_SPACE;
5062 }
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005063 } else if (space == OLD_DATA_SPACE &&
5064 size > Page::kMaxNonCodeHeapObjectSize) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005065 space = LO_SPACE;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00005066 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00005067 Object* result;
5068 { MaybeObject* maybe_result = AllocateRaw(size, space, retry_space);
5069 if (!maybe_result->ToObject(&result)) return maybe_result;
5070 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005071
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005072 // Partially initialize the object.
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005073 HeapObject::cast(result)->set_map_no_write_barrier(ascii_string_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005074 String::cast(result)->set_length(length);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005075 String::cast(result)->set_hash_field(String::kEmptyHashField);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005076 ASSERT_EQ(size, HeapObject::cast(result)->Size());
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +00005077
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005078#ifndef ENABLE_LATIN_1
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00005079#ifdef VERIFY_HEAP
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +00005080 if (FLAG_verify_heap) {
5081 // Initialize string's content to ensure ASCII-ness (character range 0-127)
5082 // as required when verifying the heap.
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005083 uint8_t* dest = SeqOneByteString::cast(result)->GetChars();
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +00005084 memset(dest, 0x0F, length * kCharSize);
5085 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00005086#endif
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005087#endif
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +00005088
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005089 return result;
5090}
5091
5092
lrn@chromium.org303ada72010-10-27 09:33:13 +00005093MaybeObject* Heap::AllocateRawTwoByteString(int length,
5094 PretenureFlag pretenure) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005095 if (length < 0 || length > SeqTwoByteString::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005096 return Failure::OutOfMemoryException(0xc);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00005097 }
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005098 int size = SeqTwoByteString::SizeFor(length);
5099 ASSERT(size <= SeqTwoByteString::kMaxSize);
5100 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
5101 AllocationSpace retry_space = OLD_DATA_SPACE;
5102
5103 if (space == NEW_SPACE) {
5104 if (size > kMaxObjectSizeInNewSpace) {
5105 // Allocate in large object space, retry space will be ignored.
5106 space = LO_SPACE;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005107 } else if (size > Page::kMaxNonCodeHeapObjectSize) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005108 // Allocate in new space, retry in large object space.
5109 retry_space = LO_SPACE;
5110 }
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005111 } else if (space == OLD_DATA_SPACE &&
5112 size > Page::kMaxNonCodeHeapObjectSize) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005113 space = LO_SPACE;
5114 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00005115 Object* result;
5116 { MaybeObject* maybe_result = AllocateRaw(size, space, retry_space);
5117 if (!maybe_result->ToObject(&result)) return maybe_result;
5118 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005119
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005120 // Partially initialize the object.
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005121 HeapObject::cast(result)->set_map_no_write_barrier(string_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005122 String::cast(result)->set_length(length);
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005123 String::cast(result)->set_hash_field(String::kEmptyHashField);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005124 ASSERT_EQ(size, HeapObject::cast(result)->Size());
5125 return result;
5126}
5127
5128
danno@chromium.orgfa458e42012-02-01 10:48:36 +00005129MaybeObject* Heap::AllocateJSArray(
5130 ElementsKind elements_kind,
5131 PretenureFlag pretenure) {
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005132 Context* native_context = isolate()->context()->native_context();
5133 JSFunction* array_function = native_context->array_function();
danno@chromium.orgfa458e42012-02-01 10:48:36 +00005134 Map* map = array_function->initial_map();
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005135 Object* maybe_map_array = native_context->js_array_maps();
svenpanne@chromium.org830d30c2012-05-29 13:20:14 +00005136 if (!maybe_map_array->IsUndefined()) {
5137 Object* maybe_transitioned_map =
5138 FixedArray::cast(maybe_map_array)->get(elements_kind);
5139 if (!maybe_transitioned_map->IsUndefined()) {
5140 map = Map::cast(maybe_transitioned_map);
5141 }
danno@chromium.orgfa458e42012-02-01 10:48:36 +00005142 }
5143
5144 return AllocateJSObjectFromMap(map, pretenure);
5145}
5146
5147
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005148MaybeObject* Heap::AllocateJSArrayWithAllocationSite(
5149 ElementsKind elements_kind,
5150 Handle<Object> allocation_site_info_payload) {
5151 Context* native_context = isolate()->context()->native_context();
5152 JSFunction* array_function = native_context->array_function();
5153 Map* map = array_function->initial_map();
5154 Object* maybe_map_array = native_context->js_array_maps();
5155 if (!maybe_map_array->IsUndefined()) {
5156 Object* maybe_transitioned_map =
5157 FixedArray::cast(maybe_map_array)->get(elements_kind);
5158 if (!maybe_transitioned_map->IsUndefined()) {
5159 map = Map::cast(maybe_transitioned_map);
5160 }
5161 }
5162 return AllocateJSObjectFromMapWithAllocationSite(map,
5163 allocation_site_info_payload);
5164}
5165
5166
lrn@chromium.org303ada72010-10-27 09:33:13 +00005167MaybeObject* Heap::AllocateEmptyFixedArray() {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005168 int size = FixedArray::SizeFor(0);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005169 Object* result;
5170 { MaybeObject* maybe_result =
5171 AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
5172 if (!maybe_result->ToObject(&result)) return maybe_result;
5173 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005174 // Initialize the object.
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005175 reinterpret_cast<FixedArray*>(result)->set_map_no_write_barrier(
5176 fixed_array_map());
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005177 reinterpret_cast<FixedArray*>(result)->set_length(0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005178 return result;
5179}
5180
5181
lrn@chromium.org303ada72010-10-27 09:33:13 +00005182MaybeObject* Heap::AllocateRawFixedArray(int length) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005183 if (length < 0 || length > FixedArray::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005184 return Failure::OutOfMemoryException(0xd);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005185 }
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00005186 ASSERT(length > 0);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00005187 // Use the general function if we're forced to always allocate.
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00005188 if (always_allocate()) return AllocateFixedArray(length, TENURED);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005189 // Allocate the raw data for a fixed array.
5190 int size = FixedArray::SizeFor(length);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00005191 return size <= kMaxObjectSizeInNewSpace
5192 ? new_space_.AllocateRaw(size)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005193 : lo_space_->AllocateRaw(size, NOT_EXECUTABLE);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005194}
5195
5196
lrn@chromium.org303ada72010-10-27 09:33:13 +00005197MaybeObject* Heap::CopyFixedArrayWithMap(FixedArray* src, Map* map) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005198 int len = src->length();
lrn@chromium.org303ada72010-10-27 09:33:13 +00005199 Object* obj;
5200 { MaybeObject* maybe_obj = AllocateRawFixedArray(len);
5201 if (!maybe_obj->ToObject(&obj)) return maybe_obj;
5202 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005203 if (InNewSpace(obj)) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005204 HeapObject* dst = HeapObject::cast(obj);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005205 dst->set_map_no_write_barrier(map);
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +00005206 CopyBlock(dst->address() + kPointerSize,
5207 src->address() + kPointerSize,
5208 FixedArray::SizeFor(len) - kPointerSize);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005209 return obj;
5210 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005211 HeapObject::cast(obj)->set_map_no_write_barrier(map);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005212 FixedArray* result = FixedArray::cast(obj);
5213 result->set_length(len);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005214
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005215 // Copy the content
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005216 AssertNoAllocation no_gc;
5217 WriteBarrierMode mode = result->GetWriteBarrierMode(no_gc);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005218 for (int i = 0; i < len; i++) result->set(i, src->get(i), mode);
5219 return result;
5220}
5221
5222
ricow@chromium.org2c99e282011-07-28 09:15:17 +00005223MaybeObject* Heap::CopyFixedDoubleArrayWithMap(FixedDoubleArray* src,
5224 Map* map) {
5225 int len = src->length();
5226 Object* obj;
5227 { MaybeObject* maybe_obj = AllocateRawFixedDoubleArray(len, NOT_TENURED);
5228 if (!maybe_obj->ToObject(&obj)) return maybe_obj;
5229 }
5230 HeapObject* dst = HeapObject::cast(obj);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005231 dst->set_map_no_write_barrier(map);
ricow@chromium.org2c99e282011-07-28 09:15:17 +00005232 CopyBlock(
5233 dst->address() + FixedDoubleArray::kLengthOffset,
5234 src->address() + FixedDoubleArray::kLengthOffset,
5235 FixedDoubleArray::SizeFor(len) - FixedDoubleArray::kLengthOffset);
5236 return obj;
5237}
5238
5239
lrn@chromium.org303ada72010-10-27 09:33:13 +00005240MaybeObject* Heap::AllocateFixedArray(int length) {
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00005241 ASSERT(length >= 0);
ager@chromium.org32912102009-01-16 10:38:43 +00005242 if (length == 0) return empty_fixed_array();
lrn@chromium.org303ada72010-10-27 09:33:13 +00005243 Object* result;
5244 { MaybeObject* maybe_result = AllocateRawFixedArray(length);
5245 if (!maybe_result->ToObject(&result)) return maybe_result;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005246 }
lrn@chromium.org303ada72010-10-27 09:33:13 +00005247 // Initialize header.
5248 FixedArray* array = reinterpret_cast<FixedArray*>(result);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005249 array->set_map_no_write_barrier(fixed_array_map());
lrn@chromium.org303ada72010-10-27 09:33:13 +00005250 array->set_length(length);
5251 // Initialize body.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005252 ASSERT(!InNewSpace(undefined_value()));
lrn@chromium.org303ada72010-10-27 09:33:13 +00005253 MemsetPointer(array->data_start(), undefined_value(), length);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005254 return result;
5255}
5256
5257
lrn@chromium.org303ada72010-10-27 09:33:13 +00005258MaybeObject* Heap::AllocateRawFixedArray(int length, PretenureFlag pretenure) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005259 if (length < 0 || length > FixedArray::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005260 return Failure::OutOfMemoryException(0xe);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005261 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005262
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005263 AllocationSpace space =
5264 (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005265 int size = FixedArray::SizeFor(length);
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005266 if (space == NEW_SPACE && size > kMaxObjectSizeInNewSpace) {
5267 // Too big for new space.
5268 space = LO_SPACE;
5269 } else if (space == OLD_POINTER_SPACE &&
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005270 size > Page::kMaxNonCodeHeapObjectSize) {
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005271 // Too big for old pointer space.
5272 space = LO_SPACE;
5273 }
5274
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005275 AllocationSpace retry_space =
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005276 (size <= Page::kMaxNonCodeHeapObjectSize) ? OLD_POINTER_SPACE : LO_SPACE;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005277
5278 return AllocateRaw(size, space, retry_space);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005279}
5280
5281
lrn@chromium.org303ada72010-10-27 09:33:13 +00005282MUST_USE_RESULT static MaybeObject* AllocateFixedArrayWithFiller(
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005283 Heap* heap,
lrn@chromium.org303ada72010-10-27 09:33:13 +00005284 int length,
5285 PretenureFlag pretenure,
5286 Object* filler) {
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005287 ASSERT(length >= 0);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005288 ASSERT(heap->empty_fixed_array()->IsFixedArray());
5289 if (length == 0) return heap->empty_fixed_array();
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005290
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005291 ASSERT(!heap->InNewSpace(filler));
lrn@chromium.org303ada72010-10-27 09:33:13 +00005292 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005293 { MaybeObject* maybe_result = heap->AllocateRawFixedArray(length, pretenure);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005294 if (!maybe_result->ToObject(&result)) return maybe_result;
5295 }
fschneider@chromium.org0c20e672010-01-14 15:28:53 +00005296
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005297 HeapObject::cast(result)->set_map_no_write_barrier(heap->fixed_array_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005298 FixedArray* array = FixedArray::cast(result);
5299 array->set_length(length);
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005300 MemsetPointer(array->data_start(), filler, length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005301 return array;
5302}
5303
5304
lrn@chromium.org303ada72010-10-27 09:33:13 +00005305MaybeObject* Heap::AllocateFixedArray(int length, PretenureFlag pretenure) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005306 return AllocateFixedArrayWithFiller(this,
5307 length,
5308 pretenure,
5309 undefined_value());
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005310}
5311
5312
lrn@chromium.org303ada72010-10-27 09:33:13 +00005313MaybeObject* Heap::AllocateFixedArrayWithHoles(int length,
5314 PretenureFlag pretenure) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005315 return AllocateFixedArrayWithFiller(this,
5316 length,
5317 pretenure,
5318 the_hole_value());
ricow@chromium.orgc9c80822010-04-21 08:22:37 +00005319}
5320
5321
lrn@chromium.org303ada72010-10-27 09:33:13 +00005322MaybeObject* Heap::AllocateUninitializedFixedArray(int length) {
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005323 if (length == 0) return empty_fixed_array();
5324
lrn@chromium.org303ada72010-10-27 09:33:13 +00005325 Object* obj;
5326 { MaybeObject* maybe_obj = AllocateRawFixedArray(length);
5327 if (!maybe_obj->ToObject(&obj)) return maybe_obj;
5328 }
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005329
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005330 reinterpret_cast<FixedArray*>(obj)->set_map_no_write_barrier(
5331 fixed_array_map());
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005332 FixedArray::cast(obj)->set_length(length);
5333 return obj;
5334}
5335
5336
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005337MaybeObject* Heap::AllocateEmptyFixedDoubleArray() {
5338 int size = FixedDoubleArray::SizeFor(0);
5339 Object* result;
5340 { MaybeObject* maybe_result =
5341 AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
5342 if (!maybe_result->ToObject(&result)) return maybe_result;
5343 }
5344 // Initialize the object.
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005345 reinterpret_cast<FixedDoubleArray*>(result)->set_map_no_write_barrier(
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005346 fixed_double_array_map());
5347 reinterpret_cast<FixedDoubleArray*>(result)->set_length(0);
5348 return result;
5349}
5350
5351
5352MaybeObject* Heap::AllocateUninitializedFixedDoubleArray(
5353 int length,
5354 PretenureFlag pretenure) {
ulan@chromium.org65a89c22012-02-14 11:46:07 +00005355 if (length == 0) return empty_fixed_array();
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005356
danno@chromium.orgfa458e42012-02-01 10:48:36 +00005357 Object* elements_object;
5358 MaybeObject* maybe_obj = AllocateRawFixedDoubleArray(length, pretenure);
5359 if (!maybe_obj->ToObject(&elements_object)) return maybe_obj;
5360 FixedDoubleArray* elements =
5361 reinterpret_cast<FixedDoubleArray*>(elements_object);
5362
5363 elements->set_map_no_write_barrier(fixed_double_array_map());
5364 elements->set_length(length);
5365 return elements;
5366}
5367
5368
5369MaybeObject* Heap::AllocateFixedDoubleArrayWithHoles(
5370 int length,
5371 PretenureFlag pretenure) {
ulan@chromium.org65a89c22012-02-14 11:46:07 +00005372 if (length == 0) return empty_fixed_array();
danno@chromium.orgfa458e42012-02-01 10:48:36 +00005373
5374 Object* elements_object;
5375 MaybeObject* maybe_obj = AllocateRawFixedDoubleArray(length, pretenure);
5376 if (!maybe_obj->ToObject(&elements_object)) return maybe_obj;
5377 FixedDoubleArray* elements =
5378 reinterpret_cast<FixedDoubleArray*>(elements_object);
5379
5380 for (int i = 0; i < length; ++i) {
5381 elements->set_the_hole(i);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005382 }
5383
danno@chromium.orgfa458e42012-02-01 10:48:36 +00005384 elements->set_map_no_write_barrier(fixed_double_array_map());
5385 elements->set_length(length);
5386 return elements;
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005387}
5388
5389
5390MaybeObject* Heap::AllocateRawFixedDoubleArray(int length,
5391 PretenureFlag pretenure) {
5392 if (length < 0 || length > FixedDoubleArray::kMaxLength) {
jkummerow@chromium.org59297c72013-01-09 16:32:23 +00005393 return Failure::OutOfMemoryException(0xf);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005394 }
5395
5396 AllocationSpace space =
5397 (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
5398 int size = FixedDoubleArray::SizeFor(length);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00005399
5400#ifndef V8_HOST_ARCH_64_BIT
5401 size += kPointerSize;
5402#endif
5403
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005404 if (space == NEW_SPACE && size > kMaxObjectSizeInNewSpace) {
5405 // Too big for new space.
5406 space = LO_SPACE;
5407 } else if (space == OLD_DATA_SPACE &&
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005408 size > Page::kMaxNonCodeHeapObjectSize) {
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005409 // Too big for old data space.
5410 space = LO_SPACE;
5411 }
5412
5413 AllocationSpace retry_space =
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005414 (size <= Page::kMaxNonCodeHeapObjectSize) ? OLD_DATA_SPACE : LO_SPACE;
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005415
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00005416 HeapObject* object;
5417 { MaybeObject* maybe_object = AllocateRaw(size, space, retry_space);
5418 if (!maybe_object->To<HeapObject>(&object)) return maybe_object;
5419 }
5420
5421 return EnsureDoubleAligned(this, object, size);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005422}
5423
5424
lrn@chromium.org303ada72010-10-27 09:33:13 +00005425MaybeObject* Heap::AllocateHashTable(int length, PretenureFlag pretenure) {
5426 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005427 { MaybeObject* maybe_result = AllocateFixedArray(length, pretenure);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005428 if (!maybe_result->ToObject(&result)) return maybe_result;
5429 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005430 reinterpret_cast<HeapObject*>(result)->set_map_no_write_barrier(
5431 hash_table_map());
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00005432 ASSERT(result->IsHashTable());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005433 return result;
5434}
5435
5436
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005437MaybeObject* Heap::AllocateSymbol(PretenureFlag pretenure) {
5438 // Statically ensure that it is safe to allocate symbols in paged spaces.
5439 STATIC_ASSERT(Symbol::kSize <= Page::kNonCodeObjectAreaSize);
5440 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
5441
5442 Object* result;
5443 MaybeObject* maybe = AllocateRaw(Symbol::kSize, space, OLD_DATA_SPACE);
5444 if (!maybe->ToObject(&result)) return maybe;
5445
5446 HeapObject::cast(result)->set_map_no_write_barrier(symbol_map());
5447
5448 // Generate a random hash value.
5449 int hash;
5450 int attempts = 0;
5451 do {
5452 hash = V8::RandomPrivate(isolate()) & Name::kHashBitMask;
5453 attempts++;
5454 } while (hash == 0 && attempts < 30);
5455 if (hash == 0) hash = 1; // never return 0
5456
5457 Symbol::cast(result)->set_hash_field(
5458 Name::kIsNotArrayIndexMask | (hash << Name::kHashShift));
5459
5460 ASSERT(result->IsSymbol());
5461 return result;
5462}
5463
5464
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005465MaybeObject* Heap::AllocateNativeContext() {
lrn@chromium.org303ada72010-10-27 09:33:13 +00005466 Object* result;
5467 { MaybeObject* maybe_result =
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005468 AllocateFixedArray(Context::NATIVE_CONTEXT_SLOTS);
5469 if (!maybe_result->ToObject(&result)) return maybe_result;
5470 }
5471 Context* context = reinterpret_cast<Context*>(result);
5472 context->set_map_no_write_barrier(native_context_map());
5473 context->set_js_array_maps(undefined_value());
5474 ASSERT(context->IsNativeContext());
5475 ASSERT(result->IsContext());
5476 return result;
5477}
5478
5479
5480MaybeObject* Heap::AllocateGlobalContext(JSFunction* function,
5481 ScopeInfo* scope_info) {
5482 Object* result;
5483 { MaybeObject* maybe_result =
5484 AllocateFixedArray(scope_info->ContextLength(), TENURED);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005485 if (!maybe_result->ToObject(&result)) return maybe_result;
5486 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005487 Context* context = reinterpret_cast<Context*>(result);
danno@chromium.orgeb831462012-08-24 11:57:08 +00005488 context->set_map_no_write_barrier(global_context_map());
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005489 context->set_closure(function);
yangguo@chromium.org355cfd12012-08-29 15:32:24 +00005490 context->set_previous(function->context());
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005491 context->set_extension(scope_info);
yangguo@chromium.org355cfd12012-08-29 15:32:24 +00005492 context->set_global_object(function->context()->global_object());
danno@chromium.orgeb831462012-08-24 11:57:08 +00005493 ASSERT(context->IsGlobalContext());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005494 ASSERT(result->IsContext());
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005495 return context;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005496}
5497
5498
danno@chromium.org81cac2b2012-07-10 11:28:27 +00005499MaybeObject* Heap::AllocateModuleContext(ScopeInfo* scope_info) {
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00005500 Object* result;
5501 { MaybeObject* maybe_result =
danno@chromium.org81cac2b2012-07-10 11:28:27 +00005502 AllocateFixedArray(scope_info->ContextLength(), TENURED);
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00005503 if (!maybe_result->ToObject(&result)) return maybe_result;
5504 }
5505 Context* context = reinterpret_cast<Context*>(result);
5506 context->set_map_no_write_barrier(module_context_map());
ulan@chromium.org8e8d8822012-11-23 14:36:46 +00005507 // Instance link will be set later.
danno@chromium.org81cac2b2012-07-10 11:28:27 +00005508 context->set_extension(Smi::FromInt(0));
erik.corry@gmail.comed49e962012-04-17 11:57:53 +00005509 return context;
5510}
5511
5512
lrn@chromium.org303ada72010-10-27 09:33:13 +00005513MaybeObject* Heap::AllocateFunctionContext(int length, JSFunction* function) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005514 ASSERT(length >= Context::MIN_CONTEXT_SLOTS);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005515 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005516 { MaybeObject* maybe_result = AllocateFixedArray(length);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005517 if (!maybe_result->ToObject(&result)) return maybe_result;
5518 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005519 Context* context = reinterpret_cast<Context*>(result);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005520 context->set_map_no_write_barrier(function_context_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005521 context->set_closure(function);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005522 context->set_previous(function->context());
danno@chromium.org81cac2b2012-07-10 11:28:27 +00005523 context->set_extension(Smi::FromInt(0));
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005524 context->set_global_object(function->context()->global_object());
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005525 return context;
5526}
5527
5528
vegorov@chromium.org3cf47312011-06-29 13:20:01 +00005529MaybeObject* Heap::AllocateCatchContext(JSFunction* function,
5530 Context* previous,
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005531 String* name,
5532 Object* thrown_object) {
5533 STATIC_ASSERT(Context::MIN_CONTEXT_SLOTS == Context::THROWN_OBJECT_INDEX);
5534 Object* result;
5535 { MaybeObject* maybe_result =
5536 AllocateFixedArray(Context::MIN_CONTEXT_SLOTS + 1);
5537 if (!maybe_result->ToObject(&result)) return maybe_result;
5538 }
5539 Context* context = reinterpret_cast<Context*>(result);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005540 context->set_map_no_write_barrier(catch_context_map());
vegorov@chromium.org3cf47312011-06-29 13:20:01 +00005541 context->set_closure(function);
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005542 context->set_previous(previous);
5543 context->set_extension(name);
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005544 context->set_global_object(previous->global_object());
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005545 context->set(Context::THROWN_OBJECT_INDEX, thrown_object);
5546 return context;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005547}
5548
5549
vegorov@chromium.org3cf47312011-06-29 13:20:01 +00005550MaybeObject* Heap::AllocateWithContext(JSFunction* function,
5551 Context* previous,
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005552 JSObject* extension) {
lrn@chromium.org303ada72010-10-27 09:33:13 +00005553 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005554 { MaybeObject* maybe_result = AllocateFixedArray(Context::MIN_CONTEXT_SLOTS);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005555 if (!maybe_result->ToObject(&result)) return maybe_result;
5556 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005557 Context* context = reinterpret_cast<Context*>(result);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005558 context->set_map_no_write_barrier(with_context_map());
vegorov@chromium.org3cf47312011-06-29 13:20:01 +00005559 context->set_closure(function);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005560 context->set_previous(previous);
5561 context->set_extension(extension);
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005562 context->set_global_object(previous->global_object());
svenpanne@chromium.org6d786c92011-06-15 10:58:27 +00005563 return context;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005564}
5565
5566
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005567MaybeObject* Heap::AllocateBlockContext(JSFunction* function,
5568 Context* previous,
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00005569 ScopeInfo* scope_info) {
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005570 Object* result;
5571 { MaybeObject* maybe_result =
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00005572 AllocateFixedArrayWithHoles(scope_info->ContextLength());
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005573 if (!maybe_result->ToObject(&result)) return maybe_result;
5574 }
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005575 Context* context = reinterpret_cast<Context*>(result);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005576 context->set_map_no_write_barrier(block_context_map());
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005577 context->set_closure(function);
5578 context->set_previous(previous);
5579 context->set_extension(scope_info);
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00005580 context->set_global_object(previous->global_object());
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005581 return context;
5582}
5583
5584
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00005585MaybeObject* Heap::AllocateScopeInfo(int length) {
5586 FixedArray* scope_info;
5587 MaybeObject* maybe_scope_info = AllocateFixedArray(length, TENURED);
5588 if (!maybe_scope_info->To(&scope_info)) return maybe_scope_info;
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00005589 scope_info->set_map_no_write_barrier(scope_info_map());
whesse@chromium.org4acdc2c2011-08-15 13:01:23 +00005590 return scope_info;
5591}
5592
5593
yangguo@chromium.orgeeb44b62012-11-13 13:56:09 +00005594MaybeObject* Heap::AllocateExternal(void* value) {
5595 Foreign* foreign;
5596 { MaybeObject* maybe_result = AllocateForeign(static_cast<Address>(value));
5597 if (!maybe_result->To(&foreign)) return maybe_result;
5598 }
5599 JSObject* external;
5600 { MaybeObject* maybe_result = AllocateJSObjectFromMap(external_map());
5601 if (!maybe_result->To(&external)) return maybe_result;
5602 }
5603 external->SetInternalField(0, foreign);
5604 return external;
5605}
5606
5607
lrn@chromium.org303ada72010-10-27 09:33:13 +00005608MaybeObject* Heap::AllocateStruct(InstanceType type) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005609 Map* map;
5610 switch (type) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005611#define MAKE_CASE(NAME, Name, name) \
5612 case NAME##_TYPE: map = name##_map(); break;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005613STRUCT_LIST(MAKE_CASE)
5614#undef MAKE_CASE
5615 default:
5616 UNREACHABLE();
5617 return Failure::InternalError();
5618 }
5619 int size = map->instance_size();
5620 AllocationSpace space =
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00005621 (size > Page::kMaxNonCodeHeapObjectSize) ? LO_SPACE : OLD_POINTER_SPACE;
lrn@chromium.org303ada72010-10-27 09:33:13 +00005622 Object* result;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005623 { MaybeObject* maybe_result = Allocate(map, space);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005624 if (!maybe_result->ToObject(&result)) return maybe_result;
5625 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005626 Struct::cast(result)->InitializeBody(size);
5627 return result;
5628}
5629
5630
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005631bool Heap::IsHeapIterable() {
5632 return (!old_pointer_space()->was_swept_conservatively() &&
5633 !old_data_space()->was_swept_conservatively());
5634}
5635
5636
5637void Heap::EnsureHeapIsIterable() {
5638 ASSERT(IsAllocationAllowed());
5639 if (!IsHeapIterable()) {
rossberg@chromium.org994edf62012-02-06 10:12:55 +00005640 CollectAllGarbage(kMakeHeapIterableMask, "Heap::EnsureHeapIsIterable");
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005641 }
5642 ASSERT(IsHeapIterable());
5643}
5644
5645
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005646void Heap::AdvanceIdleIncrementalMarking(intptr_t step_size) {
fschneider@chromium.org7d10be52012-04-10 12:30:14 +00005647 incremental_marking()->Step(step_size,
5648 IncrementalMarking::NO_GC_VIA_STACK_GUARD);
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005649
5650 if (incremental_marking()->IsComplete()) {
5651 bool uncommit = false;
5652 if (gc_count_at_last_idle_gc_ == gc_count_) {
5653 // No GC since the last full GC, the mutator is probably not active.
5654 isolate_->compilation_cache()->Clear();
5655 uncommit = true;
5656 }
5657 CollectAllGarbage(kNoGCFlags, "idle notification: finalize incremental");
5658 gc_count_at_last_idle_gc_ = gc_count_;
5659 if (uncommit) {
5660 new_space_.Shrink();
5661 UncommitFromSpace();
5662 }
5663 }
5664}
5665
5666
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005667bool Heap::IdleNotification(int hint) {
yangguo@chromium.orgde0db002012-06-22 13:44:28 +00005668 // Hints greater than this value indicate that
5669 // the embedder is requesting a lot of GC work.
danno@chromium.org88aa0582012-03-23 15:11:57 +00005670 const int kMaxHint = 1000;
yangguo@chromium.orgde0db002012-06-22 13:44:28 +00005671 // Minimal hint that allows to do full GC.
5672 const int kMinHintForFullGC = 100;
danno@chromium.org2c26cb12012-05-03 09:06:43 +00005673 intptr_t size_factor = Min(Max(hint, 20), kMaxHint) / 4;
5674 // The size factor is in range [5..250]. The numbers here are chosen from
5675 // experiments. If you changes them, make sure to test with
5676 // chrome/performance_ui_tests --gtest_filter="GeneralMixMemoryTest.*
verwaest@chromium.org33e09c82012-10-10 17:07:22 +00005677 intptr_t step_size =
5678 size_factor * IncrementalMarking::kAllocatedThreshold;
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005679
5680 if (contexts_disposed_ > 0) {
danno@chromium.org88aa0582012-03-23 15:11:57 +00005681 if (hint >= kMaxHint) {
5682 // The embedder is requesting a lot of GC work after context disposal,
5683 // we age inline caches so that they don't keep objects from
5684 // the old context alive.
5685 AgeInlineCaches();
5686 }
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005687 int mark_sweep_time = Min(TimeMarkSweepWouldTakeInMs(), 1000);
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +00005688 if (hint >= mark_sweep_time && !FLAG_expose_gc &&
5689 incremental_marking()->IsStopped()) {
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005690 HistogramTimerScope scope(isolate_->counters()->gc_context());
5691 CollectAllGarbage(kReduceMemoryFootprintMask,
5692 "idle notification: contexts disposed");
5693 } else {
5694 AdvanceIdleIncrementalMarking(step_size);
5695 contexts_disposed_ = 0;
5696 }
danno@chromium.org2c26cb12012-05-03 09:06:43 +00005697 // After context disposal there is likely a lot of garbage remaining, reset
5698 // the idle notification counters in order to trigger more incremental GCs
5699 // on subsequent idle notifications.
5700 StartIdleRound();
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005701 return false;
5702 }
5703
svenpanne@chromium.org83130cf2012-11-30 10:13:25 +00005704 if (!FLAG_incremental_marking || FLAG_expose_gc || Serializer::enabled()) {
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005705 return IdleGlobalGC();
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005706 }
5707
5708 // By doing small chunks of GC work in each IdleNotification,
5709 // perform a round of incremental GCs and after that wait until
5710 // the mutator creates enough garbage to justify a new round.
5711 // An incremental GC progresses as follows:
5712 // 1. many incremental marking steps,
5713 // 2. one old space mark-sweep-compact,
5714 // 3. many lazy sweep steps.
5715 // Use mark-sweep-compact events to count incremental GCs in a round.
5716
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005717 if (incremental_marking()->IsStopped()) {
mstarzinger@chromium.orge3b8d0f2013-02-01 09:06:41 +00005718 if (!mark_compact_collector()->AreSweeperThreadsActivated() &&
5719 !IsSweepingComplete() &&
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005720 !AdvanceSweepers(static_cast<int>(step_size))) {
5721 return false;
5722 }
5723 }
5724
5725 if (mark_sweeps_since_idle_round_started_ >= kMaxMarkSweepsInIdleRound) {
5726 if (EnoughGarbageSinceLastIdleRound()) {
5727 StartIdleRound();
5728 } else {
5729 return true;
5730 }
5731 }
5732
5733 int new_mark_sweeps = ms_count_ - ms_count_at_last_idle_notification_;
5734 mark_sweeps_since_idle_round_started_ += new_mark_sweeps;
5735 ms_count_at_last_idle_notification_ = ms_count_;
5736
yangguo@chromium.orgde0db002012-06-22 13:44:28 +00005737 int remaining_mark_sweeps = kMaxMarkSweepsInIdleRound -
5738 mark_sweeps_since_idle_round_started_;
5739
5740 if (remaining_mark_sweeps <= 0) {
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005741 FinishIdleRound();
5742 return true;
5743 }
5744
5745 if (incremental_marking()->IsStopped()) {
yangguo@chromium.orgde0db002012-06-22 13:44:28 +00005746 // If there are no more than two GCs left in this idle round and we are
5747 // allowed to do a full GC, then make those GCs full in order to compact
5748 // the code space.
5749 // TODO(ulan): Once we enable code compaction for incremental marking,
5750 // we can get rid of this special case and always start incremental marking.
5751 if (remaining_mark_sweeps <= 2 && hint >= kMinHintForFullGC) {
5752 CollectAllGarbage(kReduceMemoryFootprintMask,
5753 "idle notification: finalize idle round");
5754 } else {
5755 incremental_marking()->Start();
5756 }
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005757 }
yangguo@chromium.orgde0db002012-06-22 13:44:28 +00005758 if (!incremental_marking()->IsStopped()) {
5759 AdvanceIdleIncrementalMarking(step_size);
5760 }
svenpanne@chromium.orgecb9dd62011-12-01 08:22:35 +00005761 return false;
5762}
5763
5764
5765bool Heap::IdleGlobalGC() {
ager@chromium.orga1645e22009-09-09 19:27:10 +00005766 static const int kIdlesBeforeScavenge = 4;
5767 static const int kIdlesBeforeMarkSweep = 7;
5768 static const int kIdlesBeforeMarkCompact = 8;
ager@chromium.org5f0c45f2010-12-17 08:51:21 +00005769 static const int kMaxIdleCount = kIdlesBeforeMarkCompact + 1;
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00005770 static const unsigned int kGCsBetweenCleanup = 4;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005771
5772 if (!last_idle_notification_gc_count_init_) {
5773 last_idle_notification_gc_count_ = gc_count_;
5774 last_idle_notification_gc_count_init_ = true;
5775 }
ager@chromium.org96c75b52009-08-26 09:13:16 +00005776
ager@chromium.orgce5e87b2010-03-10 10:24:18 +00005777 bool uncommit = true;
ager@chromium.org96c75b52009-08-26 09:13:16 +00005778 bool finished = false;
5779
ager@chromium.org5f0c45f2010-12-17 08:51:21 +00005780 // Reset the number of idle notifications received when a number of
5781 // GCs have taken place. This allows another round of cleanup based
5782 // on idle notifications if enough work has been carried out to
5783 // provoke a number of garbage collections.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005784 if (gc_count_ - last_idle_notification_gc_count_ < kGCsBetweenCleanup) {
5785 number_idle_notifications_ =
5786 Min(number_idle_notifications_ + 1, kMaxIdleCount);
ager@chromium.org96c75b52009-08-26 09:13:16 +00005787 } else {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005788 number_idle_notifications_ = 0;
5789 last_idle_notification_gc_count_ = gc_count_;
ager@chromium.org96c75b52009-08-26 09:13:16 +00005790 }
5791
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005792 if (number_idle_notifications_ == kIdlesBeforeScavenge) {
ulan@chromium.org6ff65142012-03-21 09:52:17 +00005793 CollectGarbage(NEW_SPACE, "idle notification");
ager@chromium.orga1645e22009-09-09 19:27:10 +00005794 new_space_.Shrink();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005795 last_idle_notification_gc_count_ = gc_count_;
5796 } else if (number_idle_notifications_ == kIdlesBeforeMarkSweep) {
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005797 // Before doing the mark-sweep collections we clear the
5798 // compilation cache to avoid hanging on to source code and
5799 // generated code for cached functions.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005800 isolate_->compilation_cache()->Clear();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00005801
rossberg@chromium.org994edf62012-02-06 10:12:55 +00005802 CollectAllGarbage(kReduceMemoryFootprintMask, "idle notification");
ager@chromium.orga1645e22009-09-09 19:27:10 +00005803 new_space_.Shrink();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005804 last_idle_notification_gc_count_ = gc_count_;
ager@chromium.orga1645e22009-09-09 19:27:10 +00005805
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005806 } else if (number_idle_notifications_ == kIdlesBeforeMarkCompact) {
rossberg@chromium.org994edf62012-02-06 10:12:55 +00005807 CollectAllGarbage(kReduceMemoryFootprintMask, "idle notification");
ager@chromium.orga1645e22009-09-09 19:27:10 +00005808 new_space_.Shrink();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005809 last_idle_notification_gc_count_ = gc_count_;
5810 number_idle_notifications_ = 0;
ager@chromium.orga1645e22009-09-09 19:27:10 +00005811 finished = true;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005812 } else if (number_idle_notifications_ > kIdlesBeforeMarkCompact) {
ager@chromium.org5f0c45f2010-12-17 08:51:21 +00005813 // If we have received more than kIdlesBeforeMarkCompact idle
5814 // notifications we do not perform any cleanup because we don't
5815 // expect to gain much by doing so.
5816 finished = true;
ager@chromium.org96c75b52009-08-26 09:13:16 +00005817 }
5818
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005819 if (uncommit) UncommitFromSpace();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005820
ager@chromium.org96c75b52009-08-26 09:13:16 +00005821 return finished;
5822}
5823
5824
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005825#ifdef DEBUG
5826
5827void Heap::Print() {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00005828 if (!HasBeenSetUp()) return;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005829 isolate()->PrintStack();
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00005830 AllSpaces spaces(this);
5831 for (Space* space = spaces.next(); space != NULL; space = spaces.next()) {
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00005832 space->Print();
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00005833 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005834}
5835
5836
5837void Heap::ReportCodeStatistics(const char* title) {
5838 PrintF(">>>>>> Code Stats (%s) >>>>>>\n", title);
5839 PagedSpace::ResetCodeStatistics();
5840 // We do not look for code in new space, map space, or old space. If code
5841 // somehow ends up in those spaces, we would miss it here.
5842 code_space_->CollectCodeStatistics();
5843 lo_space_->CollectCodeStatistics();
5844 PagedSpace::ReportCodeStatistics();
5845}
5846
5847
5848// This function expects that NewSpace's allocated objects histogram is
5849// populated (via a call to CollectStatistics or else as a side effect of a
5850// just-completed scavenge collection).
5851void Heap::ReportHeapStatistics(const char* title) {
5852 USE(title);
5853 PrintF(">>>>>> =============== %s (%d) =============== >>>>>>\n",
5854 title, gc_count_);
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00005855 PrintF("old_gen_promotion_limit_ %" V8_PTR_PREFIX "d\n",
5856 old_gen_promotion_limit_);
5857 PrintF("old_gen_allocation_limit_ %" V8_PTR_PREFIX "d\n",
5858 old_gen_allocation_limit_);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005859 PrintF("old_gen_limit_factor_ %d\n", old_gen_limit_factor_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005860
5861 PrintF("\n");
ulan@chromium.org09d7ab52013-02-25 15:50:35 +00005862 PrintF("Number of handles : %d\n", HandleScope::NumberOfHandles(isolate_));
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005863 isolate_->global_handles()->PrintStats();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005864 PrintF("\n");
5865
5866 PrintF("Heap statistics : ");
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00005867 isolate_->memory_allocator()->ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005868 PrintF("To space : ");
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005869 new_space_.ReportStatistics();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00005870 PrintF("Old pointer space : ");
5871 old_pointer_space_->ReportStatistics();
5872 PrintF("Old data space : ");
5873 old_data_space_->ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005874 PrintF("Code space : ");
5875 code_space_->ReportStatistics();
5876 PrintF("Map space : ");
5877 map_space_->ReportStatistics();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00005878 PrintF("Cell space : ");
5879 cell_space_->ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005880 PrintF("Large object space : ");
5881 lo_space_->ReportStatistics();
5882 PrintF(">>>>>> ========================================= >>>>>>\n");
5883}
5884
5885#endif // DEBUG
5886
5887bool Heap::Contains(HeapObject* value) {
5888 return Contains(value->address());
5889}
5890
5891
5892bool Heap::Contains(Address addr) {
5893 if (OS::IsOutsideAllocatedSpace(addr)) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00005894 return HasBeenSetUp() &&
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005895 (new_space_.ToSpaceContains(addr) ||
ager@chromium.org9258b6b2008-09-11 09:11:10 +00005896 old_pointer_space_->Contains(addr) ||
5897 old_data_space_->Contains(addr) ||
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005898 code_space_->Contains(addr) ||
5899 map_space_->Contains(addr) ||
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00005900 cell_space_->Contains(addr) ||
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005901 lo_space_->SlowContains(addr));
5902}
5903
5904
5905bool Heap::InSpace(HeapObject* value, AllocationSpace space) {
5906 return InSpace(value->address(), space);
5907}
5908
5909
5910bool Heap::InSpace(Address addr, AllocationSpace space) {
5911 if (OS::IsOutsideAllocatedSpace(addr)) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00005912 if (!HasBeenSetUp()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005913
5914 switch (space) {
5915 case NEW_SPACE:
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00005916 return new_space_.ToSpaceContains(addr);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00005917 case OLD_POINTER_SPACE:
5918 return old_pointer_space_->Contains(addr);
5919 case OLD_DATA_SPACE:
5920 return old_data_space_->Contains(addr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005921 case CODE_SPACE:
5922 return code_space_->Contains(addr);
5923 case MAP_SPACE:
5924 return map_space_->Contains(addr);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00005925 case CELL_SPACE:
5926 return cell_space_->Contains(addr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005927 case LO_SPACE:
5928 return lo_space_->SlowContains(addr);
5929 }
5930
5931 return false;
5932}
5933
5934
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00005935#ifdef VERIFY_HEAP
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005936void Heap::Verify() {
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00005937 CHECK(HasBeenSetUp());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005938
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005939 store_buffer()->Verify();
5940
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005941 VerifyPointersVisitor visitor;
ager@chromium.orgc4c92722009-11-18 14:12:51 +00005942 IterateRoots(&visitor, VISIT_ONLY_STRONG);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005943
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00005944 new_space_.Verify();
5945
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00005946 old_pointer_space_->Verify(&visitor);
5947 map_space_->Verify(&visitor);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00005948
5949 VerifyPointersVisitor no_dirty_regions_visitor;
5950 old_data_space_->Verify(&no_dirty_regions_visitor);
5951 code_space_->Verify(&no_dirty_regions_visitor);
5952 cell_space_->Verify(&no_dirty_regions_visitor);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00005953
5954 lo_space_->Verify();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005955}
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00005956#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005957
5958
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005959MaybeObject* Heap::InternalizeUtf8String(Vector<const char> string) {
5960 Object* result = NULL;
lrn@chromium.org303ada72010-10-27 09:33:13 +00005961 Object* new_table;
5962 { MaybeObject* maybe_new_table =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005963 string_table()->LookupUtf8String(string, &result);
lrn@chromium.org303ada72010-10-27 09:33:13 +00005964 if (!maybe_new_table->ToObject(&new_table)) return maybe_new_table;
5965 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005966 // Can't use set_string_table because StringTable::cast knows that
5967 // StringTable is a singleton and checks for identity.
5968 roots_[kStringTableRootIndex] = new_table;
5969 ASSERT(result != NULL);
5970 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00005971}
5972
5973
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005974MaybeObject* Heap::InternalizeOneByteString(Vector<const uint8_t> string) {
5975 Object* result = NULL;
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00005976 Object* new_table;
5977 { MaybeObject* maybe_new_table =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005978 string_table()->LookupOneByteString(string, &result);
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00005979 if (!maybe_new_table->ToObject(&new_table)) return maybe_new_table;
5980 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005981 // Can't use set_string_table because StringTable::cast knows that
5982 // StringTable is a singleton and checks for identity.
5983 roots_[kStringTableRootIndex] = new_table;
5984 ASSERT(result != NULL);
5985 return result;
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00005986}
5987
5988
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005989MaybeObject* Heap::InternalizeOneByteString(Handle<SeqOneByteString> string,
danno@chromium.org40cb8782011-05-25 07:58:50 +00005990 int from,
5991 int length) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005992 Object* result = NULL;
danno@chromium.org40cb8782011-05-25 07:58:50 +00005993 Object* new_table;
5994 { MaybeObject* maybe_new_table =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005995 string_table()->LookupSubStringOneByteString(string,
danno@chromium.org40cb8782011-05-25 07:58:50 +00005996 from,
5997 length,
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00005998 &result);
danno@chromium.org40cb8782011-05-25 07:58:50 +00005999 if (!maybe_new_table->ToObject(&new_table)) return maybe_new_table;
6000 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006001 // Can't use set_string_table because StringTable::cast knows that
6002 // StringTable is a singleton and checks for identity.
6003 roots_[kStringTableRootIndex] = new_table;
6004 ASSERT(result != NULL);
6005 return result;
danno@chromium.org40cb8782011-05-25 07:58:50 +00006006}
6007
6008
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006009MaybeObject* Heap::InternalizeTwoByteString(Vector<const uc16> string) {
6010 Object* result = NULL;
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00006011 Object* new_table;
6012 { MaybeObject* maybe_new_table =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006013 string_table()->LookupTwoByteString(string, &result);
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00006014 if (!maybe_new_table->ToObject(&new_table)) return maybe_new_table;
6015 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006016 // Can't use set_string_table because StringTable::cast knows that
6017 // StringTable is a singleton and checks for identity.
6018 roots_[kStringTableRootIndex] = new_table;
6019 ASSERT(result != NULL);
6020 return result;
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +00006021}
6022
6023
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006024MaybeObject* Heap::InternalizeString(String* string) {
6025 if (string->IsInternalizedString()) return string;
6026 Object* result = NULL;
lrn@chromium.org303ada72010-10-27 09:33:13 +00006027 Object* new_table;
6028 { MaybeObject* maybe_new_table =
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006029 string_table()->LookupString(string, &result);
lrn@chromium.org303ada72010-10-27 09:33:13 +00006030 if (!maybe_new_table->ToObject(&new_table)) return maybe_new_table;
6031 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006032 // Can't use set_string_table because StringTable::cast knows that
6033 // StringTable is a singleton and checks for identity.
6034 roots_[kStringTableRootIndex] = new_table;
6035 ASSERT(result != NULL);
6036 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006037}
6038
6039
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006040bool Heap::InternalizeStringIfExists(String* string, String** result) {
6041 if (string->IsInternalizedString()) {
6042 *result = string;
ager@chromium.org7c537e22008-10-16 08:43:32 +00006043 return true;
6044 }
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006045 return string_table()->LookupStringIfExists(string, result);
ager@chromium.org7c537e22008-10-16 08:43:32 +00006046}
6047
verwaest@chromium.orge4ee6de2012-11-06 12:13:00 +00006048
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006049void Heap::ZapFromSpace() {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006050 NewSpacePageIterator it(new_space_.FromSpaceStart(),
6051 new_space_.FromSpaceEnd());
6052 while (it.has_next()) {
6053 NewSpacePage* page = it.next();
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00006054 for (Address cursor = page->area_start(), limit = page->area_end();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006055 cursor < limit;
6056 cursor += kPointerSize) {
6057 Memory::Address_at(cursor) = kFromSpaceZapValue;
6058 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006059 }
6060}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006061
6062
ager@chromium.org6a2b0aa2010-07-13 20:58:03 +00006063void Heap::IterateAndMarkPointersToFromSpace(Address start,
6064 Address end,
6065 ObjectSlotCallback callback) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006066 Address slot_address = start;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006067
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006068 // We are not collecting slots on new space objects during mutation
6069 // thus we have to scan for pointers to evacuation candidates when we
6070 // promote objects. But we should not record any slots in non-black
6071 // objects. Grey object's slots would be rescanned.
6072 // White object might not survive until the end of collection
6073 // it would be a violation of the invariant to record it's slots.
6074 bool record_slots = false;
6075 if (incremental_marking()->IsCompacting()) {
6076 MarkBit mark_bit = Marking::MarkBitFrom(HeapObject::FromAddress(start));
6077 record_slots = Marking::IsBlack(mark_bit);
6078 }
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006079
6080 while (slot_address < end) {
6081 Object** slot = reinterpret_cast<Object**>(slot_address);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006082 Object* object = *slot;
6083 // If the store buffer becomes overfull we mark pages as being exempt from
6084 // the store buffer. These pages are scanned to find pointers that point
6085 // to the new space. In that case we may hit newly promoted objects and
6086 // fix the pointers before the promotion queue gets to them. Thus the 'if'.
6087 if (object->IsHeapObject()) {
6088 if (Heap::InFromSpace(object)) {
6089 callback(reinterpret_cast<HeapObject**>(slot),
6090 HeapObject::cast(object));
6091 Object* new_object = *slot;
6092 if (InNewSpace(new_object)) {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006093 SLOW_ASSERT(Heap::InToSpace(new_object));
6094 SLOW_ASSERT(new_object->IsHeapObject());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006095 store_buffer_.EnterDirectlyIntoStoreBuffer(
6096 reinterpret_cast<Address>(slot));
6097 }
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006098 SLOW_ASSERT(!MarkCompactCollector::IsOnEvacuationCandidate(new_object));
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006099 } else if (record_slots &&
6100 MarkCompactCollector::IsOnEvacuationCandidate(object)) {
6101 mark_compact_collector()->RecordSlot(slot, slot, object);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006102 }
6103 }
6104 slot_address += kPointerSize;
6105 }
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006106}
6107
6108
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006109#ifdef DEBUG
6110typedef bool (*CheckStoreBufferFilter)(Object** addr);
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006111
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006112
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006113bool IsAMapPointerAddress(Object** addr) {
6114 uintptr_t a = reinterpret_cast<uintptr_t>(addr);
6115 int mod = a % Map::kSize;
6116 return mod >= Map::kPointerFieldsBeginOffset &&
6117 mod < Map::kPointerFieldsEndOffset;
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006118}
6119
6120
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006121bool EverythingsAPointer(Object** addr) {
6122 return true;
6123}
ricow@chromium.org30ce4112010-05-31 10:38:25 +00006124
kasperl@chromium.org71affb52009-05-26 05:44:31 +00006125
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006126static void CheckStoreBuffer(Heap* heap,
6127 Object** current,
6128 Object** limit,
6129 Object**** store_buffer_position,
6130 Object*** store_buffer_top,
6131 CheckStoreBufferFilter filter,
6132 Address special_garbage_start,
6133 Address special_garbage_end) {
6134 Map* free_space_map = heap->free_space_map();
6135 for ( ; current < limit; current++) {
6136 Object* o = *current;
6137 Address current_address = reinterpret_cast<Address>(current);
6138 // Skip free space.
6139 if (o == free_space_map) {
6140 Address current_address = reinterpret_cast<Address>(current);
6141 FreeSpace* free_space =
6142 FreeSpace::cast(HeapObject::FromAddress(current_address));
6143 int skip = free_space->Size();
6144 ASSERT(current_address + skip <= reinterpret_cast<Address>(limit));
6145 ASSERT(skip > 0);
6146 current_address += skip - kPointerSize;
6147 current = reinterpret_cast<Object**>(current_address);
6148 continue;
kasperl@chromium.org71affb52009-05-26 05:44:31 +00006149 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006150 // Skip the current linear allocation space between top and limit which is
6151 // unmarked with the free space map, but can contain junk.
6152 if (current_address == special_garbage_start &&
6153 special_garbage_end != special_garbage_start) {
6154 current_address = special_garbage_end - kPointerSize;
6155 current = reinterpret_cast<Object**>(current_address);
6156 continue;
6157 }
6158 if (!(*filter)(current)) continue;
6159 ASSERT(current_address < special_garbage_start ||
6160 current_address >= special_garbage_end);
6161 ASSERT(reinterpret_cast<uintptr_t>(o) != kFreeListZapValue);
6162 // We have to check that the pointer does not point into new space
6163 // without trying to cast it to a heap object since the hash field of
6164 // a string can contain values like 1 and 3 which are tagged null
6165 // pointers.
6166 if (!heap->InNewSpace(o)) continue;
6167 while (**store_buffer_position < current &&
6168 *store_buffer_position < store_buffer_top) {
6169 (*store_buffer_position)++;
6170 }
6171 if (**store_buffer_position != current ||
6172 *store_buffer_position == store_buffer_top) {
6173 Object** obj_start = current;
6174 while (!(*obj_start)->IsMap()) obj_start--;
6175 UNREACHABLE();
6176 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006177 }
6178}
6179
6180
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006181// Check that the store buffer contains all intergenerational pointers by
6182// scanning a page and ensuring that all pointers to young space are in the
6183// store buffer.
6184void Heap::OldPointerSpaceCheckStoreBuffer() {
6185 OldSpace* space = old_pointer_space();
6186 PageIterator pages(space);
6187
6188 store_buffer()->SortUniq();
6189
6190 while (pages.has_next()) {
6191 Page* page = pages.next();
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00006192 Object** current = reinterpret_cast<Object**>(page->area_start());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006193
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00006194 Address end = page->area_end();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006195
6196 Object*** store_buffer_position = store_buffer()->Start();
6197 Object*** store_buffer_top = store_buffer()->Top();
6198
6199 Object** limit = reinterpret_cast<Object**>(end);
6200 CheckStoreBuffer(this,
6201 current,
6202 limit,
6203 &store_buffer_position,
6204 store_buffer_top,
6205 &EverythingsAPointer,
6206 space->top(),
6207 space->limit());
6208 }
6209}
6210
6211
6212void Heap::MapSpaceCheckStoreBuffer() {
6213 MapSpace* space = map_space();
6214 PageIterator pages(space);
6215
6216 store_buffer()->SortUniq();
6217
6218 while (pages.has_next()) {
6219 Page* page = pages.next();
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00006220 Object** current = reinterpret_cast<Object**>(page->area_start());
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006221
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +00006222 Address end = page->area_end();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006223
6224 Object*** store_buffer_position = store_buffer()->Start();
6225 Object*** store_buffer_top = store_buffer()->Top();
6226
6227 Object** limit = reinterpret_cast<Object**>(end);
6228 CheckStoreBuffer(this,
6229 current,
6230 limit,
6231 &store_buffer_position,
6232 store_buffer_top,
6233 &IsAMapPointerAddress,
6234 space->top(),
6235 space->limit());
6236 }
6237}
6238
6239
6240void Heap::LargeObjectSpaceCheckStoreBuffer() {
6241 LargeObjectIterator it(lo_space());
6242 for (HeapObject* object = it.Next(); object != NULL; object = it.Next()) {
6243 // We only have code, sequential strings, or fixed arrays in large
6244 // object space, and only fixed arrays can possibly contain pointers to
6245 // the young generation.
6246 if (object->IsFixedArray()) {
6247 Object*** store_buffer_position = store_buffer()->Start();
6248 Object*** store_buffer_top = store_buffer()->Top();
6249 Object** current = reinterpret_cast<Object**>(object->address());
6250 Object** limit =
6251 reinterpret_cast<Object**>(object->address() + object->Size());
6252 CheckStoreBuffer(this,
6253 current,
6254 limit,
6255 &store_buffer_position,
6256 store_buffer_top,
6257 &EverythingsAPointer,
6258 NULL,
6259 NULL);
6260 }
6261 }
6262}
6263#endif
6264
6265
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006266void Heap::IterateRoots(ObjectVisitor* v, VisitMode mode) {
6267 IterateStrongRoots(v, mode);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00006268 IterateWeakRoots(v, mode);
6269}
6270
6271
6272void Heap::IterateWeakRoots(ObjectVisitor* v, VisitMode mode) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006273 v->VisitPointer(reinterpret_cast<Object**>(&roots_[kStringTableRootIndex]));
6274 v->Synchronize(VisitorSynchronization::kStringTable);
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +00006275 if (mode != VISIT_ALL_IN_SCAVENGE &&
6276 mode != VISIT_ALL_IN_SWEEP_NEWSPACE) {
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00006277 // Scavenge collections have special processing for this.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006278 external_string_table_.Iterate(v);
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00006279 error_object_list_.Iterate(v);
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00006280 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006281 v->Synchronize(VisitorSynchronization::kExternalStringsTable);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006282}
6283
6284
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006285void Heap::IterateStrongRoots(ObjectVisitor* v, VisitMode mode) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00006286 v->VisitPointers(&roots_[0], &roots_[kStrongRootListLength]);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006287 v->Synchronize(VisitorSynchronization::kStrongRootList);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006288
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00006289 v->VisitPointer(BitCast<Object**>(&hidden_string_));
6290 v->Synchronize(VisitorSynchronization::kInternalizedString);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006291
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006292 isolate_->bootstrapper()->Iterate(v);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006293 v->Synchronize(VisitorSynchronization::kBootstrapper);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006294 isolate_->Iterate(v);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006295 v->Synchronize(VisitorSynchronization::kTop);
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00006296 Relocatable::Iterate(v);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006297 v->Synchronize(VisitorSynchronization::kRelocatable);
ager@chromium.org65dad4b2009-04-23 08:48:43 +00006298
6299#ifdef ENABLE_DEBUGGER_SUPPORT
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006300 isolate_->debug()->Iterate(v);
ricow@chromium.org4f693d62011-07-04 14:01:31 +00006301 if (isolate_->deoptimizer_data() != NULL) {
6302 isolate_->deoptimizer_data()->Iterate(v);
6303 }
ager@chromium.org65dad4b2009-04-23 08:48:43 +00006304#endif
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006305 v->Synchronize(VisitorSynchronization::kDebug);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006306 isolate_->compilation_cache()->Iterate(v);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006307 v->Synchronize(VisitorSynchronization::kCompilationCache);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006308
6309 // Iterate over local handles in handle scopes.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006310 isolate_->handle_scope_implementer()->Iterate(v);
yangguo@chromium.org304cc332012-07-24 07:59:48 +00006311 isolate_->IterateDeferredHandles(v);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006312 v->Synchronize(VisitorSynchronization::kHandleScope);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006313
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00006314 // Iterate over the builtin code objects and code stubs in the
6315 // heap. Note that it is not necessary to iterate over code objects
6316 // on scavenge collections.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006317 if (mode != VISIT_ALL_IN_SCAVENGE) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006318 isolate_->builtins()->IterateBuiltins(v);
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00006319 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006320 v->Synchronize(VisitorSynchronization::kBuiltins);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006321
6322 // Iterate over global handles.
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +00006323 switch (mode) {
6324 case VISIT_ONLY_STRONG:
6325 isolate_->global_handles()->IterateStrongRoots(v);
6326 break;
6327 case VISIT_ALL_IN_SCAVENGE:
jkummerow@chromium.orge297f592011-06-08 10:05:15 +00006328 isolate_->global_handles()->IterateNewSpaceStrongAndDependentRoots(v);
kmillikin@chromium.orgc53e10d2011-05-18 09:12:58 +00006329 break;
6330 case VISIT_ALL_IN_SWEEP_NEWSPACE:
6331 case VISIT_ALL:
6332 isolate_->global_handles()->IterateAllRoots(v);
6333 break;
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006334 }
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006335 v->Synchronize(VisitorSynchronization::kGlobalHandles);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006336
6337 // Iterate over pointers being held by inactive threads.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006338 isolate_->thread_manager()->Iterate(v);
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00006339 v->Synchronize(VisitorSynchronization::kThreadManager);
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00006340
6341 // Iterate over the pointers the Serialization/Deserialization code is
6342 // holding.
6343 // During garbage collection this keeps the partial snapshot cache alive.
6344 // During deserialization of the startup snapshot this creates the partial
6345 // snapshot cache and deserializes the objects it refers to. During
6346 // serialization this does nothing, since the partial snapshot cache is
6347 // empty. However the next thing we do is create the partial snapshot,
6348 // filling up the partial snapshot cache with objects it needs as we go.
6349 SerializerDeserializer::Iterate(v);
6350 // We don't do a v->Synchronize call here, because in debug mode that will
6351 // output a flag to the snapshot. However at this point the serializer and
6352 // deserializer are deliberately a little unsynchronized (see above) so the
6353 // checking of the sync flag in the snapshot would fail.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006354}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006355
6356
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006357// TODO(1236194): Since the heap size is configurable on the command line
6358// and through the API, we should gracefully handle the case that the heap
6359// size is not big enough to fit all the initial objects.
ager@chromium.org01fe7df2010-11-10 11:59:11 +00006360bool Heap::ConfigureHeap(int max_semispace_size,
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006361 intptr_t max_old_gen_size,
6362 intptr_t max_executable_size) {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006363 if (HasBeenSetUp()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006364
yangguo@chromium.orgefdb9d72012-04-26 08:21:05 +00006365 if (FLAG_stress_compaction) {
6366 // This will cause more frequent GCs when stressing.
6367 max_semispace_size_ = Page::kPageSize;
6368 }
6369
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006370 if (max_semispace_size > 0) {
6371 if (max_semispace_size < Page::kPageSize) {
6372 max_semispace_size = Page::kPageSize;
6373 if (FLAG_trace_gc) {
rossberg@chromium.org657d53b2012-07-12 11:06:03 +00006374 PrintPID("Max semispace size cannot be less than %dkbytes\n",
6375 Page::kPageSize >> 10);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006376 }
6377 }
6378 max_semispace_size_ = max_semispace_size;
6379 }
ager@chromium.org3811b432009-10-28 14:53:37 +00006380
6381 if (Snapshot::IsEnabled()) {
6382 // If we are using a snapshot we always reserve the default amount
6383 // of memory for each semispace because code in the snapshot has
6384 // write-barrier code that relies on the size and alignment of new
6385 // space. We therefore cannot use a larger max semispace size
6386 // than the default reserved semispace size.
6387 if (max_semispace_size_ > reserved_semispace_size_) {
6388 max_semispace_size_ = reserved_semispace_size_;
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006389 if (FLAG_trace_gc) {
rossberg@chromium.org657d53b2012-07-12 11:06:03 +00006390 PrintPID("Max semispace size cannot be more than %dkbytes\n",
6391 reserved_semispace_size_ >> 10);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006392 }
ager@chromium.org3811b432009-10-28 14:53:37 +00006393 }
6394 } else {
6395 // If we are not using snapshots we reserve space for the actual
6396 // max semispace size.
6397 reserved_semispace_size_ = max_semispace_size_;
6398 }
6399
6400 if (max_old_gen_size > 0) max_old_generation_size_ = max_old_gen_size;
ager@chromium.org01fe7df2010-11-10 11:59:11 +00006401 if (max_executable_size > 0) {
6402 max_executable_size_ = RoundUp(max_executable_size, Page::kPageSize);
6403 }
6404
6405 // The max executable size must be less than or equal to the max old
6406 // generation size.
6407 if (max_executable_size_ > max_old_generation_size_) {
6408 max_executable_size_ = max_old_generation_size_;
6409 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006410
6411 // The new space size must be a power of two to support single-bit testing
6412 // for containment.
ager@chromium.org3811b432009-10-28 14:53:37 +00006413 max_semispace_size_ = RoundUpToPowerOf2(max_semispace_size_);
6414 reserved_semispace_size_ = RoundUpToPowerOf2(reserved_semispace_size_);
6415 initial_semispace_size_ = Min(initial_semispace_size_, max_semispace_size_);
mstarzinger@chromium.org471f2f12012-08-10 14:46:33 +00006416 external_allocation_limit_ = 16 * max_semispace_size_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006417
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006418 // The old generation is paged and needs at least one page for each space.
6419 int paged_space_count = LAST_PAGED_SPACE - FIRST_PAGED_SPACE + 1;
6420 max_old_generation_size_ = Max(static_cast<intptr_t>(paged_space_count *
6421 Page::kPageSize),
6422 RoundUp(max_old_generation_size_,
6423 Page::kPageSize));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006424
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006425 configured_ = true;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006426 return true;
6427}
6428
6429
kasper.lund7276f142008-07-30 08:49:36 +00006430bool Heap::ConfigureHeapDefault() {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006431 return ConfigureHeap(static_cast<intptr_t>(FLAG_max_new_space_size / 2) * KB,
6432 static_cast<intptr_t>(FLAG_max_old_space_size) * MB,
6433 static_cast<intptr_t>(FLAG_max_executable_size) * MB);
kasper.lund7276f142008-07-30 08:49:36 +00006434}
6435
6436
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00006437void Heap::RecordStats(HeapStats* stats, bool take_snapshot) {
ricow@chromium.org0b9f8502010-08-18 07:45:01 +00006438 *stats->start_marker = HeapStats::kStartMarker;
6439 *stats->end_marker = HeapStats::kEndMarker;
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00006440 *stats->new_space_size = new_space_.SizeAsInt();
6441 *stats->new_space_capacity = static_cast<int>(new_space_.Capacity());
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00006442 *stats->old_pointer_space_size = old_pointer_space_->SizeOfObjects();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00006443 *stats->old_pointer_space_capacity = old_pointer_space_->Capacity();
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00006444 *stats->old_data_space_size = old_data_space_->SizeOfObjects();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00006445 *stats->old_data_space_capacity = old_data_space_->Capacity();
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00006446 *stats->code_space_size = code_space_->SizeOfObjects();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00006447 *stats->code_space_capacity = code_space_->Capacity();
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00006448 *stats->map_space_size = map_space_->SizeOfObjects();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00006449 *stats->map_space_capacity = map_space_->Capacity();
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00006450 *stats->cell_space_size = cell_space_->SizeOfObjects();
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +00006451 *stats->cell_space_capacity = cell_space_->Capacity();
6452 *stats->lo_space_size = lo_space_->Size();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006453 isolate_->global_handles()->RecordStats(stats);
6454 *stats->memory_allocator_size = isolate()->memory_allocator()->Size();
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00006455 *stats->memory_allocator_capacity =
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006456 isolate()->memory_allocator()->Size() +
6457 isolate()->memory_allocator()->Available();
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00006458 *stats->os_error = OS::GetLastError();
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006459 isolate()->memory_allocator()->Available();
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00006460 if (take_snapshot) {
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006461 HeapIterator iterator(this);
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00006462 for (HeapObject* obj = iterator.next();
6463 obj != NULL;
6464 obj = iterator.next()) {
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +00006465 InstanceType type = obj->map()->instance_type();
6466 ASSERT(0 <= type && type <= LAST_TYPE);
6467 stats->objects_per_type[type]++;
6468 stats->size_per_type[type] += obj->Size();
6469 }
6470 }
ager@chromium.org60121232009-12-03 11:25:37 +00006471}
6472
6473
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00006474intptr_t Heap::PromotedSpaceSizeOfObjects() {
6475 return old_pointer_space_->SizeOfObjects()
6476 + old_data_space_->SizeOfObjects()
6477 + code_space_->SizeOfObjects()
6478 + map_space_->SizeOfObjects()
6479 + cell_space_->SizeOfObjects()
6480 + lo_space_->SizeOfObjects();
6481}
6482
6483
jkummerow@chromium.org28faa982012-04-13 09:58:30 +00006484intptr_t Heap::PromotedExternalMemorySize() {
kasper.lund7276f142008-07-30 08:49:36 +00006485 if (amount_of_external_allocated_memory_
6486 <= amount_of_external_allocated_memory_at_last_global_gc_) return 0;
6487 return amount_of_external_allocated_memory_
6488 - amount_of_external_allocated_memory_at_last_global_gc_;
6489}
6490
fschneider@chromium.org7d10be52012-04-10 12:30:14 +00006491
6492V8_DECLARE_ONCE(initialize_gc_once);
6493
6494static void InitializeGCOnce() {
6495 InitializeScavengingVisitorsTables();
6496 NewSpaceScavenger::Initialize();
6497 MarkCompactCollector::Initialize();
6498}
6499
ulan@chromium.org09d7ab52013-02-25 15:50:35 +00006500bool Heap::SetUp() {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006501#ifdef DEBUG
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006502 allocation_timeout_ = FLAG_gc_interval;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006503#endif
6504
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006505 // Initialize heap spaces and initial maps and objects. Whenever something
6506 // goes wrong, just return false. The caller should check the results and
6507 // call Heap::TearDown() to release allocated memory.
6508 //
ulan@chromium.org2efb9002012-01-19 15:36:35 +00006509 // If the heap is not yet configured (e.g. through the API), configure it.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006510 // Configuration is based on the flags new-space-size (really the semispace
6511 // size) and old-space-size if set or the initial values of semispace_size_
6512 // and old_generation_size_ otherwise.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006513 if (!configured_) {
kasper.lund7276f142008-07-30 08:49:36 +00006514 if (!ConfigureHeapDefault()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006515 }
6516
fschneider@chromium.org7d10be52012-04-10 12:30:14 +00006517 CallOnce(&initialize_gc_once, &InitializeGCOnce);
ager@chromium.orgea4f62e2010-08-16 16:28:43 +00006518
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +00006519 MarkMapPointersAsEncoded(false);
6520
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006521 // Set up memory allocator.
6522 if (!isolate_->memory_allocator()->SetUp(MaxReserved(), MaxExecutableSize()))
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006523 return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006524
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006525 // Set up new space.
6526 if (!new_space_.SetUp(reserved_semispace_size_, max_semispace_size_)) {
ager@chromium.org3811b432009-10-28 14:53:37 +00006527 return false;
6528 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006529
ager@chromium.orga1645e22009-09-09 19:27:10 +00006530 // Initialize old pointer space.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006531 old_pointer_space_ =
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006532 new OldSpace(this,
6533 max_old_generation_size_,
6534 OLD_POINTER_SPACE,
6535 NOT_EXECUTABLE);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006536 if (old_pointer_space_ == NULL) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006537 if (!old_pointer_space_->SetUp()) return false;
ager@chromium.orga1645e22009-09-09 19:27:10 +00006538
6539 // Initialize old data space.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006540 old_data_space_ =
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006541 new OldSpace(this,
6542 max_old_generation_size_,
6543 OLD_DATA_SPACE,
6544 NOT_EXECUTABLE);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006545 if (old_data_space_ == NULL) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006546 if (!old_data_space_->SetUp()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006547
6548 // Initialize the code space, set its maximum capacity to the old
kasper.lund7276f142008-07-30 08:49:36 +00006549 // generation size. It needs executable memory.
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00006550 // On 64-bit platform(s), we put all code objects in a 2 GB range of
6551 // virtual address space, so that they can call each other with near calls.
6552 if (code_range_size_ > 0) {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006553 if (!isolate_->code_range()->SetUp(code_range_size_)) {
sgjesse@chromium.orgc5145742009-10-07 09:00:33 +00006554 return false;
6555 }
6556 }
6557
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006558 code_space_ =
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006559 new OldSpace(this, max_old_generation_size_, CODE_SPACE, EXECUTABLE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006560 if (code_space_ == NULL) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006561 if (!code_space_->SetUp()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006562
6563 // Initialize map space.
yangguo@chromium.org78d1ad42012-02-09 13:53:47 +00006564 map_space_ = new MapSpace(this, max_old_generation_size_, MAP_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006565 if (map_space_ == NULL) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006566 if (!map_space_->SetUp()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006567
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006568 // Initialize global property cell space.
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006569 cell_space_ = new CellSpace(this, max_old_generation_size_, CELL_SPACE);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006570 if (cell_space_ == NULL) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006571 if (!cell_space_->SetUp()) return false;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006572
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006573 // The large object code space may contain code or data. We set the memory
6574 // to be non-executable here for safety, but this means we need to enable it
6575 // explicitly when allocating large code objects.
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006576 lo_space_ = new LargeObjectSpace(this, max_old_generation_size_, LO_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006577 if (lo_space_ == NULL) return false;
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006578 if (!lo_space_->SetUp()) return false;
rossberg@chromium.orgfab14982012-01-05 15:02:15 +00006579
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006580 // Set up the seed that is used to randomize the string hash function.
6581 ASSERT(hash_seed() == 0);
6582 if (FLAG_randomize_hashes) {
6583 if (FLAG_hash_seed == 0) {
6584 set_hash_seed(
rossberg@chromium.orgfab14982012-01-05 15:02:15 +00006585 Smi::FromInt(V8::RandomPrivate(isolate()) & 0x3fffffff));
6586 } else {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006587 set_hash_seed(Smi::FromInt(FLAG_hash_seed));
rossberg@chromium.orgfab14982012-01-05 15:02:15 +00006588 }
6589 }
6590
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006591 LOG(isolate_, IntPtrTEvent("heap-capacity", Capacity()));
6592 LOG(isolate_, IntPtrTEvent("heap-available", Available()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006593
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +00006594 store_buffer()->SetUp();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006595
yangguo@chromium.org304cc332012-07-24 07:59:48 +00006596 if (FLAG_parallel_recompilation) relocation_mutex_ = OS::CreateMutex();
6597
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006598 return true;
6599}
6600
ulan@chromium.org09d7ab52013-02-25 15:50:35 +00006601bool Heap::CreateHeapObjects() {
6602 // Create initial maps.
6603 if (!CreateInitialMaps()) return false;
6604 if (!CreateApiObjects()) return false;
6605
6606 // Create initial objects
6607 if (!CreateInitialObjects()) return false;
6608
6609 native_contexts_list_ = undefined_value();
6610 return true;
6611}
6612
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006613
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006614void Heap::SetStackLimits() {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006615 ASSERT(isolate_ != NULL);
6616 ASSERT(isolate_ == isolate());
ager@chromium.org18ad94b2009-09-02 08:22:29 +00006617 // On 64 bit machines, pointers are generally out of range of Smis. We write
6618 // something that looks like an out of range Smi to the GC.
6619
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006620 // Set up the special root array entries containing the stack limits.
6621 // These are actually addresses, but the tag makes the GC ignore it.
ager@chromium.org18ad94b2009-09-02 08:22:29 +00006622 roots_[kStackLimitRootIndex] =
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006623 reinterpret_cast<Object*>(
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006624 (isolate_->stack_guard()->jslimit() & ~kSmiTagMask) | kSmiTag);
ager@chromium.orgc4c92722009-11-18 14:12:51 +00006625 roots_[kRealStackLimitRootIndex] =
6626 reinterpret_cast<Object*>(
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006627 (isolate_->stack_guard()->real_jslimit() & ~kSmiTagMask) | kSmiTag);
ager@chromium.org18ad94b2009-09-02 08:22:29 +00006628}
6629
6630
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006631void Heap::TearDown() {
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00006632#ifdef VERIFY_HEAP
danno@chromium.org1044a4d2012-04-30 12:34:39 +00006633 if (FLAG_verify_heap) {
6634 Verify();
6635 }
6636#endif
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00006637
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006638 if (FLAG_print_cumulative_gc_stat) {
mstarzinger@chromium.orge3b8d0f2013-02-01 09:06:41 +00006639 PrintF("\n");
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006640 PrintF("gc_count=%d ", gc_count_);
6641 PrintF("mark_sweep_count=%d ", ms_count_);
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00006642 PrintF("max_gc_pause=%.1f ", get_max_gc_pause());
6643 PrintF("total_gc_time=%.1f ", total_gc_time_ms_);
6644 PrintF("min_in_mutator=%.1f ", get_min_in_mutator());
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00006645 PrintF("max_alive_after_gc=%" V8_PTR_PREFIX "d ",
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006646 get_max_alive_after_gc());
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00006647 PrintF("total_marking_time=%.1f ", marking_time());
6648 PrintF("total_sweeping_time=%.1f ", sweeping_time());
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00006649 PrintF("\n\n");
6650 }
6651
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006652 isolate_->global_handles()->TearDown();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006653
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006654 external_string_table_.TearDown();
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00006655
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00006656 error_object_list_.TearDown();
6657
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00006658 new_space_.TearDown();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006659
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006660 if (old_pointer_space_ != NULL) {
6661 old_pointer_space_->TearDown();
6662 delete old_pointer_space_;
6663 old_pointer_space_ = NULL;
6664 }
6665
6666 if (old_data_space_ != NULL) {
6667 old_data_space_->TearDown();
6668 delete old_data_space_;
6669 old_data_space_ = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006670 }
6671
6672 if (code_space_ != NULL) {
6673 code_space_->TearDown();
6674 delete code_space_;
6675 code_space_ = NULL;
6676 }
6677
6678 if (map_space_ != NULL) {
6679 map_space_->TearDown();
6680 delete map_space_;
6681 map_space_ = NULL;
6682 }
6683
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006684 if (cell_space_ != NULL) {
6685 cell_space_->TearDown();
6686 delete cell_space_;
6687 cell_space_ = NULL;
6688 }
6689
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006690 if (lo_space_ != NULL) {
6691 lo_space_->TearDown();
6692 delete lo_space_;
6693 lo_space_ = NULL;
6694 }
6695
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00006696 store_buffer()->TearDown();
6697 incremental_marking()->TearDown();
6698
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006699 isolate_->memory_allocator()->TearDown();
6700
yangguo@chromium.org304cc332012-07-24 07:59:48 +00006701 delete relocation_mutex_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006702}
6703
6704
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +00006705void Heap::AddGCPrologueCallback(GCPrologueCallback callback, GCType gc_type) {
6706 ASSERT(callback != NULL);
6707 GCPrologueCallbackPair pair(callback, gc_type);
6708 ASSERT(!gc_prologue_callbacks_.Contains(pair));
6709 return gc_prologue_callbacks_.Add(pair);
6710}
6711
6712
6713void Heap::RemoveGCPrologueCallback(GCPrologueCallback callback) {
6714 ASSERT(callback != NULL);
6715 for (int i = 0; i < gc_prologue_callbacks_.length(); ++i) {
6716 if (gc_prologue_callbacks_[i].callback == callback) {
6717 gc_prologue_callbacks_.Remove(i);
6718 return;
6719 }
6720 }
6721 UNREACHABLE();
6722}
6723
6724
6725void Heap::AddGCEpilogueCallback(GCEpilogueCallback callback, GCType gc_type) {
6726 ASSERT(callback != NULL);
6727 GCEpilogueCallbackPair pair(callback, gc_type);
6728 ASSERT(!gc_epilogue_callbacks_.Contains(pair));
6729 return gc_epilogue_callbacks_.Add(pair);
6730}
6731
6732
6733void Heap::RemoveGCEpilogueCallback(GCEpilogueCallback callback) {
6734 ASSERT(callback != NULL);
6735 for (int i = 0; i < gc_epilogue_callbacks_.length(); ++i) {
6736 if (gc_epilogue_callbacks_[i].callback == callback) {
6737 gc_epilogue_callbacks_.Remove(i);
6738 return;
6739 }
6740 }
6741 UNREACHABLE();
6742}
6743
6744
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006745#ifdef DEBUG
6746
6747class PrintHandleVisitor: public ObjectVisitor {
6748 public:
6749 void VisitPointers(Object** start, Object** end) {
6750 for (Object** p = start; p < end; p++)
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00006751 PrintF(" handle %p to %p\n",
6752 reinterpret_cast<void*>(p),
6753 reinterpret_cast<void*>(*p));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006754 }
6755};
6756
6757void Heap::PrintHandles() {
6758 PrintF("Handles:\n");
6759 PrintHandleVisitor v;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00006760 isolate_->handle_scope_implementer()->Iterate(&v);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006761}
6762
6763#endif
6764
6765
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006766Space* AllSpaces::next() {
6767 switch (counter_++) {
6768 case NEW_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006769 return heap_->new_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006770 case OLD_POINTER_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006771 return heap_->old_pointer_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006772 case OLD_DATA_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006773 return heap_->old_data_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006774 case CODE_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006775 return heap_->code_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006776 case MAP_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006777 return heap_->map_space();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006778 case CELL_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006779 return heap_->cell_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006780 case LO_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006781 return heap_->lo_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006782 default:
6783 return NULL;
6784 }
6785}
6786
6787
6788PagedSpace* PagedSpaces::next() {
6789 switch (counter_++) {
6790 case OLD_POINTER_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006791 return heap_->old_pointer_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006792 case OLD_DATA_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006793 return heap_->old_data_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006794 case CODE_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006795 return heap_->code_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006796 case MAP_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006797 return heap_->map_space();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006798 case CELL_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006799 return heap_->cell_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006800 default:
6801 return NULL;
6802 }
6803}
6804
6805
6806
6807OldSpace* OldSpaces::next() {
6808 switch (counter_++) {
6809 case OLD_POINTER_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006810 return heap_->old_pointer_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006811 case OLD_DATA_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006812 return heap_->old_data_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006813 case CODE_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006814 return heap_->code_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006815 default:
6816 return NULL;
6817 }
6818}
6819
6820
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006821SpaceIterator::SpaceIterator(Heap* heap)
6822 : heap_(heap),
6823 current_space_(FIRST_SPACE),
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00006824 iterator_(NULL),
6825 size_func_(NULL) {
6826}
6827
6828
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006829SpaceIterator::SpaceIterator(Heap* heap, HeapObjectCallback size_func)
6830 : heap_(heap),
6831 current_space_(FIRST_SPACE),
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00006832 iterator_(NULL),
6833 size_func_(size_func) {
kasper.lund7276f142008-07-30 08:49:36 +00006834}
6835
6836
6837SpaceIterator::~SpaceIterator() {
6838 // Delete active iterator if any.
6839 delete iterator_;
6840}
6841
6842
6843bool SpaceIterator::has_next() {
6844 // Iterate until no more spaces.
6845 return current_space_ != LAST_SPACE;
6846}
6847
6848
6849ObjectIterator* SpaceIterator::next() {
6850 if (iterator_ != NULL) {
6851 delete iterator_;
6852 iterator_ = NULL;
6853 // Move to the next space
6854 current_space_++;
6855 if (current_space_ > LAST_SPACE) {
6856 return NULL;
6857 }
6858 }
6859
6860 // Return iterator for the new current space.
6861 return CreateIterator();
6862}
6863
6864
6865// Create an iterator for the space to iterate.
6866ObjectIterator* SpaceIterator::CreateIterator() {
6867 ASSERT(iterator_ == NULL);
6868
6869 switch (current_space_) {
6870 case NEW_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006871 iterator_ = new SemiSpaceIterator(heap_->new_space(), size_func_);
kasper.lund7276f142008-07-30 08:49:36 +00006872 break;
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006873 case OLD_POINTER_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006874 iterator_ =
6875 new HeapObjectIterator(heap_->old_pointer_space(), size_func_);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00006876 break;
6877 case OLD_DATA_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006878 iterator_ = new HeapObjectIterator(heap_->old_data_space(), size_func_);
kasper.lund7276f142008-07-30 08:49:36 +00006879 break;
6880 case CODE_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006881 iterator_ = new HeapObjectIterator(heap_->code_space(), size_func_);
kasper.lund7276f142008-07-30 08:49:36 +00006882 break;
6883 case MAP_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006884 iterator_ = new HeapObjectIterator(heap_->map_space(), size_func_);
kasper.lund7276f142008-07-30 08:49:36 +00006885 break;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006886 case CELL_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006887 iterator_ = new HeapObjectIterator(heap_->cell_space(), size_func_);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00006888 break;
kasper.lund7276f142008-07-30 08:49:36 +00006889 case LO_SPACE:
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006890 iterator_ = new LargeObjectIterator(heap_->lo_space(), size_func_);
kasper.lund7276f142008-07-30 08:49:36 +00006891 break;
6892 }
6893
6894 // Return the newly allocated iterator;
6895 ASSERT(iterator_ != NULL);
6896 return iterator_;
6897}
6898
6899
whesse@chromium.org023421e2010-12-21 12:19:12 +00006900class HeapObjectsFilter {
6901 public:
6902 virtual ~HeapObjectsFilter() {}
6903 virtual bool SkipObject(HeapObject* object) = 0;
6904};
6905
6906
whesse@chromium.org023421e2010-12-21 12:19:12 +00006907class UnreachableObjectsFilter : public HeapObjectsFilter {
6908 public:
6909 UnreachableObjectsFilter() {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006910 MarkReachableObjects();
6911 }
6912
6913 ~UnreachableObjectsFilter() {
6914 Isolate::Current()->heap()->mark_compact_collector()->ClearMarkbits();
whesse@chromium.org023421e2010-12-21 12:19:12 +00006915 }
6916
6917 bool SkipObject(HeapObject* object) {
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006918 MarkBit mark_bit = Marking::MarkBitFrom(object);
6919 return !mark_bit.Get();
whesse@chromium.org023421e2010-12-21 12:19:12 +00006920 }
6921
6922 private:
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006923 class MarkingVisitor : public ObjectVisitor {
whesse@chromium.org023421e2010-12-21 12:19:12 +00006924 public:
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006925 MarkingVisitor() : marking_stack_(10) {}
whesse@chromium.org023421e2010-12-21 12:19:12 +00006926
6927 void VisitPointers(Object** start, Object** end) {
6928 for (Object** p = start; p < end; p++) {
6929 if (!(*p)->IsHeapObject()) continue;
6930 HeapObject* obj = HeapObject::cast(*p);
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006931 MarkBit mark_bit = Marking::MarkBitFrom(obj);
6932 if (!mark_bit.Get()) {
6933 mark_bit.Set();
6934 marking_stack_.Add(obj);
whesse@chromium.org023421e2010-12-21 12:19:12 +00006935 }
6936 }
6937 }
6938
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006939 void TransitiveClosure() {
6940 while (!marking_stack_.is_empty()) {
6941 HeapObject* obj = marking_stack_.RemoveLast();
6942 obj->Iterate(this);
6943 }
whesse@chromium.org023421e2010-12-21 12:19:12 +00006944 }
6945
6946 private:
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006947 List<HeapObject*> marking_stack_;
whesse@chromium.org023421e2010-12-21 12:19:12 +00006948 };
6949
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00006950 void MarkReachableObjects() {
6951 Heap* heap = Isolate::Current()->heap();
6952 MarkingVisitor visitor;
6953 heap->IterateRoots(&visitor, VISIT_ALL);
6954 visitor.TransitiveClosure();
whesse@chromium.org023421e2010-12-21 12:19:12 +00006955 }
6956
6957 AssertNoAllocation no_alloc;
6958};
6959
6960
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006961HeapIterator::HeapIterator(Heap* heap)
6962 : heap_(heap),
6963 filtering_(HeapIterator::kNoFiltering),
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00006964 filter_(NULL) {
6965 Init();
6966}
6967
6968
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006969HeapIterator::HeapIterator(Heap* heap,
6970 HeapIterator::HeapObjectsFiltering filtering)
6971 : heap_(heap),
6972 filtering_(filtering),
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00006973 filter_(NULL) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006974 Init();
6975}
6976
6977
6978HeapIterator::~HeapIterator() {
6979 Shutdown();
6980}
6981
6982
6983void HeapIterator::Init() {
6984 // Start the iteration.
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00006985 space_iterator_ = new SpaceIterator(heap_);
whesse@chromium.org023421e2010-12-21 12:19:12 +00006986 switch (filtering_) {
whesse@chromium.org023421e2010-12-21 12:19:12 +00006987 case kFilterUnreachable:
6988 filter_ = new UnreachableObjectsFilter;
6989 break;
6990 default:
6991 break;
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00006992 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00006993 object_iterator_ = space_iterator_->next();
6994}
6995
6996
6997void HeapIterator::Shutdown() {
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00006998#ifdef DEBUG
whesse@chromium.org023421e2010-12-21 12:19:12 +00006999 // Assert that in filtering mode we have iterated through all
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00007000 // objects. Otherwise, heap will be left in an inconsistent state.
whesse@chromium.org023421e2010-12-21 12:19:12 +00007001 if (filtering_ != kNoFiltering) {
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00007002 ASSERT(object_iterator_ == NULL);
7003 }
7004#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007005 // Make sure the last iterator is deallocated.
7006 delete space_iterator_;
7007 space_iterator_ = NULL;
7008 object_iterator_ = NULL;
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00007009 delete filter_;
7010 filter_ = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007011}
7012
7013
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007014HeapObject* HeapIterator::next() {
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00007015 if (filter_ == NULL) return NextObject();
7016
7017 HeapObject* obj = NextObject();
whesse@chromium.org023421e2010-12-21 12:19:12 +00007018 while (obj != NULL && filter_->SkipObject(obj)) obj = NextObject();
erik.corry@gmail.com4a6c3272010-11-18 12:04:40 +00007019 return obj;
7020}
7021
7022
7023HeapObject* HeapIterator::NextObject() {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007024 // No iterator means we are done.
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007025 if (object_iterator_ == NULL) return NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007026
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007027 if (HeapObject* obj = object_iterator_->next_object()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007028 // If the current iterator has more objects we are fine.
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007029 return obj;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007030 } else {
7031 // Go though the spaces looking for one that has objects.
7032 while (space_iterator_->has_next()) {
7033 object_iterator_ = space_iterator_->next();
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007034 if (HeapObject* obj = object_iterator_->next_object()) {
7035 return obj;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007036 }
7037 }
7038 }
7039 // Done with the last space.
7040 object_iterator_ = NULL;
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +00007041 return NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007042}
7043
7044
7045void HeapIterator::reset() {
7046 // Restart the iterator.
7047 Shutdown();
7048 Init();
7049}
7050
7051
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00007052#ifdef DEBUG
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007053
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007054Object* const PathTracer::kAnyGlobalObject = reinterpret_cast<Object*>(NULL);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007055
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007056class PathTracer::MarkVisitor: public ObjectVisitor {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007057 public:
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007058 explicit MarkVisitor(PathTracer* tracer) : tracer_(tracer) {}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007059 void VisitPointers(Object** start, Object** end) {
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007060 // Scan all HeapObject pointers in [start, end)
7061 for (Object** p = start; !tracer_->found() && (p < end); p++) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007062 if ((*p)->IsHeapObject())
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007063 tracer_->MarkRecursively(p, this);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007064 }
7065 }
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007066
7067 private:
7068 PathTracer* tracer_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007069};
7070
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007071
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007072class PathTracer::UnmarkVisitor: public ObjectVisitor {
7073 public:
7074 explicit UnmarkVisitor(PathTracer* tracer) : tracer_(tracer) {}
7075 void VisitPointers(Object** start, Object** end) {
7076 // Scan all HeapObject pointers in [start, end)
7077 for (Object** p = start; p < end; p++) {
7078 if ((*p)->IsHeapObject())
7079 tracer_->UnmarkRecursively(p, this);
7080 }
7081 }
7082
7083 private:
7084 PathTracer* tracer_;
7085};
7086
7087
7088void PathTracer::VisitPointers(Object** start, Object** end) {
7089 bool done = ((what_to_find_ == FIND_FIRST) && found_target_);
7090 // Visit all HeapObject pointers in [start, end)
7091 for (Object** p = start; !done && (p < end); p++) {
7092 if ((*p)->IsHeapObject()) {
7093 TracePathFrom(p);
7094 done = ((what_to_find_ == FIND_FIRST) && found_target_);
7095 }
7096 }
7097}
7098
7099
7100void PathTracer::Reset() {
7101 found_target_ = false;
7102 object_stack_.Clear();
7103}
7104
7105
7106void PathTracer::TracePathFrom(Object** root) {
7107 ASSERT((search_target_ == kAnyGlobalObject) ||
7108 search_target_->IsHeapObject());
7109 found_target_in_trace_ = false;
yangguo@chromium.org5a11aaf2012-06-20 11:29:00 +00007110 Reset();
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007111
7112 MarkVisitor mark_visitor(this);
7113 MarkRecursively(root, &mark_visitor);
7114
7115 UnmarkVisitor unmark_visitor(this);
7116 UnmarkRecursively(root, &unmark_visitor);
7117
7118 ProcessResults();
7119}
7120
7121
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00007122static bool SafeIsNativeContext(HeapObject* obj) {
7123 return obj->map() == obj->GetHeap()->raw_unchecked_native_context_map();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007124}
7125
7126
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007127void PathTracer::MarkRecursively(Object** p, MarkVisitor* mark_visitor) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007128 if (!(*p)->IsHeapObject()) return;
7129
7130 HeapObject* obj = HeapObject::cast(*p);
7131
7132 Object* map = obj->map();
7133
7134 if (!map->IsHeapObject()) return; // visited before
7135
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007136 if (found_target_in_trace_) return; // stop if target found
7137 object_stack_.Add(obj);
7138 if (((search_target_ == kAnyGlobalObject) && obj->IsJSGlobalObject()) ||
7139 (obj == search_target_)) {
7140 found_target_in_trace_ = true;
7141 found_target_ = true;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007142 return;
7143 }
7144
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00007145 bool is_native_context = SafeIsNativeContext(obj);
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007146
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007147 // not visited yet
7148 Map* map_p = reinterpret_cast<Map*>(HeapObject::cast(map));
7149
7150 Address map_addr = map_p->address();
7151
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00007152 obj->set_map_no_write_barrier(reinterpret_cast<Map*>(map_addr + kMarkTag));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007153
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007154 // Scan the object body.
yangguo@chromium.org46839fb2012-08-28 09:06:19 +00007155 if (is_native_context && (visit_mode_ == VISIT_ONLY_STRONG)) {
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007156 // This is specialized to scan Context's properly.
danno@chromium.org2ab0c3b2012-10-05 08:50:56 +00007157 Object** start = reinterpret_cast<Object**>(obj->address() +
7158 Context::kHeaderSize);
7159 Object** end = reinterpret_cast<Object**>(obj->address() +
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007160 Context::kHeaderSize + Context::FIRST_WEAK_SLOT * kPointerSize);
danno@chromium.org2ab0c3b2012-10-05 08:50:56 +00007161 mark_visitor->VisitPointers(start, end);
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007162 } else {
7163 obj->IterateBody(map_p->instance_type(),
7164 obj->SizeFromMap(map_p),
7165 mark_visitor);
7166 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007167
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007168 // Scan the map after the body because the body is a lot more interesting
7169 // when doing leak detection.
7170 MarkRecursively(&map, mark_visitor);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007171
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007172 if (!found_target_in_trace_) // don't pop if found the target
7173 object_stack_.RemoveLast();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007174}
7175
7176
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007177void PathTracer::UnmarkRecursively(Object** p, UnmarkVisitor* unmark_visitor) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007178 if (!(*p)->IsHeapObject()) return;
7179
7180 HeapObject* obj = HeapObject::cast(*p);
7181
7182 Object* map = obj->map();
7183
7184 if (map->IsHeapObject()) return; // unmarked already
7185
7186 Address map_addr = reinterpret_cast<Address>(map);
7187
7188 map_addr -= kMarkTag;
7189
7190 ASSERT_TAG_ALIGNED(map_addr);
7191
7192 HeapObject* map_p = HeapObject::FromAddress(map_addr);
7193
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +00007194 obj->set_map_no_write_barrier(reinterpret_cast<Map*>(map_p));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007195
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007196 UnmarkRecursively(reinterpret_cast<Object**>(&map_p), unmark_visitor);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007197
7198 obj->IterateBody(Map::cast(map_p)->instance_type(),
7199 obj->SizeFromMap(Map::cast(map_p)),
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007200 unmark_visitor);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007201}
7202
7203
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007204void PathTracer::ProcessResults() {
7205 if (found_target_) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007206 PrintF("=====================================\n");
7207 PrintF("==== Path to object ====\n");
7208 PrintF("=====================================\n\n");
7209
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007210 ASSERT(!object_stack_.is_empty());
7211 for (int i = 0; i < object_stack_.length(); i++) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007212 if (i > 0) PrintF("\n |\n |\n V\n\n");
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007213 Object* obj = object_stack_[i];
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007214 obj->Print();
7215 }
7216 PrintF("=====================================\n");
7217 }
7218}
7219
7220
ulan@chromium.orgea52b5f2012-07-30 13:05:33 +00007221// Triggers a depth-first traversal of reachable objects from one
7222// given root object and finds a path to a specific heap object and
7223// prints it.
7224void Heap::TracePathToObjectFrom(Object* target, Object* root) {
7225 PathTracer tracer(target, PathTracer::FIND_ALL, VISIT_ALL);
7226 tracer.VisitPointer(&root);
7227}
7228
7229
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007230// Triggers a depth-first traversal of reachable objects from roots
7231// and finds a path to a specific heap object and prints it.
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007232void Heap::TracePathToObject(Object* target) {
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007233 PathTracer tracer(target, PathTracer::FIND_ALL, VISIT_ALL);
7234 IterateRoots(&tracer, VISIT_ONLY_STRONG);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007235}
7236
7237
7238// Triggers a depth-first traversal of reachable objects from roots
7239// and finds a path to any global object and prints it. Useful for
7240// determining the source for leaks of global objects.
7241void Heap::TracePathToGlobal() {
fschneider@chromium.org3a5fd782011-02-24 10:10:44 +00007242 PathTracer tracer(PathTracer::kAnyGlobalObject,
7243 PathTracer::FIND_ALL,
7244 VISIT_ALL);
7245 IterateRoots(&tracer, VISIT_ONLY_STRONG);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007246}
7247#endif
7248
7249
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00007250static intptr_t CountTotalHolesSize(Heap* heap) {
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00007251 intptr_t holes_size = 0;
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00007252 OldSpaces spaces(heap);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007253 for (OldSpace* space = spaces.next();
7254 space != NULL;
7255 space = spaces.next()) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007256 holes_size += space->Waste() + space->Available();
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007257 }
7258 return holes_size;
7259}
7260
7261
rossberg@chromium.org994edf62012-02-06 10:12:55 +00007262GCTracer::GCTracer(Heap* heap,
7263 const char* gc_reason,
7264 const char* collector_reason)
kasper.lund7276f142008-07-30 08:49:36 +00007265 : start_time_(0.0),
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00007266 start_object_size_(0),
7267 start_memory_size_(0),
kasper.lund7276f142008-07-30 08:49:36 +00007268 gc_count_(0),
7269 full_gc_count_(0),
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007270 allocated_since_last_gc_(0),
7271 spent_in_mutator_(0),
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007272 promoted_objects_size_(0),
rossberg@chromium.orgcddc71f2012-12-07 12:40:13 +00007273 nodes_died_in_new_space_(0),
7274 nodes_copied_in_new_space_(0),
7275 nodes_promoted_(0),
rossberg@chromium.org994edf62012-02-06 10:12:55 +00007276 heap_(heap),
7277 gc_reason_(gc_reason),
7278 collector_reason_(collector_reason) {
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007279 if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
kasper.lund7276f142008-07-30 08:49:36 +00007280 start_time_ = OS::TimeCurrentMillis();
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00007281 start_object_size_ = heap_->SizeOfObjects();
7282 start_memory_size_ = heap_->isolate()->memory_allocator()->Size();
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007283
7284 for (int i = 0; i < Scope::kNumberOfScopes; i++) {
7285 scopes_[i] = 0;
7286 }
7287
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00007288 in_free_list_or_wasted_before_gc_ = CountTotalHolesSize(heap);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007289
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007290 allocated_since_last_gc_ =
7291 heap_->SizeOfObjects() - heap_->alive_after_last_gc_;
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007292
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007293 if (heap_->last_gc_end_timestamp_ > 0) {
7294 spent_in_mutator_ = Max(start_time_ - heap_->last_gc_end_timestamp_, 0.0);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007295 }
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007296
7297 steps_count_ = heap_->incremental_marking()->steps_count();
7298 steps_took_ = heap_->incremental_marking()->steps_took();
7299 longest_step_ = heap_->incremental_marking()->longest_step();
7300 steps_count_since_last_gc_ =
7301 heap_->incremental_marking()->steps_count_since_last_gc();
7302 steps_took_since_last_gc_ =
7303 heap_->incremental_marking()->steps_took_since_last_gc();
kasper.lund7276f142008-07-30 08:49:36 +00007304}
7305
7306
7307GCTracer::~GCTracer() {
kasper.lund7276f142008-07-30 08:49:36 +00007308 // Printf ONE line iff flag is set.
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007309 if (!FLAG_trace_gc && !FLAG_print_cumulative_gc_stat) return;
7310
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007311 bool first_gc = (heap_->last_gc_end_timestamp_ == 0);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007312
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007313 heap_->alive_after_last_gc_ = heap_->SizeOfObjects();
7314 heap_->last_gc_end_timestamp_ = OS::TimeCurrentMillis();
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007315
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007316 double time = heap_->last_gc_end_timestamp_ - start_time_;
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007317
7318 // Update cumulative GC statistics if required.
7319 if (FLAG_print_cumulative_gc_stat) {
mstarzinger@chromium.org471f2f12012-08-10 14:46:33 +00007320 heap_->total_gc_time_ms_ += time;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007321 heap_->max_gc_pause_ = Max(heap_->max_gc_pause_, time);
7322 heap_->max_alive_after_gc_ = Max(heap_->max_alive_after_gc_,
7323 heap_->alive_after_last_gc_);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007324 if (!first_gc) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007325 heap_->min_in_mutator_ = Min(heap_->min_in_mutator_,
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007326 spent_in_mutator_);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007327 }
mstarzinger@chromium.org471f2f12012-08-10 14:46:33 +00007328 } else if (FLAG_trace_gc_verbose) {
7329 heap_->total_gc_time_ms_ += time;
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007330 }
7331
mstarzinger@chromium.org471f2f12012-08-10 14:46:33 +00007332 if (collector_ == SCAVENGER && FLAG_trace_gc_ignore_scavenger) return;
7333
mstarzinger@chromium.orge3b8d0f2013-02-01 09:06:41 +00007334 heap_->AddMarkingTime(scopes_[Scope::MC_MARK]);
7335
7336 if (FLAG_print_cumulative_gc_stat && !FLAG_trace_gc) return;
rossberg@chromium.org657d53b2012-07-12 11:06:03 +00007337 PrintPID("%8.0f ms: ", heap_->isolate()->time_millis_since_init());
rossberg@chromium.org994edf62012-02-06 10:12:55 +00007338
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007339 if (!FLAG_trace_gc_nvp) {
7340 int external_time = static_cast<int>(scopes_[Scope::EXTERNAL]);
7341
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00007342 double end_memory_size_mb =
7343 static_cast<double>(heap_->isolate()->memory_allocator()->Size()) / MB;
7344
7345 PrintF("%s %.1f (%.1f) -> %.1f (%.1f) MB, ",
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007346 CollectorString(),
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00007347 static_cast<double>(start_object_size_) / MB,
7348 static_cast<double>(start_memory_size_) / MB,
7349 SizeOfHeapObjects(),
7350 end_memory_size_mb);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007351
7352 if (external_time > 0) PrintF("%d / ", external_time);
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007353 PrintF("%.1f ms", time);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007354 if (steps_count_ > 0) {
7355 if (collector_ == SCAVENGER) {
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007356 PrintF(" (+ %.1f ms in %d steps since last GC)",
7357 steps_took_since_last_gc_,
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007358 steps_count_since_last_gc_);
7359 } else {
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007360 PrintF(" (+ %.1f ms in %d steps since start of marking, "
7361 "biggest step %.1f ms)",
7362 steps_took_,
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007363 steps_count_,
7364 longest_step_);
7365 }
7366 }
rossberg@chromium.org994edf62012-02-06 10:12:55 +00007367
7368 if (gc_reason_ != NULL) {
7369 PrintF(" [%s]", gc_reason_);
7370 }
7371
7372 if (collector_reason_ != NULL) {
7373 PrintF(" [%s]", collector_reason_);
7374 }
7375
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007376 PrintF(".\n");
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007377 } else {
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007378 PrintF("pause=%.1f ", time);
7379 PrintF("mutator=%.1f ", spent_in_mutator_);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007380 PrintF("gc=");
7381 switch (collector_) {
7382 case SCAVENGER:
7383 PrintF("s");
7384 break;
7385 case MARK_COMPACTOR:
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007386 PrintF("ms");
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007387 break;
7388 default:
7389 UNREACHABLE();
7390 }
7391 PrintF(" ");
7392
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007393 PrintF("external=%.1f ", scopes_[Scope::EXTERNAL]);
7394 PrintF("mark=%.1f ", scopes_[Scope::MC_MARK]);
7395 PrintF("sweep=%.1f ", scopes_[Scope::MC_SWEEP]);
7396 PrintF("sweepns=%.1f ", scopes_[Scope::MC_SWEEP_NEWSPACE]);
7397 PrintF("evacuate=%.1f ", scopes_[Scope::MC_EVACUATE_PAGES]);
7398 PrintF("new_new=%.1f ", scopes_[Scope::MC_UPDATE_NEW_TO_NEW_POINTERS]);
7399 PrintF("root_new=%.1f ", scopes_[Scope::MC_UPDATE_ROOT_TO_NEW_POINTERS]);
7400 PrintF("old_new=%.1f ", scopes_[Scope::MC_UPDATE_OLD_TO_NEW_POINTERS]);
7401 PrintF("compaction_ptrs=%.1f ",
7402 scopes_[Scope::MC_UPDATE_POINTERS_TO_EVACUATED]);
7403 PrintF("intracompaction_ptrs=%.1f ",
7404 scopes_[Scope::MC_UPDATE_POINTERS_BETWEEN_EVACUATED]);
7405 PrintF("misc_compaction=%.1f ", scopes_[Scope::MC_UPDATE_MISC_POINTERS]);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007406
jkummerow@chromium.org1145ef82012-02-02 16:21:15 +00007407 PrintF("total_size_before=%" V8_PTR_PREFIX "d ", start_object_size_);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007408 PrintF("total_size_after=%" V8_PTR_PREFIX "d ", heap_->SizeOfObjects());
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00007409 PrintF("holes_size_before=%" V8_PTR_PREFIX "d ",
7410 in_free_list_or_wasted_before_gc_);
hpayer@chromium.org7c3372b2013-02-13 17:26:04 +00007411 PrintF("holes_size_after=%" V8_PTR_PREFIX "d ", CountTotalHolesSize(heap_));
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007412
kmillikin@chromium.orgf05f2912010-09-30 10:07:24 +00007413 PrintF("allocated=%" V8_PTR_PREFIX "d ", allocated_since_last_gc_);
7414 PrintF("promoted=%" V8_PTR_PREFIX "d ", promoted_objects_size_);
rossberg@chromium.orgcddc71f2012-12-07 12:40:13 +00007415 PrintF("nodes_died_in_new=%d ", nodes_died_in_new_space_);
7416 PrintF("nodes_copied_in_new=%d ", nodes_copied_in_new_space_);
7417 PrintF("nodes_promoted=%d ", nodes_promoted_);
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007418
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007419 if (collector_ == SCAVENGER) {
7420 PrintF("stepscount=%d ", steps_count_since_last_gc_);
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007421 PrintF("stepstook=%.1f ", steps_took_since_last_gc_);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007422 } else {
7423 PrintF("stepscount=%d ", steps_count_);
yangguo@chromium.orgc03a1922013-02-19 13:55:47 +00007424 PrintF("stepstook=%.1f ", steps_took_);
7425 PrintF("longeststep=%.1f ", longest_step_);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007426 }
7427
erik.corry@gmail.com9dfbea42010-05-21 12:58:28 +00007428 PrintF("\n");
7429 }
kasperl@chromium.orge959c182009-07-27 08:59:04 +00007430
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007431 heap_->PrintShortHeapStatistics();
kasper.lund7276f142008-07-30 08:49:36 +00007432}
7433
7434
7435const char* GCTracer::CollectorString() {
7436 switch (collector_) {
7437 case SCAVENGER:
7438 return "Scavenge";
7439 case MARK_COMPACTOR:
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007440 return "Mark-sweep";
kasper.lund7276f142008-07-30 08:49:36 +00007441 }
7442 return "Unknown GC";
7443}
7444
7445
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007446int KeyedLookupCache::Hash(Map* map, String* name) {
7447 // Uses only lower 32 bits if pointers are larger.
7448 uintptr_t addr_hash =
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007449 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map)) >> kMapHashShift;
fschneider@chromium.orgb95b98b2010-02-23 10:34:29 +00007450 return static_cast<uint32_t>((addr_hash ^ name->Hash()) & kCapacityMask);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007451}
7452
7453
7454int KeyedLookupCache::Lookup(Map* map, String* name) {
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +00007455 int index = (Hash(map, name) & kHashMask);
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00007456 for (int i = 0; i < kEntriesPerBucket; i++) {
7457 Key& key = keys_[index + i];
7458 if ((key.map == map) && key.name->Equals(name)) {
7459 return field_offsets_[index + i];
7460 }
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +00007461 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007462 return kNotFound;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007463}
7464
7465
7466void KeyedLookupCache::Update(Map* map, String* name, int field_offset) {
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00007467 String* internalized_name;
7468 if (HEAP->InternalizeStringIfExists(name, &internalized_name)) {
7469 int index = (Hash(map, internalized_name) & kHashMask);
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00007470 // After a GC there will be free slots, so we use them in order (this may
7471 // help to get the most frequently used one in position 0).
7472 for (int i = 0; i< kEntriesPerBucket; i++) {
7473 Key& key = keys_[index];
7474 Object* free_entry_indicator = NULL;
7475 if (key.map == free_entry_indicator) {
7476 key.map = map;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00007477 key.name = internalized_name;
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00007478 field_offsets_[index + i] = field_offset;
7479 return;
7480 }
7481 }
7482 // No free entry found in this bucket, so we move them all down one and
7483 // put the new entry at position zero.
7484 for (int i = kEntriesPerBucket - 1; i > 0; i--) {
7485 Key& key = keys_[index + i];
7486 Key& key2 = keys_[index + i - 1];
7487 key = key2;
7488 field_offsets_[index + i] = field_offsets_[index + i - 1];
7489 }
7490
jkummerow@chromium.org05ed9dd2012-01-23 14:42:48 +00007491 // Write the new first entry.
yangguo@chromium.org659ceec2012-01-26 07:37:54 +00007492 Key& key = keys_[index];
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007493 key.map = map;
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00007494 key.name = internalized_name;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007495 field_offsets_[index] = field_offset;
7496 }
7497}
7498
7499
7500void KeyedLookupCache::Clear() {
7501 for (int index = 0; index < kLength; index++) keys_[index].map = NULL;
7502}
7503
7504
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007505void DescriptorLookupCache::Clear() {
verwaest@chromium.org06ab2ec2012-10-09 17:00:13 +00007506 for (int index = 0; index < kLength; index++) keys_[index].source = NULL;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00007507}
7508
7509
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00007510#ifdef DEBUG
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00007511void Heap::GarbageCollectionGreedyCheck() {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00007512 ASSERT(FLAG_gc_greedy);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007513 if (isolate_->bootstrapper()->IsActive()) return;
whesse@chromium.org4a5224e2010-10-20 12:37:07 +00007514 if (disallow_allocation_failure()) return;
7515 CollectGarbage(NEW_SPACE);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00007516}
7517#endif
7518
ager@chromium.org18ad94b2009-09-02 08:22:29 +00007519
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007520TranscendentalCache::SubCache::SubCache(Type t)
7521 : type_(t),
7522 isolate_(Isolate::Current()) {
ager@chromium.org18ad94b2009-09-02 08:22:29 +00007523 uint32_t in0 = 0xffffffffu; // Bit-pattern for a NaN that isn't
7524 uint32_t in1 = 0xffffffffu; // generated by the FPU.
7525 for (int i = 0; i < kCacheSize; i++) {
7526 elements_[i].in[0] = in0;
7527 elements_[i].in[1] = in1;
7528 elements_[i].output = NULL;
7529 }
7530}
7531
7532
ager@chromium.org18ad94b2009-09-02 08:22:29 +00007533void TranscendentalCache::Clear() {
7534 for (int i = 0; i < kNumberOfCaches; i++) {
7535 if (caches_[i] != NULL) {
7536 delete caches_[i];
7537 caches_[i] = NULL;
7538 }
7539 }
7540}
7541
7542
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007543void ExternalStringTable::CleanUp() {
7544 int last = 0;
7545 for (int i = 0; i < new_space_strings_.length(); ++i) {
danno@chromium.org72204d52012-10-31 10:02:10 +00007546 if (new_space_strings_[i] == heap_->the_hole_value()) {
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00007547 continue;
7548 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007549 if (heap_->InNewSpace(new_space_strings_[i])) {
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007550 new_space_strings_[last++] = new_space_strings_[i];
7551 } else {
7552 old_space_strings_.Add(new_space_strings_[i]);
7553 }
7554 }
7555 new_space_strings_.Rewind(last);
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00007556 new_space_strings_.Trim();
7557
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007558 last = 0;
7559 for (int i = 0; i < old_space_strings_.length(); ++i) {
danno@chromium.org72204d52012-10-31 10:02:10 +00007560 if (old_space_strings_[i] == heap_->the_hole_value()) {
jkummerow@chromium.orgc3b37122011-11-07 10:14:12 +00007561 continue;
7562 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +00007563 ASSERT(!heap_->InNewSpace(old_space_strings_[i]));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007564 old_space_strings_[last++] = old_space_strings_[i];
7565 }
7566 old_space_strings_.Rewind(last);
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00007567 old_space_strings_.Trim();
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00007568#ifdef VERIFY_HEAP
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +00007569 if (FLAG_verify_heap) {
7570 Verify();
7571 }
svenpanne@chromium.orgc859c4f2012-10-15 11:51:39 +00007572#endif
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +00007573}
7574
7575
7576void ExternalStringTable::TearDown() {
7577 new_space_strings_.Free();
7578 old_space_strings_.Free();
7579}
7580
7581
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00007582// Update all references.
7583void ErrorObjectList::UpdateReferences() {
7584 for (int i = 0; i < list_.length(); i++) {
7585 HeapObject* object = HeapObject::cast(list_[i]);
7586 MapWord first_word = object->map_word();
7587 if (first_word.IsForwardingAddress()) {
7588 list_[i] = first_word.ToForwardingAddress();
7589 }
7590 }
7591}
7592
7593
7594// Unforwarded objects in new space are dead and removed from the list.
7595void ErrorObjectList::UpdateReferencesInNewSpace(Heap* heap) {
7596 if (list_.is_empty()) return;
7597 if (!nested_) {
7598 int write_index = 0;
7599 for (int i = 0; i < list_.length(); i++) {
7600 MapWord first_word = HeapObject::cast(list_[i])->map_word();
7601 if (first_word.IsForwardingAddress()) {
7602 list_[write_index++] = first_word.ToForwardingAddress();
7603 }
7604 }
7605 list_.Rewind(write_index);
7606 } else {
7607 // If a GC is triggered during DeferredFormatStackTrace, we do not move
7608 // objects in the list, just remove dead ones, as to not confuse the
7609 // loop in DeferredFormatStackTrace.
7610 for (int i = 0; i < list_.length(); i++) {
7611 MapWord first_word = HeapObject::cast(list_[i])->map_word();
7612 list_[i] = first_word.IsForwardingAddress()
7613 ? first_word.ToForwardingAddress()
7614 : heap->the_hole_value();
7615 }
7616 }
7617}
7618
7619
7620void ErrorObjectList::DeferredFormatStackTrace(Isolate* isolate) {
7621 // If formatting the stack trace causes a GC, this method will be
7622 // recursively called. In that case, skip the recursive call, since
7623 // the loop modifies the list while iterating over it.
7624 if (nested_ || list_.is_empty() || isolate->has_pending_exception()) return;
7625 nested_ = true;
7626 HandleScope scope(isolate);
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00007627 Handle<String> stack_key = isolate->factory()->stack_string();
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00007628 int write_index = 0;
7629 int budget = kBudgetPerGC;
7630 for (int i = 0; i < list_.length(); i++) {
7631 Object* object = list_[i];
7632 JSFunction* getter_fun;
7633
7634 { AssertNoAllocation assert;
7635 // Skip possible holes in the list.
7636 if (object->IsTheHole()) continue;
7637 if (isolate->heap()->InNewSpace(object) || budget == 0) {
7638 list_[write_index++] = object;
7639 continue;
7640 }
7641
7642 // Check whether the stack property is backed by the original getter.
7643 LookupResult lookup(isolate);
7644 JSObject::cast(object)->LocalLookupRealNamedProperty(*stack_key, &lookup);
7645 if (!lookup.IsFound() || lookup.type() != CALLBACKS) continue;
7646 Object* callback = lookup.GetCallbackObject();
7647 if (!callback->IsAccessorPair()) continue;
7648 Object* getter_obj = AccessorPair::cast(callback)->getter();
7649 if (!getter_obj->IsJSFunction()) continue;
7650 getter_fun = JSFunction::cast(getter_obj);
yangguo@chromium.org4a9f6552013-03-04 14:46:33 +00007651 String* key = isolate->heap()->hidden_stack_trace_string();
yangguo@chromium.org46a2a512013-01-18 16:29:40 +00007652 if (key != getter_fun->GetHiddenProperty(key)) continue;
7653 }
7654
7655 budget--;
7656 HandleScope scope(isolate);
7657 bool has_exception = false;
7658#ifdef DEBUG
7659 Handle<Map> map(HeapObject::cast(object)->map(), isolate);
7660#endif
7661 Handle<Object> object_handle(object, isolate);
7662 Handle<Object> getter_handle(getter_fun, isolate);
7663 Execution::Call(getter_handle, object_handle, 0, NULL, &has_exception);
7664 ASSERT(*map == HeapObject::cast(*object_handle)->map());
7665 if (has_exception) {
7666 // Hit an exception (most likely a stack overflow).
7667 // Wrap up this pass and retry after another GC.
7668 isolate->clear_pending_exception();
7669 // We use the handle since calling the getter might have caused a GC.
7670 list_[write_index++] = *object_handle;
7671 budget = 0;
7672 }
7673 }
7674 list_.Rewind(write_index);
7675 list_.Trim();
7676 nested_ = false;
7677}
7678
7679
7680void ErrorObjectList::RemoveUnmarked(Heap* heap) {
7681 for (int i = 0; i < list_.length(); i++) {
7682 HeapObject* object = HeapObject::cast(list_[i]);
7683 if (!Marking::MarkBitFrom(object).Get()) {
7684 list_[i] = heap->the_hole_value();
7685 }
7686 }
7687}
7688
7689
7690void ErrorObjectList::TearDown() {
7691 list_.Free();
7692}
7693
7694
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007695void Heap::QueueMemoryChunkForFree(MemoryChunk* chunk) {
7696 chunk->set_next_chunk(chunks_queued_for_free_);
7697 chunks_queued_for_free_ = chunk;
7698}
7699
7700
7701void Heap::FreeQueuedChunks() {
7702 if (chunks_queued_for_free_ == NULL) return;
7703 MemoryChunk* next;
7704 MemoryChunk* chunk;
7705 for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
7706 next = chunk->next_chunk();
7707 chunk->SetFlag(MemoryChunk::ABOUT_TO_BE_FREED);
7708
7709 if (chunk->owner()->identity() == LO_SPACE) {
7710 // StoreBuffer::Filter relies on MemoryChunk::FromAnyPointerAddress.
7711 // If FromAnyPointerAddress encounters a slot that belongs to a large
7712 // chunk queued for deletion it will fail to find the chunk because
7713 // it try to perform a search in the list of pages owned by of the large
7714 // object space and queued chunks were detached from that list.
7715 // To work around this we split large chunk into normal kPageSize aligned
danno@chromium.org2c456792011-11-11 12:00:53 +00007716 // pieces and initialize size, owner and flags field of every piece.
7717 // If FromAnyPointerAddress encounters a slot that belongs to one of
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007718 // these smaller pieces it will treat it as a slot on a normal Page.
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00007719 Address chunk_end = chunk->address() + chunk->size();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007720 MemoryChunk* inner = MemoryChunk::FromAddress(
7721 chunk->address() + Page::kPageSize);
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00007722 MemoryChunk* inner_last = MemoryChunk::FromAddress(chunk_end - 1);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007723 while (inner <= inner_last) {
7724 // Size of a large chunk is always a multiple of
jkummerow@chromium.org04e4f1e2011-11-14 13:36:17 +00007725 // OS::AllocateAlignment() so there is always
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007726 // enough space for a fake MemoryChunk header.
ulan@chromium.org9a21ec42012-03-06 08:42:24 +00007727 Address area_end = Min(inner->address() + Page::kPageSize, chunk_end);
7728 // Guard against overflow.
7729 if (area_end < inner->address()) area_end = chunk_end;
7730 inner->SetArea(inner->address(), area_end);
danno@chromium.org2c456792011-11-11 12:00:53 +00007731 inner->set_size(Page::kPageSize);
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +00007732 inner->set_owner(lo_space());
7733 inner->SetFlag(MemoryChunk::ABOUT_TO_BE_FREED);
7734 inner = MemoryChunk::FromAddress(
7735 inner->address() + Page::kPageSize);
7736 }
7737 }
7738 }
7739 isolate_->heap()->store_buffer()->Compact();
7740 isolate_->heap()->store_buffer()->Filter(MemoryChunk::ABOUT_TO_BE_FREED);
7741 for (chunk = chunks_queued_for_free_; chunk != NULL; chunk = next) {
7742 next = chunk->next_chunk();
7743 isolate_->memory_allocator()->Free(chunk);
7744 }
7745 chunks_queued_for_free_ = NULL;
7746}
7747
rossberg@chromium.org2c067b12012-03-19 11:01:52 +00007748
7749void Heap::RememberUnmappedPage(Address page, bool compacted) {
7750 uintptr_t p = reinterpret_cast<uintptr_t>(page);
7751 // Tag the page pointer to make it findable in the dump file.
7752 if (compacted) {
7753 p ^= 0xc1ead & (Page::kPageSize - 1); // Cleared.
7754 } else {
7755 p ^= 0x1d1ed & (Page::kPageSize - 1); // I died.
7756 }
7757 remembered_unmapped_pages_[remembered_unmapped_pages_index_] =
7758 reinterpret_cast<Address>(p);
7759 remembered_unmapped_pages_index_++;
7760 remembered_unmapped_pages_index_ %= kRememberedUnmappedPages;
7761}
7762
jkummerow@chromium.org28583c92012-07-16 11:31:55 +00007763
7764void Heap::ClearObjectStats(bool clear_last_time_stats) {
7765 memset(object_counts_, 0, sizeof(object_counts_));
7766 memset(object_sizes_, 0, sizeof(object_sizes_));
7767 if (clear_last_time_stats) {
7768 memset(object_counts_last_time_, 0, sizeof(object_counts_last_time_));
7769 memset(object_sizes_last_time_, 0, sizeof(object_sizes_last_time_));
7770 }
7771}
7772
7773
7774static LazyMutex checkpoint_object_stats_mutex = LAZY_MUTEX_INITIALIZER;
7775
7776
7777void Heap::CheckpointObjectStats() {
7778 ScopedLock lock(checkpoint_object_stats_mutex.Pointer());
7779 Counters* counters = isolate()->counters();
7780#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
7781 counters->count_of_##name()->Increment( \
7782 static_cast<int>(object_counts_[name])); \
7783 counters->count_of_##name()->Decrement( \
7784 static_cast<int>(object_counts_last_time_[name])); \
7785 counters->size_of_##name()->Increment( \
7786 static_cast<int>(object_sizes_[name])); \
7787 counters->size_of_##name()->Decrement( \
7788 static_cast<int>(object_sizes_last_time_[name]));
7789 INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
7790#undef ADJUST_LAST_TIME_OBJECT_COUNT
verwaest@chromium.org753aee42012-07-17 16:15:42 +00007791 int index;
7792#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
7793 index = FIRST_CODE_KIND_SUB_TYPE + Code::name; \
7794 counters->count_of_CODE_TYPE_##name()->Increment( \
7795 static_cast<int>(object_counts_[index])); \
7796 counters->count_of_CODE_TYPE_##name()->Decrement( \
7797 static_cast<int>(object_counts_last_time_[index])); \
7798 counters->size_of_CODE_TYPE_##name()->Increment( \
7799 static_cast<int>(object_sizes_[index])); \
7800 counters->size_of_CODE_TYPE_##name()->Decrement( \
7801 static_cast<int>(object_sizes_last_time_[index]));
7802 CODE_KIND_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
7803#undef ADJUST_LAST_TIME_OBJECT_COUNT
yangguo@chromium.org304cc332012-07-24 07:59:48 +00007804#define ADJUST_LAST_TIME_OBJECT_COUNT(name) \
7805 index = FIRST_FIXED_ARRAY_SUB_TYPE + name; \
7806 counters->count_of_FIXED_ARRAY_##name()->Increment( \
7807 static_cast<int>(object_counts_[index])); \
7808 counters->count_of_FIXED_ARRAY_##name()->Decrement( \
7809 static_cast<int>(object_counts_last_time_[index])); \
7810 counters->size_of_FIXED_ARRAY_##name()->Increment( \
7811 static_cast<int>(object_sizes_[index])); \
7812 counters->size_of_FIXED_ARRAY_##name()->Decrement( \
7813 static_cast<int>(object_sizes_last_time_[index]));
7814 FIXED_ARRAY_SUB_INSTANCE_TYPE_LIST(ADJUST_LAST_TIME_OBJECT_COUNT)
7815#undef ADJUST_LAST_TIME_OBJECT_COUNT
verwaest@chromium.org753aee42012-07-17 16:15:42 +00007816
jkummerow@chromium.org28583c92012-07-16 11:31:55 +00007817 memcpy(object_counts_last_time_, object_counts_, sizeof(object_counts_));
7818 memcpy(object_sizes_last_time_, object_sizes_, sizeof(object_sizes_));
7819 ClearObjectStats();
7820}
7821
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00007822} } // namespace v8::internal