blob: 1a80d64784c329875f07648b262be0c817b45872 [file] [log] [blame]
ager@chromium.org71daaf62009-04-01 07:22:49 +00001// Copyright 2009 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"
33#include "codegen-inl.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"
christian.plesner.hansen@gmail.com2bc58ef2009-09-22 10:00:30 +000036#include "heap-profiler.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000037#include "global-handles.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000038#include "mark-compact.h"
39#include "natives.h"
40#include "scanner.h"
41#include "scopeinfo.h"
42#include "v8threads.h"
ager@chromium.org18ad94b2009-09-02 08:22:29 +000043#if V8_TARGET_ARCH_ARM && V8_NATIVE_REGEXP
44#include "regexp-macro-assembler.h"
45#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000046
kasperl@chromium.org71affb52009-05-26 05:44:31 +000047namespace v8 {
48namespace internal {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000049
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000050
ager@chromium.org3b45ab52009-03-19 22:21:34 +000051String* Heap::hidden_symbol_;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +000052Object* Heap::roots_[Heap::kRootListLength];
53
ager@chromium.org3b45ab52009-03-19 22:21:34 +000054
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +000055NewSpace Heap::new_space_;
ager@chromium.org9258b6b2008-09-11 09:11:10 +000056OldSpace* Heap::old_pointer_space_ = NULL;
57OldSpace* Heap::old_data_space_ = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000058OldSpace* Heap::code_space_ = NULL;
59MapSpace* Heap::map_space_ = NULL;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +000060CellSpace* Heap::cell_space_ = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000061LargeObjectSpace* Heap::lo_space_ = NULL;
62
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +000063static const int kMinimumPromotionLimit = 2*MB;
64static const int kMinimumAllocationLimit = 8*MB;
65
66int Heap::old_gen_promotion_limit_ = kMinimumPromotionLimit;
67int Heap::old_gen_allocation_limit_ = kMinimumAllocationLimit;
68
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000069int Heap::old_gen_exhausted_ = false;
70
kasper.lund7276f142008-07-30 08:49:36 +000071int Heap::amount_of_external_allocated_memory_ = 0;
72int Heap::amount_of_external_allocated_memory_at_last_global_gc_ = 0;
73
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000074// semispace_size_ should be a power of 2 and old_generation_size_ should be
75// a multiple of Page::kPageSize.
kasperl@chromium.orge959c182009-07-27 08:59:04 +000076#if defined(ANDROID)
ager@chromium.orgeadaf222009-06-16 09:43:10 +000077int Heap::semispace_size_ = 512*KB;
78int Heap::old_generation_size_ = 128*MB;
79int Heap::initial_semispace_size_ = 128*KB;
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +000080#elif defined(V8_TARGET_ARCH_X64)
ager@chromium.orga1645e22009-09-09 19:27:10 +000081int Heap::semispace_size_ = 16*MB;
sgjesse@chromium.org911335c2009-08-19 12:59:44 +000082int Heap::old_generation_size_ = 1*GB;
83int Heap::initial_semispace_size_ = 1*MB;
ager@chromium.orgeadaf222009-06-16 09:43:10 +000084#else
ager@chromium.orga1645e22009-09-09 19:27:10 +000085int Heap::semispace_size_ = 8*MB;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000086int Heap::old_generation_size_ = 512*MB;
ager@chromium.orgeadaf222009-06-16 09:43:10 +000087int Heap::initial_semispace_size_ = 512*KB;
88#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000089
90GCCallback Heap::global_gc_prologue_callback_ = NULL;
91GCCallback Heap::global_gc_epilogue_callback_ = NULL;
92
93// Variables set based on semispace_size_ and old_generation_size_ in
94// ConfigureHeap.
95int Heap::young_generation_size_ = 0; // Will be 2 * semispace_size_.
ager@chromium.orgeadaf222009-06-16 09:43:10 +000096int Heap::survived_since_last_expansion_ = 0;
kasperl@chromium.orge959c182009-07-27 08:59:04 +000097int Heap::external_allocation_limit_ = 0;
ager@chromium.orgeadaf222009-06-16 09:43:10 +000098
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000099Heap::HeapState Heap::gc_state_ = NOT_IN_GC;
100
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000101int Heap::mc_count_ = 0;
102int Heap::gc_count_ = 0;
103
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000104int Heap::always_allocate_scope_depth_ = 0;
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000105bool Heap::context_disposed_pending_ = false;
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000106
kasper.lund7276f142008-07-30 08:49:36 +0000107#ifdef DEBUG
108bool Heap::allocation_allowed_ = true;
109
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000110int Heap::allocation_timeout_ = 0;
111bool Heap::disallow_allocation_failure_ = false;
112#endif // DEBUG
113
114
115int Heap::Capacity() {
116 if (!HasBeenSetup()) return 0;
117
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000118 return new_space_.Capacity() +
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000119 old_pointer_space_->Capacity() +
120 old_data_space_->Capacity() +
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000121 code_space_->Capacity() +
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000122 map_space_->Capacity() +
123 cell_space_->Capacity();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000124}
125
126
127int Heap::Available() {
128 if (!HasBeenSetup()) return 0;
129
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000130 return new_space_.Available() +
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000131 old_pointer_space_->Available() +
132 old_data_space_->Available() +
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000133 code_space_->Available() +
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000134 map_space_->Available() +
135 cell_space_->Available();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000136}
137
138
139bool Heap::HasBeenSetup() {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000140 return old_pointer_space_ != NULL &&
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000141 old_data_space_ != NULL &&
142 code_space_ != NULL &&
143 map_space_ != NULL &&
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000144 cell_space_ != NULL &&
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000145 lo_space_ != NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000146}
147
148
149GarbageCollector Heap::SelectGarbageCollector(AllocationSpace space) {
150 // Is global GC requested?
151 if (space != NEW_SPACE || FLAG_gc_global) {
152 Counters::gc_compactor_caused_by_request.Increment();
153 return MARK_COMPACTOR;
154 }
155
156 // Is enough data promoted to justify a global GC?
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000157 if (OldGenerationPromotionLimitReached()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000158 Counters::gc_compactor_caused_by_promoted_data.Increment();
159 return MARK_COMPACTOR;
160 }
161
162 // Have allocation in OLD and LO failed?
163 if (old_gen_exhausted_) {
164 Counters::gc_compactor_caused_by_oldspace_exhaustion.Increment();
165 return MARK_COMPACTOR;
166 }
167
168 // Is there enough space left in OLD to guarantee that a scavenge can
169 // succeed?
170 //
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000171 // Note that MemoryAllocator->MaxAvailable() undercounts the memory available
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000172 // for object promotion. It counts only the bytes that the memory
173 // allocator has not yet allocated from the OS and assigned to any space,
174 // and does not count available bytes already in the old space or code
175 // space. Undercounting is safe---we may get an unrequested full GC when
176 // a scavenge would have succeeded.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000177 if (MemoryAllocator::MaxAvailable() <= new_space_.Size()) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000178 Counters::gc_compactor_caused_by_oldspace_exhaustion.Increment();
179 return MARK_COMPACTOR;
180 }
181
182 // Default
183 return SCAVENGER;
184}
185
186
187// TODO(1238405): Combine the infrastructure for --heap-stats and
188// --log-gc to avoid the complicated preprocessor and flag testing.
189#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
190void Heap::ReportStatisticsBeforeGC() {
191 // Heap::ReportHeapStatistics will also log NewSpace statistics when
192 // compiled with ENABLE_LOGGING_AND_PROFILING and --log-gc is set. The
193 // following logic is used to avoid double logging.
194#if defined(DEBUG) && defined(ENABLE_LOGGING_AND_PROFILING)
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000195 if (FLAG_heap_stats || FLAG_log_gc) new_space_.CollectStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000196 if (FLAG_heap_stats) {
197 ReportHeapStatistics("Before GC");
198 } else if (FLAG_log_gc) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000199 new_space_.ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000200 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000201 if (FLAG_heap_stats || FLAG_log_gc) new_space_.ClearHistograms();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000202#elif defined(DEBUG)
203 if (FLAG_heap_stats) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000204 new_space_.CollectStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000205 ReportHeapStatistics("Before GC");
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000206 new_space_.ClearHistograms();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000207 }
208#elif defined(ENABLE_LOGGING_AND_PROFILING)
209 if (FLAG_log_gc) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000210 new_space_.CollectStatistics();
211 new_space_.ReportStatistics();
212 new_space_.ClearHistograms();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000213 }
214#endif
215}
216
217
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000218#if defined(ENABLE_LOGGING_AND_PROFILING)
219void Heap::PrintShortHeapStatistics() {
220 if (!FLAG_trace_gc_verbose) return;
221 PrintF("Memory allocator, used: %8d, available: %8d\n",
222 MemoryAllocator::Size(), MemoryAllocator::Available());
223 PrintF("New space, used: %8d, available: %8d\n",
224 Heap::new_space_.Size(), new_space_.Available());
225 PrintF("Old pointers, used: %8d, available: %8d\n",
226 old_pointer_space_->Size(), old_pointer_space_->Available());
227 PrintF("Old data space, used: %8d, available: %8d\n",
228 old_data_space_->Size(), old_data_space_->Available());
229 PrintF("Code space, used: %8d, available: %8d\n",
230 code_space_->Size(), code_space_->Available());
231 PrintF("Map space, used: %8d, available: %8d\n",
232 map_space_->Size(), map_space_->Available());
233 PrintF("Large object space, used: %8d, avaialble: %8d\n",
234 lo_space_->Size(), lo_space_->Available());
235}
236#endif
237
238
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000239// TODO(1238405): Combine the infrastructure for --heap-stats and
240// --log-gc to avoid the complicated preprocessor and flag testing.
241void Heap::ReportStatisticsAfterGC() {
242 // Similar to the before GC, we use some complicated logic to ensure that
243 // NewSpace statistics are logged exactly once when --log-gc is turned on.
244#if defined(DEBUG) && defined(ENABLE_LOGGING_AND_PROFILING)
245 if (FLAG_heap_stats) {
kasperl@chromium.org2abc4502009-07-02 07:00:29 +0000246 new_space_.CollectStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000247 ReportHeapStatistics("After GC");
248 } else if (FLAG_log_gc) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000249 new_space_.ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000250 }
251#elif defined(DEBUG)
252 if (FLAG_heap_stats) ReportHeapStatistics("After GC");
253#elif defined(ENABLE_LOGGING_AND_PROFILING)
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000254 if (FLAG_log_gc) new_space_.ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000255#endif
256}
257#endif // defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
258
259
260void Heap::GarbageCollectionPrologue() {
ager@chromium.org18ad94b2009-09-02 08:22:29 +0000261 TranscendentalCache::Clear();
kasper.lund7276f142008-07-30 08:49:36 +0000262 gc_count_++;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000263#ifdef DEBUG
264 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
265 allow_allocation(false);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000266
267 if (FLAG_verify_heap) {
268 Verify();
269 }
270
271 if (FLAG_gc_verbose) Print();
272
273 if (FLAG_print_rset) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000274 // Not all spaces have remembered set bits that we care about.
275 old_pointer_space_->PrintRSet();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000276 map_space_->PrintRSet();
277 lo_space_->PrintRSet();
278 }
279#endif
280
281#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
282 ReportStatisticsBeforeGC();
283#endif
284}
285
286int Heap::SizeOfObjects() {
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000287 int total = 0;
288 AllSpaces spaces;
sgjesse@chromium.org911335c2009-08-19 12:59:44 +0000289 while (Space* space = spaces.next()) {
290 total += space->Size();
291 }
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000292 return total;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000293}
294
295void Heap::GarbageCollectionEpilogue() {
296#ifdef DEBUG
297 allow_allocation(true);
298 ZapFromSpace();
299
300 if (FLAG_verify_heap) {
301 Verify();
302 }
303
304 if (FLAG_print_global_handles) GlobalHandles::Print();
305 if (FLAG_print_handles) PrintHandles();
306 if (FLAG_gc_verbose) Print();
307 if (FLAG_code_stats) ReportCodeStatistics("After GC");
308#endif
309
310 Counters::alive_after_last_gc.Set(SizeOfObjects());
311
kasperl@chromium.org68ac0092009-07-09 06:00:35 +0000312 Counters::symbol_table_capacity.Set(symbol_table()->Capacity());
313 Counters::number_of_symbols.Set(symbol_table()->NumberOfElements());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000314#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
315 ReportStatisticsAfterGC();
316#endif
kasperl@chromium.org71affb52009-05-26 05:44:31 +0000317#ifdef ENABLE_DEBUGGER_SUPPORT
318 Debug::AfterGarbageCollection();
319#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000320}
321
322
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +0000323void Heap::CollectAllGarbage(bool force_compaction) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000324 // Since we are ignoring the return value, the exact choice of space does
325 // not matter, so long as we do not specify NEW_SPACE, which would not
326 // cause a full GC.
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +0000327 MarkCompactCollector::SetForceCompaction(force_compaction);
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000328 CollectGarbage(0, OLD_POINTER_SPACE);
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +0000329 MarkCompactCollector::SetForceCompaction(false);
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000330}
331
332
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000333void Heap::CollectAllGarbageIfContextDisposed() {
kasperl@chromium.orgd55d36b2009-03-05 08:03:28 +0000334 // If the garbage collector interface is exposed through the global
335 // gc() function, we avoid being clever about forcing GCs when
336 // contexts are disposed and leave it to the embedder to make
337 // informed decisions about when to force a collection.
338 if (!FLAG_expose_gc && context_disposed_pending_) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +0000339 HistogramTimerScope scope(&Counters::gc_context);
ager@chromium.orgab99eea2009-08-25 07:05:41 +0000340 CollectAllGarbage(false);
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000341 }
kasperl@chromium.orgd55d36b2009-03-05 08:03:28 +0000342 context_disposed_pending_ = false;
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000343}
344
345
346void Heap::NotifyContextDisposed() {
347 context_disposed_pending_ = true;
348}
349
350
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000351bool Heap::CollectGarbage(int requested_size, AllocationSpace space) {
352 // The VM is in the GC state until exiting this function.
353 VMState state(GC);
354
355#ifdef DEBUG
356 // Reset the allocation timeout to the GC interval, but make sure to
357 // allow at least a few allocations after a collection. The reason
358 // for this is that we have a lot of allocation sequences and we
359 // assume that a garbage collection will allow the subsequent
360 // allocation attempts to go through.
361 allocation_timeout_ = Max(6, FLAG_gc_interval);
362#endif
363
364 { GCTracer tracer;
365 GarbageCollectionPrologue();
kasper.lund7276f142008-07-30 08:49:36 +0000366 // The GC count was incremented in the prologue. Tell the tracer about
367 // it.
368 tracer.set_gc_count(gc_count_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000369
370 GarbageCollector collector = SelectGarbageCollector(space);
kasper.lund7276f142008-07-30 08:49:36 +0000371 // Tell the tracer which collector we've selected.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000372 tracer.set_collector(collector);
373
ager@chromium.orgbb29dc92009-03-24 13:25:23 +0000374 HistogramTimer* rate = (collector == SCAVENGER)
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000375 ? &Counters::gc_scavenger
376 : &Counters::gc_compactor;
377 rate->Start();
kasper.lund7276f142008-07-30 08:49:36 +0000378 PerformGarbageCollection(space, collector, &tracer);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000379 rate->Stop();
380
381 GarbageCollectionEpilogue();
382 }
383
384
385#ifdef ENABLE_LOGGING_AND_PROFILING
386 if (FLAG_log_gc) HeapProfiler::WriteSample();
387#endif
388
389 switch (space) {
390 case NEW_SPACE:
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000391 return new_space_.Available() >= requested_size;
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000392 case OLD_POINTER_SPACE:
393 return old_pointer_space_->Available() >= requested_size;
394 case OLD_DATA_SPACE:
395 return old_data_space_->Available() >= requested_size;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000396 case CODE_SPACE:
397 return code_space_->Available() >= requested_size;
398 case MAP_SPACE:
399 return map_space_->Available() >= requested_size;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000400 case CELL_SPACE:
401 return cell_space_->Available() >= requested_size;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000402 case LO_SPACE:
403 return lo_space_->Available() >= requested_size;
404 }
405 return false;
406}
407
408
kasper.lund7276f142008-07-30 08:49:36 +0000409void Heap::PerformScavenge() {
410 GCTracer tracer;
411 PerformGarbageCollection(NEW_SPACE, SCAVENGER, &tracer);
412}
413
414
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000415#ifdef DEBUG
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000416// Helper class for verifying the symbol table.
417class SymbolTableVerifier : public ObjectVisitor {
418 public:
419 SymbolTableVerifier() { }
420 void VisitPointers(Object** start, Object** end) {
421 // Visit all HeapObject pointers in [start, end).
422 for (Object** p = start; p < end; p++) {
423 if ((*p)->IsHeapObject()) {
424 // Check that the symbol is actually a symbol.
425 ASSERT((*p)->IsNull() || (*p)->IsUndefined() || (*p)->IsSymbol());
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000426 }
427 }
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000428 }
429};
430#endif // DEBUG
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000431
kasperl@chromium.org416c5b02009-04-14 14:03:52 +0000432
433static void VerifySymbolTable() {
434#ifdef DEBUG
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000435 SymbolTableVerifier verifier;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +0000436 Heap::symbol_table()->IterateElements(&verifier);
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000437#endif // DEBUG
438}
439
440
ager@chromium.orgadd848f2009-08-13 12:44:13 +0000441void Heap::EnsureFromSpaceIsCommitted() {
442 if (new_space_.CommitFromSpaceIfNeeded()) return;
443
444 // Committing memory to from space failed.
445 // Try shrinking and try again.
446 Shrink();
447 if (new_space_.CommitFromSpaceIfNeeded()) return;
448
449 // Committing memory to from space failed again.
450 // Memory is exhausted and we will die.
451 V8::FatalProcessOutOfMemory("Committing semi space failed.");
452}
453
454
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000455void Heap::PerformGarbageCollection(AllocationSpace space,
kasper.lund7276f142008-07-30 08:49:36 +0000456 GarbageCollector collector,
457 GCTracer* tracer) {
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000458 VerifySymbolTable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000459 if (collector == MARK_COMPACTOR && global_gc_prologue_callback_) {
460 ASSERT(!allocation_allowed_);
461 global_gc_prologue_callback_();
462 }
ager@chromium.orgadd848f2009-08-13 12:44:13 +0000463 EnsureFromSpaceIsCommitted();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000464 if (collector == MARK_COMPACTOR) {
kasper.lund7276f142008-07-30 08:49:36 +0000465 MarkCompact(tracer);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000466
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000467 int old_gen_size = PromotedSpaceSize();
468 old_gen_promotion_limit_ =
469 old_gen_size + Max(kMinimumPromotionLimit, old_gen_size / 3);
470 old_gen_allocation_limit_ =
ager@chromium.orgeadaf222009-06-16 09:43:10 +0000471 old_gen_size + Max(kMinimumAllocationLimit, old_gen_size / 2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000472 old_gen_exhausted_ = false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000473 }
ager@chromium.org439e85a2009-08-26 13:15:29 +0000474 Scavenge();
475
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000476 Counters::objs_since_last_young.Set(0);
477
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000478 PostGarbageCollectionProcessing();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000479
kasper.lund7276f142008-07-30 08:49:36 +0000480 if (collector == MARK_COMPACTOR) {
481 // Register the amount of external allocated memory.
482 amount_of_external_allocated_memory_at_last_global_gc_ =
483 amount_of_external_allocated_memory_;
484 }
485
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000486 if (collector == MARK_COMPACTOR && global_gc_epilogue_callback_) {
487 ASSERT(!allocation_allowed_);
488 global_gc_epilogue_callback_();
489 }
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000490 VerifySymbolTable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000491}
492
493
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000494void Heap::PostGarbageCollectionProcessing() {
495 // Process weak handles post gc.
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +0000496 {
497 DisableAssertNoAllocation allow_allocation;
498 GlobalHandles::PostGarbageCollectionProcessing();
499 }
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000500 // Update flat string readers.
501 FlatStringReader::PostGarbageCollectionProcessing();
502}
503
504
kasper.lund7276f142008-07-30 08:49:36 +0000505void Heap::MarkCompact(GCTracer* tracer) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000506 gc_state_ = MARK_COMPACT;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000507 mc_count_++;
kasper.lund7276f142008-07-30 08:49:36 +0000508 tracer->set_full_gc_count(mc_count_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000509 LOG(ResourceEvent("markcompact", "begin"));
510
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000511 MarkCompactCollector::Prepare(tracer);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000512
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000513 bool is_compacting = MarkCompactCollector::IsCompacting();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000514
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000515 MarkCompactPrologue(is_compacting);
516
517 MarkCompactCollector::CollectGarbage();
518
519 MarkCompactEpilogue(is_compacting);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000520
521 LOG(ResourceEvent("markcompact", "end"));
522
523 gc_state_ = NOT_IN_GC;
524
525 Shrink();
526
527 Counters::objs_since_last_full.Set(0);
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000528 context_disposed_pending_ = false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000529}
530
531
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000532void Heap::MarkCompactPrologue(bool is_compacting) {
533 // At any old GC clear the keyed lookup cache to enable collection of unused
534 // maps.
ager@chromium.org5aa501c2009-06-23 07:57:28 +0000535 KeyedLookupCache::Clear();
536 ContextSlotCache::Clear();
537 DescriptorLookupCache::Clear();
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000538
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000539 CompilationCache::MarkCompactPrologue();
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000540
541 Top::MarkCompactPrologue(is_compacting);
542 ThreadManager::MarkCompactPrologue(is_compacting);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000543}
544
545
kasperl@chromium.org061ef742009-02-27 12:16:20 +0000546void Heap::MarkCompactEpilogue(bool is_compacting) {
547 Top::MarkCompactEpilogue(is_compacting);
548 ThreadManager::MarkCompactEpilogue(is_compacting);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000549}
550
551
552Object* Heap::FindCodeObject(Address a) {
553 Object* obj = code_space_->FindObject(a);
554 if (obj->IsFailure()) {
555 obj = lo_space_->FindObject(a);
556 }
kasper.lund7276f142008-07-30 08:49:36 +0000557 ASSERT(!obj->IsFailure());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000558 return obj;
559}
560
561
562// Helper class for copying HeapObjects
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000563class ScavengeVisitor: public ObjectVisitor {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000564 public:
565
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000566 void VisitPointer(Object** p) { ScavengePointer(p); }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000567
568 void VisitPointers(Object** start, Object** end) {
569 // Copy all HeapObject pointers in [start, end)
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000570 for (Object** p = start; p < end; p++) ScavengePointer(p);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000571 }
572
573 private:
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000574 void ScavengePointer(Object** p) {
575 Object* object = *p;
576 if (!Heap::InNewSpace(object)) return;
577 Heap::ScavengeObject(reinterpret_cast<HeapObject**>(p),
578 reinterpret_cast<HeapObject*>(object));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000579 }
580};
581
582
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000583// A queue of pointers and maps of to-be-promoted objects during a
584// scavenge collection.
585class PromotionQueue {
586 public:
587 void Initialize(Address start_address) {
588 front_ = rear_ = reinterpret_cast<HeapObject**>(start_address);
589 }
590
591 bool is_empty() { return front_ <= rear_; }
592
593 void insert(HeapObject* object, Map* map) {
594 *(--rear_) = object;
595 *(--rear_) = map;
596 // Assert no overflow into live objects.
597 ASSERT(reinterpret_cast<Address>(rear_) >= Heap::new_space()->top());
598 }
599
600 void remove(HeapObject** object, Map** map) {
601 *object = *(--front_);
602 *map = Map::cast(*(--front_));
603 // Assert no underflow.
604 ASSERT(front_ >= rear_);
605 }
606
607 private:
608 // The front of the queue is higher in memory than the rear.
609 HeapObject** front_;
610 HeapObject** rear_;
611};
612
613
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000614// Shared state read by the scavenge collector and set by ScavengeObject.
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000615static PromotionQueue promotion_queue;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000616
617
618#ifdef DEBUG
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000619// Visitor class to verify pointers in code or data space do not point into
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000620// new space.
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000621class VerifyNonPointerSpacePointersVisitor: public ObjectVisitor {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000622 public:
623 void VisitPointers(Object** start, Object**end) {
624 for (Object** current = start; current < end; current++) {
625 if ((*current)->IsHeapObject()) {
626 ASSERT(!Heap::InNewSpace(HeapObject::cast(*current)));
627 }
628 }
629 }
630};
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000631
632
633static void VerifyNonPointerSpacePointers() {
634 // Verify that there are no pointers to new space in spaces where we
635 // do not expect them.
636 VerifyNonPointerSpacePointersVisitor v;
637 HeapObjectIterator code_it(Heap::code_space());
638 while (code_it.has_next()) {
639 HeapObject* object = code_it.next();
christian.plesner.hansen@gmail.com2bc58ef2009-09-22 10:00:30 +0000640 object->Iterate(&v);
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000641 }
642
643 HeapObjectIterator data_it(Heap::old_data_space());
644 while (data_it.has_next()) data_it.next()->Iterate(&v);
645}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000646#endif
647
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000648
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000649void Heap::Scavenge() {
650#ifdef DEBUG
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000651 if (FLAG_enable_slow_asserts) VerifyNonPointerSpacePointers();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000652#endif
653
654 gc_state_ = SCAVENGE;
655
656 // Implements Cheney's copying algorithm
657 LOG(ResourceEvent("scavenge", "begin"));
658
ager@chromium.org5aa501c2009-06-23 07:57:28 +0000659 // Clear descriptor cache.
660 DescriptorLookupCache::Clear();
661
ager@chromium.orgeadaf222009-06-16 09:43:10 +0000662 // Used for updating survived_since_last_expansion_ at function end.
663 int survived_watermark = PromotedSpaceSize();
664
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000665 if (new_space_.Capacity() < new_space_.MaximumCapacity() &&
ager@chromium.orgeadaf222009-06-16 09:43:10 +0000666 survived_since_last_expansion_ > new_space_.Capacity()) {
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +0000667 // Grow the size of new space if there is room to grow and enough
ager@chromium.orgeadaf222009-06-16 09:43:10 +0000668 // data has survived scavenge since the last expansion.
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +0000669 new_space_.Grow();
ager@chromium.orgeadaf222009-06-16 09:43:10 +0000670 survived_since_last_expansion_ = 0;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000671 }
672
673 // Flip the semispaces. After flipping, to space is empty, from space has
674 // live objects.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000675 new_space_.Flip();
676 new_space_.ResetAllocationInfo();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000677
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000678 // We need to sweep newly copied objects which can be either in the
679 // to space or promoted to the old generation. For to-space
680 // objects, we treat the bottom of the to space as a queue. Newly
681 // copied and unswept objects lie between a 'front' mark and the
682 // allocation pointer.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000683 //
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000684 // Promoted objects can go into various old-generation spaces, and
685 // can be allocated internally in the spaces (from the free list).
686 // We treat the top of the to space as a queue of addresses of
687 // promoted objects. The addresses of newly promoted and unswept
688 // objects lie between a 'front' mark and a 'rear' mark that is
689 // updated as a side effect of promoting an object.
690 //
691 // There is guaranteed to be enough room at the top of the to space
692 // for the addresses of promoted objects: every object promoted
693 // frees up its size in bytes from the top of the new space, and
694 // objects are at least one pointer in size.
695 Address new_space_front = new_space_.ToSpaceLow();
696 promotion_queue.Initialize(new_space_.ToSpaceHigh());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000697
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000698 ScavengeVisitor scavenge_visitor;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000699 // Copy roots.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000700 IterateRoots(&scavenge_visitor);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000701
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000702 // Copy objects reachable from weak pointers.
703 GlobalHandles::IterateWeakRoots(&scavenge_visitor);
704
705 // Copy objects reachable from the old generation. By definition,
706 // there are no intergenerational pointers in code or data spaces.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000707 IterateRSet(old_pointer_space_, &ScavengePointer);
708 IterateRSet(map_space_, &ScavengePointer);
709 lo_space_->IterateRSet(&ScavengePointer);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000710
711 // Copy objects reachable from cells by scavenging cell values directly.
712 HeapObjectIterator cell_iterator(cell_space_);
713 while (cell_iterator.has_next()) {
714 HeapObject* cell = cell_iterator.next();
715 if (cell->IsJSGlobalPropertyCell()) {
716 Address value_address =
717 reinterpret_cast<Address>(cell) +
718 (JSGlobalPropertyCell::kValueOffset - kHeapObjectTag);
719 scavenge_visitor.VisitPointer(reinterpret_cast<Object**>(value_address));
720 }
721 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000722
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000723 do {
724 ASSERT(new_space_front <= new_space_.top());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000725
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000726 // The addresses new_space_front and new_space_.top() define a
727 // queue of unprocessed copied objects. Process them until the
728 // queue is empty.
729 while (new_space_front < new_space_.top()) {
730 HeapObject* object = HeapObject::FromAddress(new_space_front);
731 object->Iterate(&scavenge_visitor);
732 new_space_front += object->Size();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000733 }
734
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000735 // Promote and process all the to-be-promoted objects.
736 while (!promotion_queue.is_empty()) {
737 HeapObject* source;
738 Map* map;
739 promotion_queue.remove(&source, &map);
740 // Copy the from-space object to its new location (given by the
741 // forwarding address) and fix its map.
742 HeapObject* target = source->map_word().ToForwardingAddress();
743 CopyBlock(reinterpret_cast<Object**>(target->address()),
744 reinterpret_cast<Object**>(source->address()),
745 source->SizeFromMap(map));
746 target->set_map(map);
747
748#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
749 // Update NewSpace stats if necessary.
750 RecordCopiedObject(target);
751#endif
752 // Visit the newly copied object for pointers to new space.
753 target->Iterate(&scavenge_visitor);
754 UpdateRSet(target);
755 }
756
757 // Take another spin if there are now unswept objects in new space
758 // (there are currently no more unswept promoted objects).
759 } while (new_space_front < new_space_.top());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000760
761 // Set age mark.
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000762 new_space_.set_age_mark(new_space_.top());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000763
ager@chromium.orgeadaf222009-06-16 09:43:10 +0000764 // Update how much has survived scavenge.
765 survived_since_last_expansion_ +=
766 (PromotedSpaceSize() - survived_watermark) + new_space_.Size();
767
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000768 LOG(ResourceEvent("scavenge", "end"));
769
770 gc_state_ = NOT_IN_GC;
771}
772
773
774void Heap::ClearRSetRange(Address start, int size_in_bytes) {
775 uint32_t start_bit;
776 Address start_word_address =
777 Page::ComputeRSetBitPosition(start, 0, &start_bit);
778 uint32_t end_bit;
779 Address end_word_address =
780 Page::ComputeRSetBitPosition(start + size_in_bytes - kIntSize,
781 0,
782 &end_bit);
783
784 // We want to clear the bits in the starting word starting with the
785 // first bit, and in the ending word up to and including the last
786 // bit. Build a pair of bitmasks to do that.
787 uint32_t start_bitmask = start_bit - 1;
788 uint32_t end_bitmask = ~((end_bit << 1) - 1);
789
790 // If the start address and end address are the same, we mask that
791 // word once, otherwise mask the starting and ending word
792 // separately and all the ones in between.
793 if (start_word_address == end_word_address) {
794 Memory::uint32_at(start_word_address) &= (start_bitmask | end_bitmask);
795 } else {
796 Memory::uint32_at(start_word_address) &= start_bitmask;
797 Memory::uint32_at(end_word_address) &= end_bitmask;
798 start_word_address += kIntSize;
799 memset(start_word_address, 0, end_word_address - start_word_address);
800 }
801}
802
803
804class UpdateRSetVisitor: public ObjectVisitor {
805 public:
806
807 void VisitPointer(Object** p) {
808 UpdateRSet(p);
809 }
810
811 void VisitPointers(Object** start, Object** end) {
812 // Update a store into slots [start, end), used (a) to update remembered
813 // set when promoting a young object to old space or (b) to rebuild
814 // remembered sets after a mark-compact collection.
815 for (Object** p = start; p < end; p++) UpdateRSet(p);
816 }
817 private:
818
819 void UpdateRSet(Object** p) {
820 // The remembered set should not be set. It should be clear for objects
821 // newly copied to old space, and it is cleared before rebuilding in the
822 // mark-compact collector.
823 ASSERT(!Page::IsRSetSet(reinterpret_cast<Address>(p), 0));
824 if (Heap::InNewSpace(*p)) {
825 Page::SetRSet(reinterpret_cast<Address>(p), 0);
826 }
827 }
828};
829
830
831int Heap::UpdateRSet(HeapObject* obj) {
832 ASSERT(!InNewSpace(obj));
833 // Special handling of fixed arrays to iterate the body based on the start
834 // address and offset. Just iterating the pointers as in UpdateRSetVisitor
835 // will not work because Page::SetRSet needs to have the start of the
sgjesse@chromium.orgb9d7da12009-08-05 08:38:10 +0000836 // object for large object pages.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000837 if (obj->IsFixedArray()) {
838 FixedArray* array = FixedArray::cast(obj);
839 int length = array->length();
840 for (int i = 0; i < length; i++) {
841 int offset = FixedArray::kHeaderSize + i * kPointerSize;
842 ASSERT(!Page::IsRSetSet(obj->address(), offset));
843 if (Heap::InNewSpace(array->get(i))) {
844 Page::SetRSet(obj->address(), offset);
845 }
846 }
847 } else if (!obj->IsCode()) {
848 // Skip code object, we know it does not contain inter-generational
849 // pointers.
850 UpdateRSetVisitor v;
851 obj->Iterate(&v);
852 }
853 return obj->Size();
854}
855
856
857void Heap::RebuildRSets() {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000858 // By definition, we do not care about remembered set bits in code,
859 // data, or cell spaces.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000860 map_space_->ClearRSet();
861 RebuildRSets(map_space_);
862
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000863 old_pointer_space_->ClearRSet();
864 RebuildRSets(old_pointer_space_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000865
866 Heap::lo_space_->ClearRSet();
867 RebuildRSets(lo_space_);
868}
869
870
871void Heap::RebuildRSets(PagedSpace* space) {
872 HeapObjectIterator it(space);
873 while (it.has_next()) Heap::UpdateRSet(it.next());
874}
875
876
877void Heap::RebuildRSets(LargeObjectSpace* space) {
878 LargeObjectIterator it(space);
879 while (it.has_next()) Heap::UpdateRSet(it.next());
880}
881
882
883#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
884void Heap::RecordCopiedObject(HeapObject* obj) {
885 bool should_record = false;
886#ifdef DEBUG
887 should_record = FLAG_heap_stats;
888#endif
889#ifdef ENABLE_LOGGING_AND_PROFILING
890 should_record = should_record || FLAG_log_gc;
891#endif
892 if (should_record) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000893 if (new_space_.Contains(obj)) {
894 new_space_.RecordAllocation(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000895 } else {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000896 new_space_.RecordPromotion(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000897 }
898 }
899}
900#endif // defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
901
902
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000903
904HeapObject* Heap::MigrateObject(HeapObject* source,
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000905 HeapObject* target,
906 int size) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000907 // Copy the content of source to target.
908 CopyBlock(reinterpret_cast<Object**>(target->address()),
909 reinterpret_cast<Object**>(source->address()),
910 size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000911
kasper.lund7276f142008-07-30 08:49:36 +0000912 // Set the forwarding address.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000913 source->set_map_word(MapWord::FromForwardingAddress(target));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000914
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000915#if defined(DEBUG) || defined(ENABLE_LOGGING_AND_PROFILING)
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000916 // Update NewSpace stats if necessary.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000917 RecordCopiedObject(target);
918#endif
919
920 return target;
921}
922
923
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000924static inline bool IsShortcutCandidate(HeapObject* object, Map* map) {
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000925 STATIC_ASSERT(kNotStringTag != 0 && kSymbolTag != 0);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000926 ASSERT(object->map() == map);
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +0000927 InstanceType type = map->instance_type();
928 if ((type & kShortcutTypeMask) != kShortcutTypeTag) return false;
929 ASSERT(object->IsString() && !object->IsSymbol());
930 return ConsString::cast(object)->unchecked_second() == Heap::empty_string();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000931}
932
933
934void Heap::ScavengeObjectSlow(HeapObject** p, HeapObject* object) {
935 ASSERT(InFromSpace(object));
936 MapWord first_word = object->map_word();
937 ASSERT(!first_word.IsForwardingAddress());
938
939 // Optimization: Bypass flattened ConsString objects.
940 if (IsShortcutCandidate(object, first_word.ToMap())) {
ager@chromium.org870a0b62008-11-04 11:43:05 +0000941 object = HeapObject::cast(ConsString::cast(object)->unchecked_first());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000942 *p = object;
943 // After patching *p we have to repeat the checks that object is in the
944 // active semispace of the young generation and not already copied.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000945 if (!InNewSpace(object)) return;
kasper.lund7276f142008-07-30 08:49:36 +0000946 first_word = object->map_word();
947 if (first_word.IsForwardingAddress()) {
948 *p = first_word.ToForwardingAddress();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000949 return;
950 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000951 }
952
kasper.lund7276f142008-07-30 08:49:36 +0000953 int object_size = object->SizeFromMap(first_word.ToMap());
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000954 // We rely on live objects in new space to be at least two pointers,
955 // so we can store the from-space address and map pointer of promoted
956 // objects in the to space.
957 ASSERT(object_size >= 2 * kPointerSize);
958
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000959 // If the object should be promoted, we try to copy it to old space.
960 if (ShouldBePromoted(object->address(), object_size)) {
ager@chromium.org5aa501c2009-06-23 07:57:28 +0000961 Object* result;
962 if (object_size > MaxObjectSizeInPagedSpace()) {
963 result = lo_space_->AllocateRawFixedArray(object_size);
964 if (!result->IsFailure()) {
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000965 // Save the from-space object pointer and its map pointer at the
966 // top of the to space to be swept and copied later. Write the
967 // forwarding address over the map word of the from-space
968 // object.
ager@chromium.org5aa501c2009-06-23 07:57:28 +0000969 HeapObject* target = HeapObject::cast(result);
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000970 promotion_queue.insert(object, first_word.ToMap());
971 object->set_map_word(MapWord::FromForwardingAddress(target));
972
973 // Give the space allocated for the result a proper map by
974 // treating it as a free list node (not linked into the free
975 // list).
976 FreeListNode* node = FreeListNode::FromAddress(target->address());
977 node->set_size(object_size);
978
979 *p = target;
ager@chromium.org5aa501c2009-06-23 07:57:28 +0000980 return;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000981 }
ager@chromium.org5aa501c2009-06-23 07:57:28 +0000982 } else {
983 OldSpace* target_space = Heap::TargetSpace(object);
984 ASSERT(target_space == Heap::old_pointer_space_ ||
985 target_space == Heap::old_data_space_);
986 result = target_space->AllocateRaw(object_size);
987 if (!result->IsFailure()) {
988 HeapObject* target = HeapObject::cast(result);
989 if (target_space == Heap::old_pointer_space_) {
990 // Save the from-space object pointer and its map pointer at the
991 // top of the to space to be swept and copied later. Write the
992 // forwarding address over the map word of the from-space
993 // object.
994 promotion_queue.insert(object, first_word.ToMap());
995 object->set_map_word(MapWord::FromForwardingAddress(target));
996
997 // Give the space allocated for the result a proper map by
998 // treating it as a free list node (not linked into the free
999 // list).
1000 FreeListNode* node = FreeListNode::FromAddress(target->address());
1001 node->set_size(object_size);
1002
1003 *p = target;
1004 } else {
1005 // Objects promoted to the data space can be copied immediately
1006 // and not revisited---we will never sweep that space for
1007 // pointers and the copied objects do not contain pointers to
1008 // new space objects.
1009 *p = MigrateObject(object, target, object_size);
1010#ifdef DEBUG
1011 VerifyNonPointerSpacePointersVisitor v;
1012 (*p)->Iterate(&v);
1013#endif
1014 }
1015 return;
1016 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001017 }
1018 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001019 // The object should remain in new space or the old space allocation failed.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001020 Object* result = new_space_.AllocateRaw(object_size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001021 // Failed allocation at this point is utterly unexpected.
1022 ASSERT(!result->IsFailure());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001023 *p = MigrateObject(object, HeapObject::cast(result), object_size);
1024}
1025
1026
1027void Heap::ScavengePointer(HeapObject** p) {
1028 ScavengeObject(p, *p);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001029}
1030
1031
1032Object* Heap::AllocatePartialMap(InstanceType instance_type,
1033 int instance_size) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001034 Object* result = AllocateRawMap();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001035 if (result->IsFailure()) return result;
1036
1037 // Map::cast cannot be used due to uninitialized map field.
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001038 reinterpret_cast<Map*>(result)->set_map(raw_unchecked_meta_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001039 reinterpret_cast<Map*>(result)->set_instance_type(instance_type);
1040 reinterpret_cast<Map*>(result)->set_instance_size(instance_size);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001041 reinterpret_cast<Map*>(result)->set_inobject_properties(0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001042 reinterpret_cast<Map*>(result)->set_unused_property_fields(0);
1043 return result;
1044}
1045
1046
1047Object* Heap::AllocateMap(InstanceType instance_type, int instance_size) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001048 Object* result = AllocateRawMap();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001049 if (result->IsFailure()) return result;
1050
1051 Map* map = reinterpret_cast<Map*>(result);
1052 map->set_map(meta_map());
1053 map->set_instance_type(instance_type);
1054 map->set_prototype(null_value());
1055 map->set_constructor(null_value());
1056 map->set_instance_size(instance_size);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001057 map->set_inobject_properties(0);
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00001058 map->set_pre_allocated_property_fields(0);
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00001059 map->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001060 map->set_code_cache(empty_fixed_array());
1061 map->set_unused_property_fields(0);
1062 map->set_bit_field(0);
ager@chromium.org3a37e9b2009-04-27 09:26:21 +00001063 map->set_bit_field2(0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001064 return map;
1065}
1066
1067
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001068const Heap::StringTypeTable Heap::string_type_table[] = {
1069#define STRING_TYPE_ELEMENT(type, size, name, camel_name) \
1070 {type, size, k##camel_name##MapRootIndex},
1071 STRING_TYPE_LIST(STRING_TYPE_ELEMENT)
1072#undef STRING_TYPE_ELEMENT
1073};
1074
1075
1076const Heap::ConstantSymbolTable Heap::constant_symbol_table[] = {
1077#define CONSTANT_SYMBOL_ELEMENT(name, contents) \
1078 {contents, k##name##RootIndex},
1079 SYMBOL_LIST(CONSTANT_SYMBOL_ELEMENT)
1080#undef CONSTANT_SYMBOL_ELEMENT
1081};
1082
1083
1084const Heap::StructTable Heap::struct_table[] = {
1085#define STRUCT_TABLE_ELEMENT(NAME, Name, name) \
1086 { NAME##_TYPE, Name::kSize, k##Name##MapRootIndex },
1087 STRUCT_LIST(STRUCT_TABLE_ELEMENT)
1088#undef STRUCT_TABLE_ELEMENT
1089};
1090
1091
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001092bool Heap::CreateInitialMaps() {
1093 Object* obj = AllocatePartialMap(MAP_TYPE, Map::kSize);
1094 if (obj->IsFailure()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001095 // Map::cast cannot be used due to uninitialized map field.
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001096 Map* new_meta_map = reinterpret_cast<Map*>(obj);
1097 set_meta_map(new_meta_map);
1098 new_meta_map->set_map(new_meta_map);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001099
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001100 obj = AllocatePartialMap(FIXED_ARRAY_TYPE, FixedArray::kHeaderSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001101 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001102 set_fixed_array_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001103
1104 obj = AllocatePartialMap(ODDBALL_TYPE, Oddball::kSize);
1105 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001106 set_oddball_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001107
1108 // Allocate the empty array
1109 obj = AllocateEmptyFixedArray();
1110 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001111 set_empty_fixed_array(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001112
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001113 obj = Allocate(oddball_map(), OLD_DATA_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001114 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001115 set_null_value(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001116
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001117 // Allocate the empty descriptor array.
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00001118 obj = AllocateEmptyFixedArray();
1119 if (obj->IsFailure()) return false;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001120 set_empty_descriptor_array(DescriptorArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001121
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00001122 // Fix the instance_descriptors for the existing maps.
1123 meta_map()->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001124 meta_map()->set_code_cache(empty_fixed_array());
1125
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00001126 fixed_array_map()->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001127 fixed_array_map()->set_code_cache(empty_fixed_array());
1128
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00001129 oddball_map()->set_instance_descriptors(empty_descriptor_array());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001130 oddball_map()->set_code_cache(empty_fixed_array());
1131
1132 // Fix prototype object for existing maps.
1133 meta_map()->set_prototype(null_value());
1134 meta_map()->set_constructor(null_value());
1135
1136 fixed_array_map()->set_prototype(null_value());
1137 fixed_array_map()->set_constructor(null_value());
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001138
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001139 oddball_map()->set_prototype(null_value());
1140 oddball_map()->set_constructor(null_value());
1141
1142 obj = AllocateMap(HEAP_NUMBER_TYPE, HeapNumber::kSize);
1143 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001144 set_heap_number_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001145
1146 obj = AllocateMap(PROXY_TYPE, Proxy::kSize);
1147 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001148 set_proxy_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001149
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001150 for (unsigned i = 0; i < ARRAY_SIZE(string_type_table); i++) {
1151 const StringTypeTable& entry = string_type_table[i];
1152 obj = AllocateMap(entry.type, entry.size);
1153 if (obj->IsFailure()) return false;
1154 roots_[entry.index] = Map::cast(obj);
1155 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001156
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001157 obj = AllocateMap(SHORT_STRING_TYPE, SeqTwoByteString::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001158 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001159 set_undetectable_short_string_map(Map::cast(obj));
1160 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001161
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001162 obj = AllocateMap(MEDIUM_STRING_TYPE, SeqTwoByteString::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001163 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001164 set_undetectable_medium_string_map(Map::cast(obj));
1165 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001166
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001167 obj = AllocateMap(LONG_STRING_TYPE, SeqTwoByteString::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001168 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001169 set_undetectable_long_string_map(Map::cast(obj));
1170 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001171
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001172 obj = AllocateMap(SHORT_ASCII_STRING_TYPE, SeqAsciiString::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001173 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001174 set_undetectable_short_ascii_string_map(Map::cast(obj));
1175 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001176
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001177 obj = AllocateMap(MEDIUM_ASCII_STRING_TYPE, SeqAsciiString::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001178 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001179 set_undetectable_medium_ascii_string_map(Map::cast(obj));
1180 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001181
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001182 obj = AllocateMap(LONG_ASCII_STRING_TYPE, SeqAsciiString::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001183 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001184 set_undetectable_long_ascii_string_map(Map::cast(obj));
1185 Map::cast(obj)->set_is_undetectable();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001186
kasperl@chromium.orge959c182009-07-27 08:59:04 +00001187 obj = AllocateMap(BYTE_ARRAY_TYPE, ByteArray::kAlignedSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001188 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001189 set_byte_array_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001190
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001191 obj = AllocateMap(PIXEL_ARRAY_TYPE, PixelArray::kAlignedSize);
1192 if (obj->IsFailure()) return false;
1193 set_pixel_array_map(Map::cast(obj));
1194
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001195 obj = AllocateMap(CODE_TYPE, Code::kHeaderSize);
1196 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001197 set_code_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001198
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001199 obj = AllocateMap(JS_GLOBAL_PROPERTY_CELL_TYPE,
1200 JSGlobalPropertyCell::kSize);
1201 if (obj->IsFailure()) return false;
1202 set_global_property_cell_map(Map::cast(obj));
1203
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001204 obj = AllocateMap(FILLER_TYPE, kPointerSize);
1205 if (obj->IsFailure()) return false;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001206 set_one_pointer_filler_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001207
1208 obj = AllocateMap(FILLER_TYPE, 2 * kPointerSize);
1209 if (obj->IsFailure()) return false;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001210 set_two_pointer_filler_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001211
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001212 for (unsigned i = 0; i < ARRAY_SIZE(struct_table); i++) {
1213 const StructTable& entry = struct_table[i];
1214 obj = AllocateMap(entry.type, entry.size);
1215 if (obj->IsFailure()) return false;
1216 roots_[entry.index] = Map::cast(obj);
1217 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001218
ager@chromium.org236ad962008-09-25 09:45:57 +00001219 obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001220 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001221 set_hash_table_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001222
ager@chromium.org236ad962008-09-25 09:45:57 +00001223 obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001224 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001225 set_context_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001226
ager@chromium.org236ad962008-09-25 09:45:57 +00001227 obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001228 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001229 set_catch_context_map(Map::cast(obj));
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00001230
1231 obj = AllocateMap(FIXED_ARRAY_TYPE, HeapObject::kHeaderSize);
1232 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001233 set_global_context_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001234
1235 obj = AllocateMap(JS_FUNCTION_TYPE, JSFunction::kSize);
1236 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001237 set_boilerplate_function_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001238
1239 obj = AllocateMap(SHARED_FUNCTION_INFO_TYPE, SharedFunctionInfo::kSize);
1240 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001241 set_shared_function_info_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001242
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00001243 ASSERT(!Heap::InNewSpace(Heap::empty_fixed_array()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001244 return true;
1245}
1246
1247
1248Object* Heap::AllocateHeapNumber(double value, PretenureFlag pretenure) {
1249 // Statically ensure that it is safe to allocate heap numbers in paged
1250 // spaces.
1251 STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxHeapObjectSize);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001252 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00001253 Object* result = AllocateRaw(HeapNumber::kSize, space, OLD_DATA_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001254 if (result->IsFailure()) return result;
1255
1256 HeapObject::cast(result)->set_map(heap_number_map());
1257 HeapNumber::cast(result)->set_value(value);
1258 return result;
1259}
1260
1261
1262Object* Heap::AllocateHeapNumber(double value) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00001263 // Use general version, if we're forced to always allocate.
1264 if (always_allocate()) return AllocateHeapNumber(value, NOT_TENURED);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001265 // This version of AllocateHeapNumber is optimized for
1266 // allocation in new space.
1267 STATIC_ASSERT(HeapNumber::kSize <= Page::kMaxHeapObjectSize);
1268 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001269 Object* result = new_space_.AllocateRaw(HeapNumber::kSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001270 if (result->IsFailure()) return result;
1271 HeapObject::cast(result)->set_map(heap_number_map());
1272 HeapNumber::cast(result)->set_value(value);
1273 return result;
1274}
1275
1276
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001277Object* Heap::AllocateJSGlobalPropertyCell(Object* value) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001278 Object* result = AllocateRawCell();
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001279 if (result->IsFailure()) return result;
1280 HeapObject::cast(result)->set_map(global_property_cell_map());
1281 JSGlobalPropertyCell::cast(result)->set_value(value);
1282 return result;
1283}
1284
1285
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001286Object* Heap::CreateOddball(Map* map,
1287 const char* to_string,
1288 Object* to_number) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001289 Object* result = Allocate(map, OLD_DATA_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001290 if (result->IsFailure()) return result;
1291 return Oddball::cast(result)->Initialize(to_string, to_number);
1292}
1293
1294
1295bool Heap::CreateApiObjects() {
1296 Object* obj;
1297
1298 obj = AllocateMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
1299 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001300 set_neander_map(Map::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001301
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001302 obj = Heap::AllocateJSObjectFromMap(neander_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001303 if (obj->IsFailure()) return false;
1304 Object* elements = AllocateFixedArray(2);
1305 if (elements->IsFailure()) return false;
1306 FixedArray::cast(elements)->set(0, Smi::FromInt(0));
1307 JSObject::cast(obj)->set_elements(FixedArray::cast(elements));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001308 set_message_listeners(JSObject::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001309
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001310 return true;
1311}
1312
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001313
1314void Heap::CreateCEntryStub() {
ager@chromium.orga1645e22009-09-09 19:27:10 +00001315 CEntryStub stub(1);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001316 set_c_entry_code(*stub.GetCode());
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001317}
1318
1319
ager@chromium.org18ad94b2009-09-02 08:22:29 +00001320#if V8_TARGET_ARCH_ARM && V8_NATIVE_REGEXP
1321void Heap::CreateRegExpCEntryStub() {
1322 RegExpCEntryStub stub;
1323 set_re_c_entry_code(*stub.GetCode());
1324}
1325#endif
1326
1327
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001328void Heap::CreateCEntryDebugBreakStub() {
1329 CEntryDebugBreakStub stub;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001330 set_c_entry_debug_break_code(*stub.GetCode());
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001331}
1332
1333
1334void Heap::CreateJSEntryStub() {
1335 JSEntryStub stub;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001336 set_js_entry_code(*stub.GetCode());
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001337}
1338
1339
1340void Heap::CreateJSConstructEntryStub() {
1341 JSConstructEntryStub stub;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001342 set_js_construct_entry_code(*stub.GetCode());
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001343}
1344
1345
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001346void Heap::CreateFixedStubs() {
1347 // Here we create roots for fixed stubs. They are needed at GC
1348 // for cooking and uncooking (check out frames.cc).
1349 // The eliminates the need for doing dictionary lookup in the
1350 // stub cache for these stubs.
1351 HandleScope scope;
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001352 // gcc-4.4 has problem generating correct code of following snippet:
1353 // { CEntryStub stub;
1354 // c_entry_code_ = *stub.GetCode();
1355 // }
1356 // { CEntryDebugBreakStub stub;
1357 // c_entry_debug_break_code_ = *stub.GetCode();
1358 // }
1359 // To workaround the problem, make separate functions without inlining.
1360 Heap::CreateCEntryStub();
1361 Heap::CreateCEntryDebugBreakStub();
1362 Heap::CreateJSEntryStub();
1363 Heap::CreateJSConstructEntryStub();
ager@chromium.org18ad94b2009-09-02 08:22:29 +00001364#if V8_TARGET_ARCH_ARM && V8_NATIVE_REGEXP
1365 Heap::CreateRegExpCEntryStub();
1366#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001367}
1368
1369
1370bool Heap::CreateInitialObjects() {
1371 Object* obj;
1372
1373 // The -0 value must be set before NumberFromDouble works.
1374 obj = AllocateHeapNumber(-0.0, TENURED);
1375 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001376 set_minus_zero_value(obj);
1377 ASSERT(signbit(minus_zero_value()->Number()) != 0);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001378
1379 obj = AllocateHeapNumber(OS::nan_value(), TENURED);
1380 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001381 set_nan_value(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001382
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001383 obj = Allocate(oddball_map(), OLD_DATA_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001384 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001385 set_undefined_value(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001386 ASSERT(!InNewSpace(undefined_value()));
1387
1388 // Allocate initial symbol table.
1389 obj = SymbolTable::Allocate(kInitialSymbolTableSize);
1390 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001391 // Don't use set_symbol_table() due to asserts.
1392 roots_[kSymbolTableRootIndex] = obj;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001393
1394 // Assign the print strings for oddballs after creating symboltable.
1395 Object* symbol = LookupAsciiSymbol("undefined");
1396 if (symbol->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001397 Oddball::cast(undefined_value())->set_to_string(String::cast(symbol));
1398 Oddball::cast(undefined_value())->set_to_number(nan_value());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001399
1400 // Assign the print strings for oddballs after creating symboltable.
1401 symbol = LookupAsciiSymbol("null");
1402 if (symbol->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001403 Oddball::cast(null_value())->set_to_string(String::cast(symbol));
1404 Oddball::cast(null_value())->set_to_number(Smi::FromInt(0));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001405
1406 // Allocate the null_value
1407 obj = Oddball::cast(null_value())->Initialize("null", Smi::FromInt(0));
1408 if (obj->IsFailure()) return false;
1409
1410 obj = CreateOddball(oddball_map(), "true", Smi::FromInt(1));
1411 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001412 set_true_value(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001413
1414 obj = CreateOddball(oddball_map(), "false", Smi::FromInt(0));
1415 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001416 set_false_value(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001417
1418 obj = CreateOddball(oddball_map(), "hole", Smi::FromInt(-1));
1419 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001420 set_the_hole_value(obj);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001421
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001422 obj = CreateOddball(
1423 oddball_map(), "no_interceptor_result_sentinel", Smi::FromInt(-2));
1424 if (obj->IsFailure()) return false;
1425 set_no_interceptor_result_sentinel(obj);
1426
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +00001427 obj = CreateOddball(oddball_map(), "termination_exception", Smi::FromInt(-3));
1428 if (obj->IsFailure()) return false;
1429 set_termination_exception(obj);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001430
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001431 // Allocate the empty string.
1432 obj = AllocateRawAsciiString(0, TENURED);
1433 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001434 set_empty_string(String::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001435
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001436 for (unsigned i = 0; i < ARRAY_SIZE(constant_symbol_table); i++) {
1437 obj = LookupAsciiSymbol(constant_symbol_table[i].contents);
1438 if (obj->IsFailure()) return false;
1439 roots_[constant_symbol_table[i].index] = String::cast(obj);
1440 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001441
ager@chromium.org3b45ab52009-03-19 22:21:34 +00001442 // Allocate the hidden symbol which is used to identify the hidden properties
1443 // in JSObjects. The hash code has a special value so that it will not match
1444 // the empty string when searching for the property. It cannot be part of the
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001445 // loop above because it needs to be allocated manually with the special
ager@chromium.org3b45ab52009-03-19 22:21:34 +00001446 // hash code in place. The hash code for the hidden_symbol is zero to ensure
1447 // that it will always be at the first entry in property descriptors.
1448 obj = AllocateSymbol(CStrVector(""), 0, String::kHashComputedMask);
1449 if (obj->IsFailure()) return false;
1450 hidden_symbol_ = String::cast(obj);
1451
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001452 // Allocate the proxy for __proto__.
1453 obj = AllocateProxy((Address) &Accessors::ObjectPrototype);
1454 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001455 set_prototype_accessors(Proxy::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001456
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001457 // Allocate the code_stubs dictionary. The initial size is set to avoid
1458 // expanding the dictionary during bootstrapping.
1459 obj = NumberDictionary::Allocate(128);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001460 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001461 set_code_stubs(NumberDictionary::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001462
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001463 // Allocate the non_monomorphic_cache used in stub-cache.cc. The initial size
1464 // is set to avoid expanding the dictionary during bootstrapping.
1465 obj = NumberDictionary::Allocate(64);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001466 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001467 set_non_monomorphic_cache(NumberDictionary::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001468
1469 CreateFixedStubs();
1470
1471 // Allocate the number->string conversion cache
1472 obj = AllocateFixedArray(kNumberStringCacheSize * 2);
1473 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001474 set_number_string_cache(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001475
1476 // Allocate cache for single character strings.
1477 obj = AllocateFixedArray(String::kMaxAsciiCharCode+1);
1478 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001479 set_single_character_string_cache(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001480
1481 // Allocate cache for external strings pointing to native source code.
1482 obj = AllocateFixedArray(Natives::GetBuiltinsCount());
1483 if (obj->IsFailure()) return false;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001484 set_natives_source_cache(FixedArray::cast(obj));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001485
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001486 // Handling of script id generation is in Factory::NewScript.
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001487 set_last_script_id(undefined_value());
kasperl@chromium.org7be3c992009-03-12 07:19:55 +00001488
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001489 // Initialize keyed lookup cache.
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001490 KeyedLookupCache::Clear();
1491
1492 // Initialize context slot cache.
1493 ContextSlotCache::Clear();
1494
1495 // Initialize descriptor cache.
1496 DescriptorLookupCache::Clear();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001497
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00001498 // Initialize compilation cache.
1499 CompilationCache::Clear();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001500
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001501 return true;
1502}
1503
1504
1505static inline int double_get_hash(double d) {
1506 DoubleRepresentation rep(d);
1507 return ((static_cast<int>(rep.bits) ^ static_cast<int>(rep.bits >> 32)) &
1508 (Heap::kNumberStringCacheSize - 1));
1509}
1510
1511
1512static inline int smi_get_hash(Smi* smi) {
1513 return (smi->value() & (Heap::kNumberStringCacheSize - 1));
1514}
1515
1516
1517
1518Object* Heap::GetNumberStringCache(Object* number) {
1519 int hash;
1520 if (number->IsSmi()) {
1521 hash = smi_get_hash(Smi::cast(number));
1522 } else {
1523 hash = double_get_hash(number->Number());
1524 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001525 Object* key = number_string_cache()->get(hash * 2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001526 if (key == number) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001527 return String::cast(number_string_cache()->get(hash * 2 + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001528 } else if (key->IsHeapNumber() &&
1529 number->IsHeapNumber() &&
1530 key->Number() == number->Number()) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001531 return String::cast(number_string_cache()->get(hash * 2 + 1));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001532 }
1533 return undefined_value();
1534}
1535
1536
1537void Heap::SetNumberStringCache(Object* number, String* string) {
1538 int hash;
1539 if (number->IsSmi()) {
1540 hash = smi_get_hash(Smi::cast(number));
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001541 number_string_cache()->set(hash * 2, number, SKIP_WRITE_BARRIER);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001542 } else {
1543 hash = double_get_hash(number->Number());
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001544 number_string_cache()->set(hash * 2, number);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001545 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001546 number_string_cache()->set(hash * 2 + 1, string);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001547}
1548
1549
1550Object* Heap::SmiOrNumberFromDouble(double value,
1551 bool new_object,
1552 PretenureFlag pretenure) {
1553 // We need to distinguish the minus zero value and this cannot be
1554 // done after conversion to int. Doing this by comparing bit
1555 // patterns is faster than using fpclassify() et al.
1556 static const DoubleRepresentation plus_zero(0.0);
1557 static const DoubleRepresentation minus_zero(-0.0);
1558 static const DoubleRepresentation nan(OS::nan_value());
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001559 ASSERT(minus_zero_value() != NULL);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001560 ASSERT(sizeof(plus_zero.value) == sizeof(plus_zero.bits));
1561
1562 DoubleRepresentation rep(value);
1563 if (rep.bits == plus_zero.bits) return Smi::FromInt(0); // not uncommon
1564 if (rep.bits == minus_zero.bits) {
1565 return new_object ? AllocateHeapNumber(-0.0, pretenure)
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001566 : minus_zero_value();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001567 }
1568 if (rep.bits == nan.bits) {
1569 return new_object
1570 ? AllocateHeapNumber(OS::nan_value(), pretenure)
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00001571 : nan_value();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001572 }
1573
1574 // Try to represent the value as a tagged small integer.
1575 int int_value = FastD2I(value);
1576 if (value == FastI2D(int_value) && Smi::IsValid(int_value)) {
1577 return Smi::FromInt(int_value);
1578 }
1579
1580 // Materialize the value in the heap.
1581 return AllocateHeapNumber(value, pretenure);
1582}
1583
1584
1585Object* Heap::NewNumberFromDouble(double value, PretenureFlag pretenure) {
1586 return SmiOrNumberFromDouble(value,
1587 true /* number object must be new */,
1588 pretenure);
1589}
1590
1591
1592Object* Heap::NumberFromDouble(double value, PretenureFlag pretenure) {
1593 return SmiOrNumberFromDouble(value,
1594 false /* use preallocated NaN, -0.0 */,
1595 pretenure);
1596}
1597
1598
1599Object* Heap::AllocateProxy(Address proxy, PretenureFlag pretenure) {
1600 // Statically ensure that it is safe to allocate proxies in paged spaces.
1601 STATIC_ASSERT(Proxy::kSize <= Page::kMaxHeapObjectSize);
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001602 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001603 Object* result = Allocate(proxy_map(), space);
1604 if (result->IsFailure()) return result;
1605
1606 Proxy::cast(result)->set_proxy(proxy);
1607 return result;
1608}
1609
1610
1611Object* Heap::AllocateSharedFunctionInfo(Object* name) {
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00001612 Object* result = Allocate(shared_function_info_map(), OLD_POINTER_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001613 if (result->IsFailure()) return result;
1614
1615 SharedFunctionInfo* share = SharedFunctionInfo::cast(result);
1616 share->set_name(name);
1617 Code* illegal = Builtins::builtin(Builtins::Illegal);
1618 share->set_code(illegal);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001619 Code* construct_stub = Builtins::builtin(Builtins::JSConstructStubGeneric);
1620 share->set_construct_stub(construct_stub);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001621 share->set_expected_nof_properties(0);
1622 share->set_length(0);
1623 share->set_formal_parameter_count(0);
1624 share->set_instance_class_name(Object_symbol());
1625 share->set_function_data(undefined_value());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001626 share->set_script(undefined_value());
1627 share->set_start_position_and_type(0);
1628 share->set_debug_info(undefined_value());
kasperl@chromium.orgd1e3e722009-04-14 13:38:25 +00001629 share->set_inferred_name(empty_string());
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00001630 share->set_compiler_hints(0);
1631 share->set_this_property_assignments_count(0);
1632 share->set_this_property_assignments(undefined_value());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001633 return result;
1634}
1635
1636
ager@chromium.org3e875802009-06-29 08:26:34 +00001637Object* Heap::AllocateConsString(String* first, String* second) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001638 int first_length = first->length();
ager@chromium.org3e875802009-06-29 08:26:34 +00001639 if (first_length == 0) return second;
1640
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001641 int second_length = second->length();
ager@chromium.org3e875802009-06-29 08:26:34 +00001642 if (second_length == 0) return first;
1643
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001644 int length = first_length + second_length;
ager@chromium.org5ec48922009-05-05 07:25:34 +00001645 bool is_ascii = first->IsAsciiRepresentation()
1646 && second->IsAsciiRepresentation();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001647
ager@chromium.org3e875802009-06-29 08:26:34 +00001648 // Make sure that an out of memory exception is thrown if the length
1649 // of the new cons string is too large to fit in a Smi.
1650 if (length > Smi::kMaxValue || length < -0) {
1651 Top::context()->mark_out_of_memory();
1652 return Failure::OutOfMemoryException();
1653 }
1654
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001655 // If the resulting string is small make a flat string.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001656 if (length < String::kMinNonFlatLength) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001657 ASSERT(first->IsFlat());
1658 ASSERT(second->IsFlat());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001659 if (is_ascii) {
1660 Object* result = AllocateRawAsciiString(length);
1661 if (result->IsFailure()) return result;
1662 // Copy the characters into the new object.
1663 char* dest = SeqAsciiString::cast(result)->GetChars();
ager@chromium.org3e875802009-06-29 08:26:34 +00001664 // Copy first part.
1665 char* src = SeqAsciiString::cast(first)->GetChars();
1666 for (int i = 0; i < first_length; i++) *dest++ = src[i];
1667 // Copy second part.
1668 src = SeqAsciiString::cast(second)->GetChars();
1669 for (int i = 0; i < second_length; i++) *dest++ = src[i];
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001670 return result;
1671 } else {
1672 Object* result = AllocateRawTwoByteString(length);
1673 if (result->IsFailure()) return result;
1674 // Copy the characters into the new object.
1675 uc16* dest = SeqTwoByteString::cast(result)->GetChars();
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001676 String::WriteToFlat(first, dest, 0, first_length);
1677 String::WriteToFlat(second, dest + first_length, 0, second_length);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001678 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001679 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001680 }
1681
1682 Map* map;
1683 if (length <= String::kMaxShortStringSize) {
1684 map = is_ascii ? short_cons_ascii_string_map()
1685 : short_cons_string_map();
1686 } else if (length <= String::kMaxMediumStringSize) {
1687 map = is_ascii ? medium_cons_ascii_string_map()
1688 : medium_cons_string_map();
1689 } else {
1690 map = is_ascii ? long_cons_ascii_string_map()
1691 : long_cons_string_map();
1692 }
1693
1694 Object* result = Allocate(map, NEW_SPACE);
1695 if (result->IsFailure()) return result;
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00001696 ASSERT(InNewSpace(result));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001697 ConsString* cons_string = ConsString::cast(result);
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00001698 cons_string->set_first(first, SKIP_WRITE_BARRIER);
1699 cons_string->set_second(second, SKIP_WRITE_BARRIER);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001700 cons_string->set_length(length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001701 return result;
1702}
1703
1704
ager@chromium.org870a0b62008-11-04 11:43:05 +00001705Object* Heap::AllocateSlicedString(String* buffer,
ager@chromium.org870a0b62008-11-04 11:43:05 +00001706 int start,
1707 int end) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001708 int length = end - start;
1709
1710 // If the resulting string is small make a sub string.
christian.plesner.hansen@gmail.com5a6af922009-08-12 14:20:51 +00001711 if (length <= String::kMinNonFlatLength) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001712 return Heap::AllocateSubString(buffer, start, end);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001713 }
1714
1715 Map* map;
1716 if (length <= String::kMaxShortStringSize) {
ager@chromium.org5ec48922009-05-05 07:25:34 +00001717 map = buffer->IsAsciiRepresentation() ?
ager@chromium.org870a0b62008-11-04 11:43:05 +00001718 short_sliced_ascii_string_map() :
1719 short_sliced_string_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001720 } else if (length <= String::kMaxMediumStringSize) {
ager@chromium.org5ec48922009-05-05 07:25:34 +00001721 map = buffer->IsAsciiRepresentation() ?
ager@chromium.org870a0b62008-11-04 11:43:05 +00001722 medium_sliced_ascii_string_map() :
1723 medium_sliced_string_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001724 } else {
ager@chromium.org5ec48922009-05-05 07:25:34 +00001725 map = buffer->IsAsciiRepresentation() ?
ager@chromium.org870a0b62008-11-04 11:43:05 +00001726 long_sliced_ascii_string_map() :
1727 long_sliced_string_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001728 }
1729
1730 Object* result = Allocate(map, NEW_SPACE);
1731 if (result->IsFailure()) return result;
1732
1733 SlicedString* sliced_string = SlicedString::cast(result);
1734 sliced_string->set_buffer(buffer);
1735 sliced_string->set_start(start);
1736 sliced_string->set_length(length);
1737
1738 return result;
1739}
1740
1741
ager@chromium.org870a0b62008-11-04 11:43:05 +00001742Object* Heap::AllocateSubString(String* buffer,
ager@chromium.org870a0b62008-11-04 11:43:05 +00001743 int start,
1744 int end) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001745 int length = end - start;
1746
ager@chromium.org7c537e22008-10-16 08:43:32 +00001747 if (length == 1) {
ager@chromium.org870a0b62008-11-04 11:43:05 +00001748 return Heap::LookupSingleCharacterStringFromCode(
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001749 buffer->Get(start));
ager@chromium.org7c537e22008-10-16 08:43:32 +00001750 }
1751
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001752 // Make an attempt to flatten the buffer to reduce access time.
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001753 if (!buffer->IsFlat()) {
1754 buffer->TryFlatten();
ager@chromium.org870a0b62008-11-04 11:43:05 +00001755 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001756
ager@chromium.org5ec48922009-05-05 07:25:34 +00001757 Object* result = buffer->IsAsciiRepresentation()
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001758 ? AllocateRawAsciiString(length)
1759 : AllocateRawTwoByteString(length);
1760 if (result->IsFailure()) return result;
1761
1762 // Copy the characters into the new object.
1763 String* string_result = String::cast(result);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001764 StringHasher hasher(length);
1765 int i = 0;
1766 for (; i < length && hasher.is_array_index(); i++) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001767 uc32 c = buffer->Get(start + i);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001768 hasher.AddCharacter(c);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001769 string_result->Set(i, c);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001770 }
ager@chromium.org7c537e22008-10-16 08:43:32 +00001771 for (; i < length; i++) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001772 uc32 c = buffer->Get(start + i);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001773 hasher.AddCharacterNoIndex(c);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001774 string_result->Set(i, c);
ager@chromium.org7c537e22008-10-16 08:43:32 +00001775 }
1776 string_result->set_length_field(hasher.GetHashField());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001777 return result;
1778}
1779
1780
1781Object* Heap::AllocateExternalStringFromAscii(
1782 ExternalAsciiString::Resource* resource) {
1783 Map* map;
1784 int length = resource->length();
1785 if (length <= String::kMaxShortStringSize) {
1786 map = short_external_ascii_string_map();
1787 } else if (length <= String::kMaxMediumStringSize) {
1788 map = medium_external_ascii_string_map();
1789 } else {
1790 map = long_external_ascii_string_map();
1791 }
1792
1793 Object* result = Allocate(map, NEW_SPACE);
1794 if (result->IsFailure()) return result;
1795
1796 ExternalAsciiString* external_string = ExternalAsciiString::cast(result);
1797 external_string->set_length(length);
1798 external_string->set_resource(resource);
1799
1800 return result;
1801}
1802
1803
1804Object* Heap::AllocateExternalStringFromTwoByte(
1805 ExternalTwoByteString::Resource* resource) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001806 int length = resource->length();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001807
ager@chromium.org6f10e412009-02-13 10:11:16 +00001808 Map* map = ExternalTwoByteString::StringMap(length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001809 Object* result = Allocate(map, NEW_SPACE);
1810 if (result->IsFailure()) return result;
1811
1812 ExternalTwoByteString* external_string = ExternalTwoByteString::cast(result);
1813 external_string->set_length(length);
1814 external_string->set_resource(resource);
1815
1816 return result;
1817}
1818
1819
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001820Object* Heap::LookupSingleCharacterStringFromCode(uint16_t code) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001821 if (code <= String::kMaxAsciiCharCode) {
1822 Object* value = Heap::single_character_string_cache()->get(code);
1823 if (value != Heap::undefined_value()) return value;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001824
1825 char buffer[1];
1826 buffer[0] = static_cast<char>(code);
1827 Object* result = LookupSymbol(Vector<const char>(buffer, 1));
1828
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001829 if (result->IsFailure()) return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001830 Heap::single_character_string_cache()->set(code, result);
1831 return result;
1832 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001833
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001834 Object* result = Heap::AllocateRawTwoByteString(1);
1835 if (result->IsFailure()) return result;
ager@chromium.org870a0b62008-11-04 11:43:05 +00001836 String* answer = String::cast(result);
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00001837 answer->Set(0, code);
ager@chromium.org870a0b62008-11-04 11:43:05 +00001838 return answer;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001839}
1840
1841
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001842Object* Heap::AllocateByteArray(int length, PretenureFlag pretenure) {
1843 if (pretenure == NOT_TENURED) {
1844 return AllocateByteArray(length);
1845 }
1846 int size = ByteArray::SizeFor(length);
1847 AllocationSpace space =
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001848 size > MaxObjectSizeInPagedSpace() ? LO_SPACE : OLD_DATA_SPACE;
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001849
1850 Object* result = AllocateRaw(size, space, OLD_DATA_SPACE);
1851
1852 if (result->IsFailure()) return result;
1853
1854 reinterpret_cast<Array*>(result)->set_map(byte_array_map());
1855 reinterpret_cast<Array*>(result)->set_length(length);
1856 return result;
1857}
1858
1859
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001860Object* Heap::AllocateByteArray(int length) {
1861 int size = ByteArray::SizeFor(length);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001862 AllocationSpace space =
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001863 size > MaxObjectSizeInPagedSpace() ? LO_SPACE : NEW_SPACE;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001864
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00001865 Object* result = AllocateRaw(size, space, OLD_DATA_SPACE);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001866
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001867 if (result->IsFailure()) return result;
1868
1869 reinterpret_cast<Array*>(result)->set_map(byte_array_map());
1870 reinterpret_cast<Array*>(result)->set_length(length);
1871 return result;
1872}
1873
1874
ager@chromium.org6f10e412009-02-13 10:11:16 +00001875void Heap::CreateFillerObjectAt(Address addr, int size) {
1876 if (size == 0) return;
1877 HeapObject* filler = HeapObject::FromAddress(addr);
1878 if (size == kPointerSize) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00001879 filler->set_map(Heap::one_pointer_filler_map());
ager@chromium.org6f10e412009-02-13 10:11:16 +00001880 } else {
1881 filler->set_map(Heap::byte_array_map());
1882 ByteArray::cast(filler)->set_length(ByteArray::LengthFor(size));
1883 }
1884}
1885
1886
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00001887Object* Heap::AllocatePixelArray(int length,
1888 uint8_t* external_pointer,
1889 PretenureFlag pretenure) {
1890 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
1891
1892 Object* result = AllocateRaw(PixelArray::kAlignedSize, space, OLD_DATA_SPACE);
1893
1894 if (result->IsFailure()) return result;
1895
1896 reinterpret_cast<PixelArray*>(result)->set_map(pixel_array_map());
1897 reinterpret_cast<PixelArray*>(result)->set_length(length);
1898 reinterpret_cast<PixelArray*>(result)->set_external_pointer(external_pointer);
1899
1900 return result;
1901}
1902
1903
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001904Object* Heap::CreateCode(const CodeDesc& desc,
kasperl@chromium.org71affb52009-05-26 05:44:31 +00001905 ZoneScopeInfo* sinfo,
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001906 Code::Flags flags,
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001907 Handle<Object> self_reference) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001908 // Compute size
1909 int body_size = RoundUp(desc.instr_size + desc.reloc_size, kObjectAlignment);
1910 int sinfo_size = 0;
1911 if (sinfo != NULL) sinfo_size = sinfo->Serialize(NULL);
1912 int obj_size = Code::SizeFor(body_size, sinfo_size);
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001913 ASSERT(IsAligned(obj_size, Code::kCodeAlignment));
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001914 Object* result;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001915 if (obj_size > MaxObjectSizeInPagedSpace()) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001916 result = lo_space_->AllocateRawCode(obj_size);
1917 } else {
1918 result = code_space_->AllocateRaw(obj_size);
1919 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001920
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001921 if (result->IsFailure()) return result;
1922
1923 // Initialize the object
1924 HeapObject::cast(result)->set_map(code_map());
1925 Code* code = Code::cast(result);
1926 code->set_instruction_size(desc.instr_size);
1927 code->set_relocation_size(desc.reloc_size);
1928 code->set_sinfo_size(sinfo_size);
1929 code->set_flags(flags);
kasperl@chromium.org061ef742009-02-27 12:16:20 +00001930 // Allow self references to created code object by patching the handle to
1931 // point to the newly allocated Code object.
1932 if (!self_reference.is_null()) {
1933 *(self_reference.location()) = code;
ager@chromium.orga74f0da2008-12-03 16:05:52 +00001934 }
1935 // Migrate generated code.
1936 // The generated code can contain Object** values (typically from handles)
1937 // that are dereferenced during the copy to point directly to the actual heap
1938 // objects. These pointers can include references to the code object itself,
1939 // through the self_reference parameter.
1940 code->CopyFrom(desc);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001941 if (sinfo != NULL) sinfo->Serialize(code); // write scope info
1942
1943#ifdef DEBUG
1944 code->Verify();
1945#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001946 return code;
1947}
1948
1949
1950Object* Heap::CopyCode(Code* code) {
1951 // Allocate an object the same size as the code object.
1952 int obj_size = code->Size();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001953 Object* result;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00001954 if (obj_size > MaxObjectSizeInPagedSpace()) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00001955 result = lo_space_->AllocateRawCode(obj_size);
1956 } else {
1957 result = code_space_->AllocateRaw(obj_size);
1958 }
1959
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001960 if (result->IsFailure()) return result;
1961
1962 // Copy code object.
1963 Address old_addr = code->address();
1964 Address new_addr = reinterpret_cast<HeapObject*>(result)->address();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00001965 CopyBlock(reinterpret_cast<Object**>(new_addr),
1966 reinterpret_cast<Object**>(old_addr),
1967 obj_size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001968 // Relocate the copy.
1969 Code* new_code = Code::cast(result);
1970 new_code->Relocate(new_addr - old_addr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001971 return new_code;
1972}
1973
1974
1975Object* Heap::Allocate(Map* map, AllocationSpace space) {
1976 ASSERT(gc_state_ == NOT_IN_GC);
1977 ASSERT(map->instance_type() != MAP_TYPE);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00001978 Object* result = AllocateRaw(map->instance_size(),
1979 space,
1980 TargetSpaceId(map->instance_type()));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001981 if (result->IsFailure()) return result;
1982 HeapObject::cast(result)->set_map(map);
1983 return result;
1984}
1985
1986
1987Object* Heap::InitializeFunction(JSFunction* function,
1988 SharedFunctionInfo* shared,
1989 Object* prototype) {
1990 ASSERT(!prototype->IsMap());
1991 function->initialize_properties();
1992 function->initialize_elements();
1993 function->set_shared(shared);
1994 function->set_prototype_or_initial_map(prototype);
1995 function->set_context(undefined_value());
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00001996 function->set_literals(empty_fixed_array(), SKIP_WRITE_BARRIER);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00001997 return function;
1998}
1999
2000
2001Object* Heap::AllocateFunctionPrototype(JSFunction* function) {
ager@chromium.orgddb913d2009-01-27 10:01:48 +00002002 // Allocate the prototype. Make sure to use the object function
2003 // from the function's context, since the function can be from a
2004 // different context.
2005 JSFunction* object_function =
2006 function->context()->global_context()->object_function();
2007 Object* prototype = AllocateJSObject(object_function);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002008 if (prototype->IsFailure()) return prototype;
2009 // When creating the prototype for the function we must set its
2010 // constructor to the function.
2011 Object* result =
2012 JSObject::cast(prototype)->SetProperty(constructor_symbol(),
2013 function,
2014 DONT_ENUM);
2015 if (result->IsFailure()) return result;
2016 return prototype;
2017}
2018
2019
2020Object* Heap::AllocateFunction(Map* function_map,
2021 SharedFunctionInfo* shared,
2022 Object* prototype) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002023 Object* result = Allocate(function_map, OLD_POINTER_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002024 if (result->IsFailure()) return result;
2025 return InitializeFunction(JSFunction::cast(result), shared, prototype);
2026}
2027
2028
2029Object* Heap::AllocateArgumentsObject(Object* callee, int length) {
mads.s.ager@gmail.com9a4089a2008-09-01 08:55:01 +00002030 // To get fast allocation and map sharing for arguments objects we
2031 // allocate them based on an arguments boilerplate.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002032
2033 // This calls Copy directly rather than using Heap::AllocateRaw so we
2034 // duplicate the check here.
2035 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
2036
2037 JSObject* boilerplate =
2038 Top::context()->global_context()->arguments_boilerplate();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002039
2040 // Make the clone.
2041 Map* map = boilerplate->map();
2042 int object_size = map->instance_size();
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002043 Object* result = AllocateRaw(object_size, NEW_SPACE, OLD_POINTER_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002044 if (result->IsFailure()) return result;
2045
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002046 // Copy the content. The arguments boilerplate doesn't have any
2047 // fields that point to new space so it's safe to skip the write
2048 // barrier here.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002049 CopyBlock(reinterpret_cast<Object**>(HeapObject::cast(result)->address()),
2050 reinterpret_cast<Object**>(boilerplate->address()),
2051 object_size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002052
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002053 // Set the two properties.
2054 JSObject::cast(result)->InObjectPropertyAtPut(arguments_callee_index,
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002055 callee);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002056 JSObject::cast(result)->InObjectPropertyAtPut(arguments_length_index,
2057 Smi::FromInt(length),
2058 SKIP_WRITE_BARRIER);
2059
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002060 // Check the state of the object
2061 ASSERT(JSObject::cast(result)->HasFastProperties());
2062 ASSERT(JSObject::cast(result)->HasFastElements());
2063
2064 return result;
2065}
2066
2067
2068Object* Heap::AllocateInitialMap(JSFunction* fun) {
2069 ASSERT(!fun->has_initial_map());
2070
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002071 // First create a new map with the size and number of in-object properties
2072 // suggested by the function.
2073 int instance_size = fun->shared()->CalculateInstanceSize();
2074 int in_object_properties = fun->shared()->CalculateInObjectProperties();
ager@chromium.org7c537e22008-10-16 08:43:32 +00002075 Object* map_obj = Heap::AllocateMap(JS_OBJECT_TYPE, instance_size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002076 if (map_obj->IsFailure()) return map_obj;
2077
2078 // Fetch or allocate prototype.
2079 Object* prototype;
2080 if (fun->has_instance_prototype()) {
2081 prototype = fun->instance_prototype();
2082 } else {
2083 prototype = AllocateFunctionPrototype(fun);
2084 if (prototype->IsFailure()) return prototype;
2085 }
2086 Map* map = Map::cast(map_obj);
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002087 map->set_inobject_properties(in_object_properties);
2088 map->set_unused_property_fields(in_object_properties);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002089 map->set_prototype(prototype);
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002090
2091 // If the function has only simple this property assignments add field
2092 // descriptors for these to the initial map as the object cannot be
2093 // constructed without having these properties.
2094 ASSERT(in_object_properties <= Map::kMaxPreAllocatedPropertyFields);
2095 if (fun->shared()->has_only_this_property_assignments() &&
2096 fun->shared()->this_property_assignments_count() > 0) {
2097 int count = fun->shared()->this_property_assignments_count();
2098 if (count > in_object_properties) {
2099 count = in_object_properties;
2100 }
sgjesse@chromium.orgc81c8942009-08-21 10:54:26 +00002101 Object* descriptors_obj = DescriptorArray::Allocate(count);
2102 if (descriptors_obj->IsFailure()) return descriptors_obj;
2103 DescriptorArray* descriptors = DescriptorArray::cast(descriptors_obj);
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002104 for (int i = 0; i < count; i++) {
2105 String* name = fun->shared()->GetThisPropertyAssignmentName(i);
2106 ASSERT(name->IsSymbol());
2107 FieldDescriptor field(name, i, NONE);
2108 descriptors->Set(i, &field);
2109 }
2110 descriptors->Sort();
2111 map->set_instance_descriptors(descriptors);
2112 map->set_pre_allocated_property_fields(count);
2113 map->set_unused_property_fields(in_object_properties - count);
2114 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002115 return map;
2116}
2117
2118
2119void Heap::InitializeJSObjectFromMap(JSObject* obj,
2120 FixedArray* properties,
2121 Map* map) {
2122 obj->set_properties(properties);
2123 obj->initialize_elements();
2124 // TODO(1240798): Initialize the object's body using valid initial values
2125 // according to the object's initial map. For example, if the map's
2126 // instance type is JS_ARRAY_TYPE, the length field should be initialized
2127 // to a number (eg, Smi::FromInt(0)) and the elements initialized to a
2128 // fixed array (eg, Heap::empty_fixed_array()). Currently, the object
2129 // verification code has to cope with (temporarily) invalid objects. See
2130 // for example, JSArray::JSArrayVerify).
2131 obj->InitializeBody(map->instance_size());
2132}
2133
2134
2135Object* Heap::AllocateJSObjectFromMap(Map* map, PretenureFlag pretenure) {
2136 // JSFunctions should be allocated using AllocateFunction to be
2137 // properly initialized.
2138 ASSERT(map->instance_type() != JS_FUNCTION_TYPE);
2139
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002140 // Both types of globla objects should be allocated using
2141 // AllocateGloblaObject to be properly initialized.
2142 ASSERT(map->instance_type() != JS_GLOBAL_OBJECT_TYPE);
2143 ASSERT(map->instance_type() != JS_BUILTINS_OBJECT_TYPE);
2144
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002145 // Allocate the backing storage for the properties.
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002146 int prop_size =
2147 map->pre_allocated_property_fields() +
2148 map->unused_property_fields() -
2149 map->inobject_properties();
2150 ASSERT(prop_size >= 0);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002151 Object* properties = AllocateFixedArray(prop_size, pretenure);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002152 if (properties->IsFailure()) return properties;
2153
2154 // Allocate the JSObject.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002155 AllocationSpace space =
2156 (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002157 if (map->instance_size() > MaxObjectSizeInPagedSpace()) space = LO_SPACE;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002158 Object* obj = Allocate(map, space);
2159 if (obj->IsFailure()) return obj;
2160
2161 // Initialize the JSObject.
2162 InitializeJSObjectFromMap(JSObject::cast(obj),
2163 FixedArray::cast(properties),
2164 map);
2165 return obj;
2166}
2167
2168
2169Object* Heap::AllocateJSObject(JSFunction* constructor,
2170 PretenureFlag pretenure) {
2171 // Allocate the initial map if absent.
2172 if (!constructor->has_initial_map()) {
2173 Object* initial_map = AllocateInitialMap(constructor);
2174 if (initial_map->IsFailure()) return initial_map;
2175 constructor->set_initial_map(Map::cast(initial_map));
2176 Map::cast(initial_map)->set_constructor(constructor);
2177 }
2178 // Allocate the object based on the constructors initial map.
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002179 Object* result =
2180 AllocateJSObjectFromMap(constructor->initial_map(), pretenure);
2181 // Make sure result is NOT a global object if valid.
2182 ASSERT(result->IsFailure() || !result->IsGlobalObject());
2183 return result;
2184}
2185
2186
2187Object* Heap::AllocateGlobalObject(JSFunction* constructor) {
2188 ASSERT(constructor->has_initial_map());
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002189 Map* map = constructor->initial_map();
2190
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002191 // Make sure no field properties are described in the initial map.
2192 // This guarantees us that normalizing the properties does not
2193 // require us to change property values to JSGlobalPropertyCells.
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002194 ASSERT(map->NextFreePropertyIndex() == 0);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002195
2196 // Make sure we don't have a ton of pre-allocated slots in the
2197 // global objects. They will be unused once we normalize the object.
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002198 ASSERT(map->unused_property_fields() == 0);
2199 ASSERT(map->inobject_properties() == 0);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002200
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002201 // Initial size of the backing store to avoid resize of the storage during
2202 // bootstrapping. The size differs between the JS global object ad the
2203 // builtins object.
2204 int initial_size = map->instance_type() == JS_GLOBAL_OBJECT_TYPE ? 64 : 512;
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002205
sgjesse@chromium.org0b6db592009-07-30 14:48:31 +00002206 // Allocate a dictionary object for backing storage.
2207 Object* obj =
2208 StringDictionary::Allocate(
2209 map->NumberOfDescribedProperties() * 2 + initial_size);
2210 if (obj->IsFailure()) return obj;
2211 StringDictionary* dictionary = StringDictionary::cast(obj);
2212
2213 // The global object might be created from an object template with accessors.
2214 // Fill these accessors into the dictionary.
2215 DescriptorArray* descs = map->instance_descriptors();
2216 for (int i = 0; i < descs->number_of_descriptors(); i++) {
2217 PropertyDetails details = descs->GetDetails(i);
2218 ASSERT(details.type() == CALLBACKS); // Only accessors are expected.
2219 PropertyDetails d =
2220 PropertyDetails(details.attributes(), CALLBACKS, details.index());
2221 Object* value = descs->GetCallbacksObject(i);
2222 value = Heap::AllocateJSGlobalPropertyCell(value);
2223 if (value->IsFailure()) return value;
2224
2225 Object* result = dictionary->Add(descs->GetKey(i), value, d);
2226 if (result->IsFailure()) return result;
2227 dictionary = StringDictionary::cast(result);
2228 }
2229
2230 // Allocate the global object and initialize it with the backing store.
2231 obj = Allocate(map, OLD_POINTER_SPACE);
2232 if (obj->IsFailure()) return obj;
2233 JSObject* global = JSObject::cast(obj);
2234 InitializeJSObjectFromMap(global, dictionary, map);
2235
2236 // Create a new map for the global object.
2237 obj = map->CopyDropDescriptors();
2238 if (obj->IsFailure()) return obj;
2239 Map* new_map = Map::cast(obj);
2240
2241 // Setup the global object as a normalized object.
2242 global->set_map(new_map);
2243 global->map()->set_instance_descriptors(Heap::empty_descriptor_array());
2244 global->set_properties(dictionary);
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002245
2246 // Make sure result is a global object with properties in dictionary.
2247 ASSERT(global->IsGlobalObject());
2248 ASSERT(!global->HasFastProperties());
2249 return global;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002250}
2251
2252
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002253Object* Heap::CopyJSObject(JSObject* source) {
2254 // Never used to copy functions. If functions need to be copied we
2255 // have to be careful to clear the literals array.
2256 ASSERT(!source->IsJSFunction());
2257
2258 // Make the clone.
2259 Map* map = source->map();
2260 int object_size = map->instance_size();
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002261 Object* clone;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002262
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002263 // If we're forced to always allocate, we use the general allocation
2264 // functions which may leave us with an object in old space.
2265 if (always_allocate()) {
2266 clone = AllocateRaw(object_size, NEW_SPACE, OLD_POINTER_SPACE);
2267 if (clone->IsFailure()) return clone;
2268 Address clone_address = HeapObject::cast(clone)->address();
2269 CopyBlock(reinterpret_cast<Object**>(clone_address),
2270 reinterpret_cast<Object**>(source->address()),
2271 object_size);
2272 // Update write barrier for all fields that lie beyond the header.
2273 for (int offset = JSObject::kHeaderSize;
2274 offset < object_size;
2275 offset += kPointerSize) {
2276 RecordWrite(clone_address, offset);
2277 }
2278 } else {
2279 clone = new_space_.AllocateRaw(object_size);
2280 if (clone->IsFailure()) return clone;
2281 ASSERT(Heap::InNewSpace(clone));
2282 // Since we know the clone is allocated in new space, we can copy
ager@chromium.org32912102009-01-16 10:38:43 +00002283 // the contents without worrying about updating the write barrier.
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002284 CopyBlock(reinterpret_cast<Object**>(HeapObject::cast(clone)->address()),
2285 reinterpret_cast<Object**>(source->address()),
2286 object_size);
2287 }
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002288
2289 FixedArray* elements = FixedArray::cast(source->elements());
2290 FixedArray* properties = FixedArray::cast(source->properties());
2291 // Update elements if necessary.
2292 if (elements->length()> 0) {
2293 Object* elem = CopyFixedArray(elements);
2294 if (elem->IsFailure()) return elem;
2295 JSObject::cast(clone)->set_elements(FixedArray::cast(elem));
2296 }
2297 // Update properties if necessary.
2298 if (properties->length() > 0) {
2299 Object* prop = CopyFixedArray(properties);
2300 if (prop->IsFailure()) return prop;
2301 JSObject::cast(clone)->set_properties(FixedArray::cast(prop));
2302 }
2303 // Return the new clone.
2304 return clone;
2305}
2306
2307
2308Object* Heap::ReinitializeJSGlobalProxy(JSFunction* constructor,
2309 JSGlobalProxy* object) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002310 // Allocate initial map if absent.
2311 if (!constructor->has_initial_map()) {
2312 Object* initial_map = AllocateInitialMap(constructor);
2313 if (initial_map->IsFailure()) return initial_map;
2314 constructor->set_initial_map(Map::cast(initial_map));
2315 Map::cast(initial_map)->set_constructor(constructor);
2316 }
2317
2318 Map* map = constructor->initial_map();
2319
2320 // Check that the already allocated object has the same size as
2321 // objects allocated using the constructor.
2322 ASSERT(map->instance_size() == object->map()->instance_size());
2323
2324 // Allocate the backing storage for the properties.
ager@chromium.org7c537e22008-10-16 08:43:32 +00002325 int prop_size = map->unused_property_fields() - map->inobject_properties();
kasperl@chromium.org2abc4502009-07-02 07:00:29 +00002326 Object* properties = AllocateFixedArray(prop_size, TENURED);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002327 if (properties->IsFailure()) return properties;
2328
2329 // Reset the map for the object.
2330 object->set_map(constructor->initial_map());
2331
2332 // Reinitialize the object from the constructor map.
2333 InitializeJSObjectFromMap(object, FixedArray::cast(properties), map);
2334 return object;
2335}
2336
2337
2338Object* Heap::AllocateStringFromAscii(Vector<const char> string,
2339 PretenureFlag pretenure) {
2340 Object* result = AllocateRawAsciiString(string.length(), pretenure);
2341 if (result->IsFailure()) return result;
2342
2343 // Copy the characters into the new object.
ager@chromium.org7c537e22008-10-16 08:43:32 +00002344 SeqAsciiString* string_result = SeqAsciiString::cast(result);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002345 for (int i = 0; i < string.length(); i++) {
ager@chromium.org7c537e22008-10-16 08:43:32 +00002346 string_result->SeqAsciiStringSet(i, string[i]);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002347 }
2348 return result;
2349}
2350
2351
2352Object* Heap::AllocateStringFromUtf8(Vector<const char> string,
2353 PretenureFlag pretenure) {
2354 // Count the number of characters in the UTF-8 string and check if
2355 // it is an ASCII string.
2356 Access<Scanner::Utf8Decoder> decoder(Scanner::utf8_decoder());
2357 decoder->Reset(string.start(), string.length());
2358 int chars = 0;
2359 bool is_ascii = true;
2360 while (decoder->has_more()) {
2361 uc32 r = decoder->GetNext();
2362 if (r > String::kMaxAsciiCharCode) is_ascii = false;
2363 chars++;
2364 }
2365
2366 // If the string is ascii, we do not need to convert the characters
2367 // since UTF8 is backwards compatible with ascii.
2368 if (is_ascii) return AllocateStringFromAscii(string, pretenure);
2369
2370 Object* result = AllocateRawTwoByteString(chars, pretenure);
2371 if (result->IsFailure()) return result;
2372
2373 // Convert and copy the characters into the new object.
2374 String* string_result = String::cast(result);
2375 decoder->Reset(string.start(), string.length());
2376 for (int i = 0; i < chars; i++) {
2377 uc32 r = decoder->GetNext();
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00002378 string_result->Set(i, r);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002379 }
2380 return result;
2381}
2382
2383
2384Object* Heap::AllocateStringFromTwoByte(Vector<const uc16> string,
2385 PretenureFlag pretenure) {
2386 // Check if the string is an ASCII string.
2387 int i = 0;
2388 while (i < string.length() && string[i] <= String::kMaxAsciiCharCode) i++;
2389
2390 Object* result;
2391 if (i == string.length()) { // It's an ASCII string.
2392 result = AllocateRawAsciiString(string.length(), pretenure);
2393 } else { // It's not an ASCII string.
2394 result = AllocateRawTwoByteString(string.length(), pretenure);
2395 }
2396 if (result->IsFailure()) return result;
2397
2398 // Copy the characters into the new object, which may be either ASCII or
2399 // UTF-16.
2400 String* string_result = String::cast(result);
2401 for (int i = 0; i < string.length(); i++) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00002402 string_result->Set(i, string[i]);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002403 }
2404 return result;
2405}
2406
2407
2408Map* Heap::SymbolMapForString(String* string) {
2409 // If the string is in new space it cannot be used as a symbol.
2410 if (InNewSpace(string)) return NULL;
2411
2412 // Find the corresponding symbol map for strings.
2413 Map* map = string->map();
2414
2415 if (map == short_ascii_string_map()) return short_ascii_symbol_map();
2416 if (map == medium_ascii_string_map()) return medium_ascii_symbol_map();
2417 if (map == long_ascii_string_map()) return long_ascii_symbol_map();
2418
2419 if (map == short_string_map()) return short_symbol_map();
2420 if (map == medium_string_map()) return medium_symbol_map();
2421 if (map == long_string_map()) return long_symbol_map();
2422
2423 if (map == short_cons_string_map()) return short_cons_symbol_map();
2424 if (map == medium_cons_string_map()) return medium_cons_symbol_map();
2425 if (map == long_cons_string_map()) return long_cons_symbol_map();
2426
2427 if (map == short_cons_ascii_string_map()) {
2428 return short_cons_ascii_symbol_map();
2429 }
2430 if (map == medium_cons_ascii_string_map()) {
2431 return medium_cons_ascii_symbol_map();
2432 }
2433 if (map == long_cons_ascii_string_map()) {
2434 return long_cons_ascii_symbol_map();
2435 }
2436
2437 if (map == short_sliced_string_map()) return short_sliced_symbol_map();
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00002438 if (map == medium_sliced_string_map()) return medium_sliced_symbol_map();
2439 if (map == long_sliced_string_map()) return long_sliced_symbol_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002440
2441 if (map == short_sliced_ascii_string_map()) {
2442 return short_sliced_ascii_symbol_map();
2443 }
2444 if (map == medium_sliced_ascii_string_map()) {
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00002445 return medium_sliced_ascii_symbol_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002446 }
2447 if (map == long_sliced_ascii_string_map()) {
kasperl@chromium.org9fe21c62008-10-28 08:53:51 +00002448 return long_sliced_ascii_symbol_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002449 }
2450
ager@chromium.org6f10e412009-02-13 10:11:16 +00002451 if (map == short_external_string_map()) {
2452 return short_external_symbol_map();
2453 }
2454 if (map == medium_external_string_map()) {
2455 return medium_external_symbol_map();
2456 }
2457 if (map == long_external_string_map()) {
2458 return long_external_symbol_map();
2459 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002460
2461 if (map == short_external_ascii_string_map()) {
ager@chromium.org6f10e412009-02-13 10:11:16 +00002462 return short_external_ascii_symbol_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002463 }
2464 if (map == medium_external_ascii_string_map()) {
ager@chromium.org6f10e412009-02-13 10:11:16 +00002465 return medium_external_ascii_symbol_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002466 }
2467 if (map == long_external_ascii_string_map()) {
ager@chromium.org6f10e412009-02-13 10:11:16 +00002468 return long_external_ascii_symbol_map();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002469 }
2470
2471 // No match found.
2472 return NULL;
2473}
2474
2475
ager@chromium.orga74f0da2008-12-03 16:05:52 +00002476Object* Heap::AllocateInternalSymbol(unibrow::CharacterStream* buffer,
2477 int chars,
2478 uint32_t length_field) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002479 // Ensure the chars matches the number of characters in the buffer.
2480 ASSERT(static_cast<unsigned>(chars) == buffer->Length());
2481 // Determine whether the string is ascii.
2482 bool is_ascii = true;
ager@chromium.org6f10e412009-02-13 10:11:16 +00002483 while (buffer->has_more() && is_ascii) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002484 if (buffer->GetNext() > unibrow::Utf8::kMaxOneByteChar) is_ascii = false;
2485 }
2486 buffer->Rewind();
2487
2488 // Compute map and object size.
2489 int size;
2490 Map* map;
2491
2492 if (is_ascii) {
2493 if (chars <= String::kMaxShortStringSize) {
2494 map = short_ascii_symbol_map();
2495 } else if (chars <= String::kMaxMediumStringSize) {
2496 map = medium_ascii_symbol_map();
2497 } else {
2498 map = long_ascii_symbol_map();
2499 }
ager@chromium.org7c537e22008-10-16 08:43:32 +00002500 size = SeqAsciiString::SizeFor(chars);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002501 } else {
2502 if (chars <= String::kMaxShortStringSize) {
2503 map = short_symbol_map();
2504 } else if (chars <= String::kMaxMediumStringSize) {
2505 map = medium_symbol_map();
2506 } else {
2507 map = long_symbol_map();
2508 }
ager@chromium.org7c537e22008-10-16 08:43:32 +00002509 size = SeqTwoByteString::SizeFor(chars);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002510 }
2511
2512 // Allocate string.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002513 AllocationSpace space =
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002514 (size > MaxObjectSizeInPagedSpace()) ? LO_SPACE : OLD_DATA_SPACE;
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002515 Object* result = AllocateRaw(size, space, OLD_DATA_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002516 if (result->IsFailure()) return result;
2517
2518 reinterpret_cast<HeapObject*>(result)->set_map(map);
2519 // The hash value contains the length of the string.
ager@chromium.org870a0b62008-11-04 11:43:05 +00002520 String* answer = String::cast(result);
ager@chromium.org870a0b62008-11-04 11:43:05 +00002521 answer->set_length_field(length_field);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002522
ager@chromium.org870a0b62008-11-04 11:43:05 +00002523 ASSERT_EQ(size, answer->Size());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002524
2525 // Fill in the characters.
2526 for (int i = 0; i < chars; i++) {
ager@chromium.orgbb29dc92009-03-24 13:25:23 +00002527 answer->Set(i, buffer->GetNext());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002528 }
ager@chromium.org870a0b62008-11-04 11:43:05 +00002529 return answer;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002530}
2531
2532
2533Object* Heap::AllocateRawAsciiString(int length, PretenureFlag pretenure) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002534 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
ager@chromium.org7c537e22008-10-16 08:43:32 +00002535 int size = SeqAsciiString::SizeFor(length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002536
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002537 Object* result = Failure::OutOfMemoryException();
2538 if (space == NEW_SPACE) {
2539 result = size <= kMaxObjectSizeInNewSpace
2540 ? new_space_.AllocateRaw(size)
2541 : lo_space_->AllocateRawFixedArray(size);
2542 } else {
2543 if (size > MaxObjectSizeInPagedSpace()) space = LO_SPACE;
2544 result = AllocateRaw(size, space, OLD_DATA_SPACE);
2545 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002546 if (result->IsFailure()) return result;
2547
2548 // Determine the map based on the string's length.
2549 Map* map;
2550 if (length <= String::kMaxShortStringSize) {
2551 map = short_ascii_string_map();
2552 } else if (length <= String::kMaxMediumStringSize) {
2553 map = medium_ascii_string_map();
2554 } else {
2555 map = long_ascii_string_map();
2556 }
2557
2558 // Partially initialize the object.
2559 HeapObject::cast(result)->set_map(map);
2560 String::cast(result)->set_length(length);
2561 ASSERT_EQ(size, HeapObject::cast(result)->Size());
2562 return result;
2563}
2564
2565
2566Object* Heap::AllocateRawTwoByteString(int length, PretenureFlag pretenure) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002567 AllocationSpace space = (pretenure == TENURED) ? OLD_DATA_SPACE : NEW_SPACE;
ager@chromium.org7c537e22008-10-16 08:43:32 +00002568 int size = SeqTwoByteString::SizeFor(length);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002569
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002570 Object* result = Failure::OutOfMemoryException();
2571 if (space == NEW_SPACE) {
2572 result = size <= kMaxObjectSizeInNewSpace
2573 ? new_space_.AllocateRaw(size)
2574 : lo_space_->AllocateRawFixedArray(size);
2575 } else {
2576 if (size > MaxObjectSizeInPagedSpace()) space = LO_SPACE;
2577 result = AllocateRaw(size, space, OLD_DATA_SPACE);
2578 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002579 if (result->IsFailure()) return result;
2580
2581 // Determine the map based on the string's length.
2582 Map* map;
2583 if (length <= String::kMaxShortStringSize) {
2584 map = short_string_map();
2585 } else if (length <= String::kMaxMediumStringSize) {
2586 map = medium_string_map();
2587 } else {
2588 map = long_string_map();
2589 }
2590
2591 // Partially initialize the object.
2592 HeapObject::cast(result)->set_map(map);
2593 String::cast(result)->set_length(length);
2594 ASSERT_EQ(size, HeapObject::cast(result)->Size());
2595 return result;
2596}
2597
2598
2599Object* Heap::AllocateEmptyFixedArray() {
2600 int size = FixedArray::SizeFor(0);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002601 Object* result = AllocateRaw(size, OLD_DATA_SPACE, OLD_DATA_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002602 if (result->IsFailure()) return result;
2603 // Initialize the object.
2604 reinterpret_cast<Array*>(result)->set_map(fixed_array_map());
2605 reinterpret_cast<Array*>(result)->set_length(0);
2606 return result;
2607}
2608
2609
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002610Object* Heap::AllocateRawFixedArray(int length) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002611 // Use the general function if we're forced to always allocate.
2612 if (always_allocate()) return AllocateFixedArray(length, NOT_TENURED);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002613 // Allocate the raw data for a fixed array.
2614 int size = FixedArray::SizeFor(length);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002615 return size <= kMaxObjectSizeInNewSpace
2616 ? new_space_.AllocateRaw(size)
2617 : lo_space_->AllocateRawFixedArray(size);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002618}
2619
2620
2621Object* Heap::CopyFixedArray(FixedArray* src) {
2622 int len = src->length();
2623 Object* obj = AllocateRawFixedArray(len);
2624 if (obj->IsFailure()) return obj;
2625 if (Heap::InNewSpace(obj)) {
2626 HeapObject* dst = HeapObject::cast(obj);
2627 CopyBlock(reinterpret_cast<Object**>(dst->address()),
2628 reinterpret_cast<Object**>(src->address()),
2629 FixedArray::SizeFor(len));
2630 return obj;
2631 }
2632 HeapObject::cast(obj)->set_map(src->map());
2633 FixedArray* result = FixedArray::cast(obj);
2634 result->set_length(len);
2635 // Copy the content
2636 WriteBarrierMode mode = result->GetWriteBarrierMode();
2637 for (int i = 0; i < len; i++) result->set(i, src->get(i), mode);
2638 return result;
2639}
2640
2641
2642Object* Heap::AllocateFixedArray(int length) {
sgjesse@chromium.org911335c2009-08-19 12:59:44 +00002643 ASSERT(length >= 0);
ager@chromium.org32912102009-01-16 10:38:43 +00002644 if (length == 0) return empty_fixed_array();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002645 Object* result = AllocateRawFixedArray(length);
2646 if (!result->IsFailure()) {
2647 // Initialize header.
2648 reinterpret_cast<Array*>(result)->set_map(fixed_array_map());
2649 FixedArray* array = FixedArray::cast(result);
2650 array->set_length(length);
2651 Object* value = undefined_value();
2652 // Initialize body.
2653 for (int index = 0; index < length; index++) {
2654 array->set(index, value, SKIP_WRITE_BARRIER);
2655 }
2656 }
2657 return result;
2658}
2659
2660
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002661Object* Heap::AllocateFixedArray(int length, PretenureFlag pretenure) {
2662 ASSERT(empty_fixed_array()->IsFixedArray());
2663 if (length == 0) return empty_fixed_array();
2664
2665 int size = FixedArray::SizeFor(length);
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002666 Object* result = Failure::OutOfMemoryException();
2667 if (pretenure != TENURED) {
2668 result = size <= kMaxObjectSizeInNewSpace
2669 ? new_space_.AllocateRaw(size)
2670 : lo_space_->AllocateRawFixedArray(size);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002671 }
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002672 if (result->IsFailure()) {
2673 if (size > MaxObjectSizeInPagedSpace()) {
2674 result = lo_space_->AllocateRawFixedArray(size);
2675 } else {
2676 AllocationSpace space =
2677 (pretenure == TENURED) ? OLD_POINTER_SPACE : NEW_SPACE;
2678 result = AllocateRaw(size, space, OLD_POINTER_SPACE);
2679 }
2680 if (result->IsFailure()) return result;
2681 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002682 // Initialize the object.
2683 reinterpret_cast<Array*>(result)->set_map(fixed_array_map());
2684 FixedArray* array = FixedArray::cast(result);
2685 array->set_length(length);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002686 Object* value = undefined_value();
2687 for (int index = 0; index < length; index++) {
2688 array->set(index, value, SKIP_WRITE_BARRIER);
2689 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002690 return array;
2691}
2692
2693
2694Object* Heap::AllocateFixedArrayWithHoles(int length) {
2695 if (length == 0) return empty_fixed_array();
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002696 Object* result = AllocateRawFixedArray(length);
2697 if (!result->IsFailure()) {
2698 // Initialize header.
2699 reinterpret_cast<Array*>(result)->set_map(fixed_array_map());
2700 FixedArray* array = FixedArray::cast(result);
2701 array->set_length(length);
2702 // Initialize body.
2703 Object* value = the_hole_value();
2704 for (int index = 0; index < length; index++) {
2705 array->set(index, value, SKIP_WRITE_BARRIER);
2706 }
2707 }
2708 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002709}
2710
2711
2712Object* Heap::AllocateHashTable(int length) {
2713 Object* result = Heap::AllocateFixedArray(length);
2714 if (result->IsFailure()) return result;
2715 reinterpret_cast<Array*>(result)->set_map(hash_table_map());
kasperl@chromium.org86f77b72009-07-06 08:21:57 +00002716 ASSERT(result->IsHashTable());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002717 return result;
2718}
2719
2720
2721Object* Heap::AllocateGlobalContext() {
2722 Object* result = Heap::AllocateFixedArray(Context::GLOBAL_CONTEXT_SLOTS);
2723 if (result->IsFailure()) return result;
2724 Context* context = reinterpret_cast<Context*>(result);
2725 context->set_map(global_context_map());
2726 ASSERT(context->IsGlobalContext());
2727 ASSERT(result->IsContext());
2728 return result;
2729}
2730
2731
2732Object* Heap::AllocateFunctionContext(int length, JSFunction* function) {
2733 ASSERT(length >= Context::MIN_CONTEXT_SLOTS);
2734 Object* result = Heap::AllocateFixedArray(length);
2735 if (result->IsFailure()) return result;
2736 Context* context = reinterpret_cast<Context*>(result);
2737 context->set_map(context_map());
2738 context->set_closure(function);
2739 context->set_fcontext(context);
2740 context->set_previous(NULL);
2741 context->set_extension(NULL);
2742 context->set_global(function->context()->global());
2743 ASSERT(!context->IsGlobalContext());
2744 ASSERT(context->is_function_context());
2745 ASSERT(result->IsContext());
2746 return result;
2747}
2748
2749
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00002750Object* Heap::AllocateWithContext(Context* previous,
2751 JSObject* extension,
2752 bool is_catch_context) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002753 Object* result = Heap::AllocateFixedArray(Context::MIN_CONTEXT_SLOTS);
2754 if (result->IsFailure()) return result;
2755 Context* context = reinterpret_cast<Context*>(result);
christian.plesner.hansen@gmail.com37abdec2009-01-06 14:43:28 +00002756 context->set_map(is_catch_context ? catch_context_map() : context_map());
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002757 context->set_closure(previous->closure());
2758 context->set_fcontext(previous->fcontext());
2759 context->set_previous(previous);
2760 context->set_extension(extension);
2761 context->set_global(previous->global());
2762 ASSERT(!context->IsGlobalContext());
2763 ASSERT(!context->is_function_context());
2764 ASSERT(result->IsContext());
2765 return result;
2766}
2767
2768
2769Object* Heap::AllocateStruct(InstanceType type) {
2770 Map* map;
2771 switch (type) {
2772#define MAKE_CASE(NAME, Name, name) case NAME##_TYPE: map = name##_map(); break;
2773STRUCT_LIST(MAKE_CASE)
2774#undef MAKE_CASE
2775 default:
2776 UNREACHABLE();
2777 return Failure::InternalError();
2778 }
2779 int size = map->instance_size();
2780 AllocationSpace space =
ager@chromium.org5aa501c2009-06-23 07:57:28 +00002781 (size > MaxObjectSizeInPagedSpace()) ? LO_SPACE : OLD_POINTER_SPACE;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002782 Object* result = Heap::Allocate(map, space);
2783 if (result->IsFailure()) return result;
2784 Struct::cast(result)->InitializeBody(size);
2785 return result;
2786}
2787
2788
ager@chromium.org96c75b52009-08-26 09:13:16 +00002789bool Heap::IdleNotification() {
ager@chromium.orga1645e22009-09-09 19:27:10 +00002790 static const int kIdlesBeforeScavenge = 4;
2791 static const int kIdlesBeforeMarkSweep = 7;
2792 static const int kIdlesBeforeMarkCompact = 8;
ager@chromium.org96c75b52009-08-26 09:13:16 +00002793 static int number_idle_notifications = 0;
2794 static int last_gc_count = gc_count_;
2795
2796 bool finished = false;
2797
2798 if (last_gc_count == gc_count_) {
2799 number_idle_notifications++;
2800 } else {
2801 number_idle_notifications = 0;
2802 last_gc_count = gc_count_;
2803 }
2804
ager@chromium.orga1645e22009-09-09 19:27:10 +00002805 if (number_idle_notifications == kIdlesBeforeScavenge) {
2806 CollectGarbage(0, NEW_SPACE);
2807 new_space_.Shrink();
ager@chromium.org96c75b52009-08-26 09:13:16 +00002808 last_gc_count = gc_count_;
ager@chromium.orga1645e22009-09-09 19:27:10 +00002809
2810 } else if (number_idle_notifications == kIdlesBeforeMarkSweep) {
2811 CollectAllGarbage(false);
2812 new_space_.Shrink();
2813 last_gc_count = gc_count_;
2814
2815 } else if (number_idle_notifications == kIdlesBeforeMarkCompact) {
2816 CollectAllGarbage(true);
2817 new_space_.Shrink();
2818 last_gc_count = gc_count_;
2819 number_idle_notifications = 0;
2820 finished = true;
ager@chromium.org96c75b52009-08-26 09:13:16 +00002821 }
2822
2823 // Uncommit unused memory in new space.
2824 Heap::UncommitFromSpace();
2825 return finished;
2826}
2827
2828
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002829#ifdef DEBUG
2830
2831void Heap::Print() {
2832 if (!HasBeenSetup()) return;
2833 Top::PrintStack();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002834 AllSpaces spaces;
2835 while (Space* space = spaces.next()) space->Print();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002836}
2837
2838
2839void Heap::ReportCodeStatistics(const char* title) {
2840 PrintF(">>>>>> Code Stats (%s) >>>>>>\n", title);
2841 PagedSpace::ResetCodeStatistics();
2842 // We do not look for code in new space, map space, or old space. If code
2843 // somehow ends up in those spaces, we would miss it here.
2844 code_space_->CollectCodeStatistics();
2845 lo_space_->CollectCodeStatistics();
2846 PagedSpace::ReportCodeStatistics();
2847}
2848
2849
2850// This function expects that NewSpace's allocated objects histogram is
2851// populated (via a call to CollectStatistics or else as a side effect of a
2852// just-completed scavenge collection).
2853void Heap::ReportHeapStatistics(const char* title) {
2854 USE(title);
2855 PrintF(">>>>>> =============== %s (%d) =============== >>>>>>\n",
2856 title, gc_count_);
2857 PrintF("mark-compact GC : %d\n", mc_count_);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +00002858 PrintF("old_gen_promotion_limit_ %d\n", old_gen_promotion_limit_);
2859 PrintF("old_gen_allocation_limit_ %d\n", old_gen_allocation_limit_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002860
2861 PrintF("\n");
2862 PrintF("Number of handles : %d\n", HandleScope::NumberOfHandles());
2863 GlobalHandles::PrintStats();
2864 PrintF("\n");
2865
2866 PrintF("Heap statistics : ");
2867 MemoryAllocator::ReportStatistics();
2868 PrintF("To space : ");
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002869 new_space_.ReportStatistics();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002870 PrintF("Old pointer space : ");
2871 old_pointer_space_->ReportStatistics();
2872 PrintF("Old data space : ");
2873 old_data_space_->ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002874 PrintF("Code space : ");
2875 code_space_->ReportStatistics();
2876 PrintF("Map space : ");
2877 map_space_->ReportStatistics();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002878 PrintF("Cell space : ");
2879 cell_space_->ReportStatistics();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002880 PrintF("Large object space : ");
2881 lo_space_->ReportStatistics();
2882 PrintF(">>>>>> ========================================= >>>>>>\n");
2883}
2884
2885#endif // DEBUG
2886
2887bool Heap::Contains(HeapObject* value) {
2888 return Contains(value->address());
2889}
2890
2891
2892bool Heap::Contains(Address addr) {
2893 if (OS::IsOutsideAllocatedSpace(addr)) return false;
2894 return HasBeenSetup() &&
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002895 (new_space_.ToSpaceContains(addr) ||
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002896 old_pointer_space_->Contains(addr) ||
2897 old_data_space_->Contains(addr) ||
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002898 code_space_->Contains(addr) ||
2899 map_space_->Contains(addr) ||
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002900 cell_space_->Contains(addr) ||
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002901 lo_space_->SlowContains(addr));
2902}
2903
2904
2905bool Heap::InSpace(HeapObject* value, AllocationSpace space) {
2906 return InSpace(value->address(), space);
2907}
2908
2909
2910bool Heap::InSpace(Address addr, AllocationSpace space) {
2911 if (OS::IsOutsideAllocatedSpace(addr)) return false;
2912 if (!HasBeenSetup()) return false;
2913
2914 switch (space) {
2915 case NEW_SPACE:
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002916 return new_space_.ToSpaceContains(addr);
ager@chromium.org9258b6b2008-09-11 09:11:10 +00002917 case OLD_POINTER_SPACE:
2918 return old_pointer_space_->Contains(addr);
2919 case OLD_DATA_SPACE:
2920 return old_data_space_->Contains(addr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002921 case CODE_SPACE:
2922 return code_space_->Contains(addr);
2923 case MAP_SPACE:
2924 return map_space_->Contains(addr);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002925 case CELL_SPACE:
2926 return cell_space_->Contains(addr);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002927 case LO_SPACE:
2928 return lo_space_->SlowContains(addr);
2929 }
2930
2931 return false;
2932}
2933
2934
2935#ifdef DEBUG
2936void Heap::Verify() {
2937 ASSERT(HasBeenSetup());
2938
2939 VerifyPointersVisitor visitor;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002940 IterateRoots(&visitor);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002941
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00002942 new_space_.Verify();
2943
2944 VerifyPointersAndRSetVisitor rset_visitor;
2945 old_pointer_space_->Verify(&rset_visitor);
2946 map_space_->Verify(&rset_visitor);
2947
2948 VerifyPointersVisitor no_rset_visitor;
2949 old_data_space_->Verify(&no_rset_visitor);
2950 code_space_->Verify(&no_rset_visitor);
2951 cell_space_->Verify(&no_rset_visitor);
2952
2953 lo_space_->Verify();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002954}
2955#endif // DEBUG
2956
2957
2958Object* Heap::LookupSymbol(Vector<const char> string) {
2959 Object* symbol = NULL;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002960 Object* new_table = symbol_table()->LookupSymbol(string, &symbol);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002961 if (new_table->IsFailure()) return new_table;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002962 // Can't use set_symbol_table because SymbolTable::cast knows that
2963 // SymbolTable is a singleton and checks for identity.
2964 roots_[kSymbolTableRootIndex] = new_table;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002965 ASSERT(symbol != NULL);
2966 return symbol;
2967}
2968
2969
2970Object* Heap::LookupSymbol(String* string) {
2971 if (string->IsSymbol()) return string;
2972 Object* symbol = NULL;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002973 Object* new_table = symbol_table()->LookupString(string, &symbol);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002974 if (new_table->IsFailure()) return new_table;
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002975 // Can't use set_symbol_table because SymbolTable::cast knows that
2976 // SymbolTable is a singleton and checks for identity.
2977 roots_[kSymbolTableRootIndex] = new_table;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002978 ASSERT(symbol != NULL);
2979 return symbol;
2980}
2981
2982
ager@chromium.org7c537e22008-10-16 08:43:32 +00002983bool Heap::LookupSymbolIfExists(String* string, String** symbol) {
2984 if (string->IsSymbol()) {
2985 *symbol = string;
2986 return true;
2987 }
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00002988 return symbol_table()->LookupSymbolIfExists(string, symbol);
ager@chromium.org7c537e22008-10-16 08:43:32 +00002989}
2990
2991
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002992#ifdef DEBUG
2993void Heap::ZapFromSpace() {
ager@chromium.org18ad94b2009-09-02 08:22:29 +00002994 ASSERT(reinterpret_cast<Object*>(kFromSpaceZapValue)->IsHeapObject());
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00002995 for (Address a = new_space_.FromSpaceLow();
2996 a < new_space_.FromSpaceHigh();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002997 a += kPointerSize) {
2998 Memory::Address_at(a) = kFromSpaceZapValue;
2999 }
3000}
3001#endif // DEBUG
3002
3003
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003004int Heap::IterateRSetRange(Address object_start,
3005 Address object_end,
3006 Address rset_start,
3007 ObjectSlotCallback copy_object_func) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003008 Address object_address = object_start;
3009 Address rset_address = rset_start;
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003010 int set_bits_count = 0;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003011
3012 // Loop over all the pointers in [object_start, object_end).
3013 while (object_address < object_end) {
3014 uint32_t rset_word = Memory::uint32_at(rset_address);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003015 if (rset_word != 0) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003016 uint32_t result_rset = rset_word;
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003017 for (uint32_t bitmask = 1; bitmask != 0; bitmask = bitmask << 1) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003018 // Do not dereference pointers at or past object_end.
3019 if ((rset_word & bitmask) != 0 && object_address < object_end) {
3020 Object** object_p = reinterpret_cast<Object**>(object_address);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003021 if (Heap::InNewSpace(*object_p)) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003022 copy_object_func(reinterpret_cast<HeapObject**>(object_p));
3023 }
3024 // If this pointer does not need to be remembered anymore, clear
3025 // the remembered set bit.
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003026 if (!Heap::InNewSpace(*object_p)) result_rset &= ~bitmask;
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003027 set_bits_count++;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003028 }
3029 object_address += kPointerSize;
3030 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003031 // Update the remembered set if it has changed.
3032 if (result_rset != rset_word) {
3033 Memory::uint32_at(rset_address) = result_rset;
3034 }
3035 } else {
3036 // No bits in the word were set. This is the common case.
3037 object_address += kPointerSize * kBitsPerInt;
3038 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003039 rset_address += kIntSize;
3040 }
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003041 return set_bits_count;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003042}
3043
3044
3045void Heap::IterateRSet(PagedSpace* space, ObjectSlotCallback copy_object_func) {
3046 ASSERT(Page::is_rset_in_use());
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003047 ASSERT(space == old_pointer_space_ || space == map_space_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003048
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003049 static void* paged_rset_histogram = StatsTable::CreateHistogram(
3050 "V8.RSetPaged",
3051 0,
3052 Page::kObjectAreaSize / kPointerSize,
3053 30);
3054
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003055 PageIterator it(space, PageIterator::PAGES_IN_USE);
3056 while (it.has_next()) {
3057 Page* page = it.next();
kasperl@chromium.org71affb52009-05-26 05:44:31 +00003058 int count = IterateRSetRange(page->ObjectAreaStart(), page->AllocationTop(),
3059 page->RSetStart(), copy_object_func);
3060 if (paged_rset_histogram != NULL) {
3061 StatsTable::AddHistogramSample(paged_rset_histogram, count);
3062 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003063 }
3064}
3065
3066
3067#ifdef DEBUG
3068#define SYNCHRONIZE_TAG(tag) v->Synchronize(tag)
3069#else
3070#define SYNCHRONIZE_TAG(tag)
3071#endif
3072
3073void Heap::IterateRoots(ObjectVisitor* v) {
3074 IterateStrongRoots(v);
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003075 v->VisitPointer(reinterpret_cast<Object**>(&roots_[kSymbolTableRootIndex]));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003076 SYNCHRONIZE_TAG("symbol_table");
3077}
3078
3079
3080void Heap::IterateStrongRoots(ObjectVisitor* v) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +00003081 v->VisitPointers(&roots_[0], &roots_[kStrongRootListLength]);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003082 SYNCHRONIZE_TAG("strong_root_list");
3083
ager@chromium.org3b45ab52009-03-19 22:21:34 +00003084 v->VisitPointer(bit_cast<Object**, String**>(&hidden_symbol_));
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003085 SYNCHRONIZE_TAG("symbol");
3086
3087 Bootstrapper::Iterate(v);
3088 SYNCHRONIZE_TAG("bootstrapper");
3089 Top::Iterate(v);
3090 SYNCHRONIZE_TAG("top");
ager@chromium.org65dad4b2009-04-23 08:48:43 +00003091
3092#ifdef ENABLE_DEBUGGER_SUPPORT
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003093 Debug::Iterate(v);
ager@chromium.org65dad4b2009-04-23 08:48:43 +00003094#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003095 SYNCHRONIZE_TAG("debug");
kasperl@chromium.orgb9123622008-09-17 14:05:56 +00003096 CompilationCache::Iterate(v);
3097 SYNCHRONIZE_TAG("compilationcache");
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003098
3099 // Iterate over local handles in handle scopes.
3100 HandleScopeImplementer::Iterate(v);
3101 SYNCHRONIZE_TAG("handlescope");
3102
3103 // Iterate over the builtin code objects and code stubs in the heap. Note
3104 // that it is not strictly necessary to iterate over code objects on
3105 // scavenge collections. We still do it here because this same function
3106 // is used by the mark-sweep collector and the deserializer.
3107 Builtins::IterateBuiltins(v);
3108 SYNCHRONIZE_TAG("builtins");
3109
3110 // Iterate over global handles.
3111 GlobalHandles::IterateRoots(v);
3112 SYNCHRONIZE_TAG("globalhandles");
3113
3114 // Iterate over pointers being held by inactive threads.
3115 ThreadManager::Iterate(v);
3116 SYNCHRONIZE_TAG("threadmanager");
3117}
3118#undef SYNCHRONIZE_TAG
3119
3120
3121// Flag is set when the heap has been configured. The heap can be repeatedly
3122// configured through the API until it is setup.
3123static bool heap_configured = false;
3124
3125// TODO(1236194): Since the heap size is configurable on the command line
3126// and through the API, we should gracefully handle the case that the heap
3127// size is not big enough to fit all the initial objects.
3128bool Heap::ConfigureHeap(int semispace_size, int old_gen_size) {
3129 if (HasBeenSetup()) return false;
3130
3131 if (semispace_size > 0) semispace_size_ = semispace_size;
3132 if (old_gen_size > 0) old_generation_size_ = old_gen_size;
3133
3134 // The new space size must be a power of two to support single-bit testing
3135 // for containment.
mads.s.ager@gmail.com769cc962008-08-06 10:02:49 +00003136 semispace_size_ = RoundUpToPowerOf2(semispace_size_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003137 initial_semispace_size_ = Min(initial_semispace_size_, semispace_size_);
3138 young_generation_size_ = 2 * semispace_size_;
kasperl@chromium.orge959c182009-07-27 08:59:04 +00003139 external_allocation_limit_ = 10 * semispace_size_;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003140
3141 // The old generation is paged.
3142 old_generation_size_ = RoundUp(old_generation_size_, Page::kPageSize);
3143
3144 heap_configured = true;
3145 return true;
3146}
3147
3148
kasper.lund7276f142008-07-30 08:49:36 +00003149bool Heap::ConfigureHeapDefault() {
3150 return ConfigureHeap(FLAG_new_space_size, FLAG_old_space_size);
3151}
3152
3153
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003154int Heap::PromotedSpaceSize() {
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003155 return old_pointer_space_->Size()
3156 + old_data_space_->Size()
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003157 + code_space_->Size()
3158 + map_space_->Size()
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003159 + cell_space_->Size()
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003160 + lo_space_->Size();
3161}
3162
3163
kasper.lund7276f142008-07-30 08:49:36 +00003164int Heap::PromotedExternalMemorySize() {
3165 if (amount_of_external_allocated_memory_
3166 <= amount_of_external_allocated_memory_at_last_global_gc_) return 0;
3167 return amount_of_external_allocated_memory_
3168 - amount_of_external_allocated_memory_at_last_global_gc_;
3169}
3170
3171
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003172bool Heap::Setup(bool create_heap_objects) {
3173 // Initialize heap spaces and initial maps and objects. Whenever something
3174 // goes wrong, just return false. The caller should check the results and
3175 // call Heap::TearDown() to release allocated memory.
3176 //
3177 // If the heap is not yet configured (eg, through the API), configure it.
3178 // Configuration is based on the flags new-space-size (really the semispace
3179 // size) and old-space-size if set or the initial values of semispace_size_
3180 // and old_generation_size_ otherwise.
3181 if (!heap_configured) {
kasper.lund7276f142008-07-30 08:49:36 +00003182 if (!ConfigureHeapDefault()) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003183 }
3184
ager@chromium.orga1645e22009-09-09 19:27:10 +00003185 // Setup memory allocator and reserve a chunk of memory for new
3186 // space. The chunk is double the size of the new space to ensure
3187 // that we can find a pair of semispaces that are contiguous and
3188 // aligned to their size.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003189 if (!MemoryAllocator::Setup(MaxCapacity())) return false;
ager@chromium.orga1645e22009-09-09 19:27:10 +00003190 void* chunk =
3191 MemoryAllocator::ReserveInitialChunk(2 * young_generation_size_);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003192 if (chunk == NULL) return false;
3193
ager@chromium.orga1645e22009-09-09 19:27:10 +00003194 // Align the pair of semispaces to their size, which must be a power
3195 // of 2.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003196 ASSERT(IsPowerOf2(young_generation_size_));
ager@chromium.orga1645e22009-09-09 19:27:10 +00003197 Address new_space_start =
3198 RoundUp(reinterpret_cast<byte*>(chunk), young_generation_size_);
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003199 if (!new_space_.Setup(new_space_start, young_generation_size_)) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003200
ager@chromium.orga1645e22009-09-09 19:27:10 +00003201 // Initialize old pointer space.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003202 old_pointer_space_ =
3203 new OldSpace(old_generation_size_, OLD_POINTER_SPACE, NOT_EXECUTABLE);
3204 if (old_pointer_space_ == NULL) return false;
ager@chromium.orga1645e22009-09-09 19:27:10 +00003205 if (!old_pointer_space_->Setup(NULL, 0)) return false;
3206
3207 // Initialize old data space.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003208 old_data_space_ =
3209 new OldSpace(old_generation_size_, OLD_DATA_SPACE, NOT_EXECUTABLE);
3210 if (old_data_space_ == NULL) return false;
ager@chromium.orga1645e22009-09-09 19:27:10 +00003211 if (!old_data_space_->Setup(NULL, 0)) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003212
3213 // Initialize the code space, set its maximum capacity to the old
kasper.lund7276f142008-07-30 08:49:36 +00003214 // generation size. It needs executable memory.
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003215 code_space_ =
3216 new OldSpace(old_generation_size_, CODE_SPACE, EXECUTABLE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003217 if (code_space_ == NULL) return false;
ager@chromium.orga1645e22009-09-09 19:27:10 +00003218 if (!code_space_->Setup(NULL, 0)) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003219
3220 // Initialize map space.
kasper.lund7276f142008-07-30 08:49:36 +00003221 map_space_ = new MapSpace(kMaxMapSpaceSize, MAP_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003222 if (map_space_ == NULL) return false;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003223 if (!map_space_->Setup(NULL, 0)) return false;
3224
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003225 // Initialize global property cell space.
3226 cell_space_ = new CellSpace(old_generation_size_, CELL_SPACE);
3227 if (cell_space_ == NULL) return false;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003228 if (!cell_space_->Setup(NULL, 0)) return false;
3229
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003230 // The large object code space may contain code or data. We set the memory
3231 // to be non-executable here for safety, but this means we need to enable it
3232 // explicitly when allocating large code objects.
3233 lo_space_ = new LargeObjectSpace(LO_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003234 if (lo_space_ == NULL) return false;
3235 if (!lo_space_->Setup()) return false;
3236
3237 if (create_heap_objects) {
3238 // Create initial maps.
3239 if (!CreateInitialMaps()) return false;
3240 if (!CreateApiObjects()) return false;
3241
3242 // Create initial objects
3243 if (!CreateInitialObjects()) return false;
3244 }
3245
3246 LOG(IntEvent("heap-capacity", Capacity()));
3247 LOG(IntEvent("heap-available", Available()));
3248
3249 return true;
3250}
3251
3252
ager@chromium.org18ad94b2009-09-02 08:22:29 +00003253void Heap::SetStackLimit(intptr_t limit) {
3254 // On 64 bit machines, pointers are generally out of range of Smis. We write
3255 // something that looks like an out of range Smi to the GC.
3256
3257 // Set up the special root array entry containing the stack guard.
3258 // This is actually an address, but the tag makes the GC ignore it.
3259 roots_[kStackLimitRootIndex] =
3260 reinterpret_cast<Object*>((limit & ~kSmiTagMask) | kSmiTag);
3261}
3262
3263
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003264void Heap::TearDown() {
3265 GlobalHandles::TearDown();
3266
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003267 new_space_.TearDown();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003268
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003269 if (old_pointer_space_ != NULL) {
3270 old_pointer_space_->TearDown();
3271 delete old_pointer_space_;
3272 old_pointer_space_ = NULL;
3273 }
3274
3275 if (old_data_space_ != NULL) {
3276 old_data_space_->TearDown();
3277 delete old_data_space_;
3278 old_data_space_ = NULL;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003279 }
3280
3281 if (code_space_ != NULL) {
3282 code_space_->TearDown();
3283 delete code_space_;
3284 code_space_ = NULL;
3285 }
3286
3287 if (map_space_ != NULL) {
3288 map_space_->TearDown();
3289 delete map_space_;
3290 map_space_ = NULL;
3291 }
3292
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003293 if (cell_space_ != NULL) {
3294 cell_space_->TearDown();
3295 delete cell_space_;
3296 cell_space_ = NULL;
3297 }
3298
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003299 if (lo_space_ != NULL) {
3300 lo_space_->TearDown();
3301 delete lo_space_;
3302 lo_space_ = NULL;
3303 }
3304
3305 MemoryAllocator::TearDown();
3306}
3307
3308
3309void Heap::Shrink() {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003310 // Try to shrink all paged spaces.
3311 PagedSpaces spaces;
3312 while (PagedSpace* space = spaces.next()) space->Shrink();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003313}
3314
3315
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00003316#ifdef ENABLE_HEAP_PROTECTION
3317
3318void Heap::Protect() {
ager@chromium.org71daaf62009-04-01 07:22:49 +00003319 if (HasBeenSetup()) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003320 AllSpaces spaces;
3321 while (Space* space = spaces.next()) space->Protect();
ager@chromium.org71daaf62009-04-01 07:22:49 +00003322 }
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00003323}
3324
3325
3326void Heap::Unprotect() {
ager@chromium.org71daaf62009-04-01 07:22:49 +00003327 if (HasBeenSetup()) {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003328 AllSpaces spaces;
3329 while (Space* space = spaces.next()) space->Unprotect();
ager@chromium.org71daaf62009-04-01 07:22:49 +00003330 }
kasperl@chromium.orgf5aa8372009-03-24 14:47:14 +00003331}
3332
3333#endif
3334
3335
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003336#ifdef DEBUG
3337
3338class PrintHandleVisitor: public ObjectVisitor {
3339 public:
3340 void VisitPointers(Object** start, Object** end) {
3341 for (Object** p = start; p < end; p++)
3342 PrintF(" handle %p to %p\n", p, *p);
3343 }
3344};
3345
3346void Heap::PrintHandles() {
3347 PrintF("Handles:\n");
3348 PrintHandleVisitor v;
3349 HandleScopeImplementer::Iterate(&v);
3350}
3351
3352#endif
3353
3354
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003355Space* AllSpaces::next() {
3356 switch (counter_++) {
3357 case NEW_SPACE:
3358 return Heap::new_space();
3359 case OLD_POINTER_SPACE:
3360 return Heap::old_pointer_space();
3361 case OLD_DATA_SPACE:
3362 return Heap::old_data_space();
3363 case CODE_SPACE:
3364 return Heap::code_space();
3365 case MAP_SPACE:
3366 return Heap::map_space();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003367 case CELL_SPACE:
3368 return Heap::cell_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003369 case LO_SPACE:
3370 return Heap::lo_space();
3371 default:
3372 return NULL;
3373 }
3374}
3375
3376
3377PagedSpace* PagedSpaces::next() {
3378 switch (counter_++) {
3379 case OLD_POINTER_SPACE:
3380 return Heap::old_pointer_space();
3381 case OLD_DATA_SPACE:
3382 return Heap::old_data_space();
3383 case CODE_SPACE:
3384 return Heap::code_space();
3385 case MAP_SPACE:
3386 return Heap::map_space();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003387 case CELL_SPACE:
3388 return Heap::cell_space();
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003389 default:
3390 return NULL;
3391 }
3392}
3393
3394
3395
3396OldSpace* OldSpaces::next() {
3397 switch (counter_++) {
3398 case OLD_POINTER_SPACE:
3399 return Heap::old_pointer_space();
3400 case OLD_DATA_SPACE:
3401 return Heap::old_data_space();
3402 case CODE_SPACE:
3403 return Heap::code_space();
3404 default:
3405 return NULL;
3406 }
3407}
3408
3409
kasper.lund7276f142008-07-30 08:49:36 +00003410SpaceIterator::SpaceIterator() : current_space_(FIRST_SPACE), iterator_(NULL) {
3411}
3412
3413
3414SpaceIterator::~SpaceIterator() {
3415 // Delete active iterator if any.
3416 delete iterator_;
3417}
3418
3419
3420bool SpaceIterator::has_next() {
3421 // Iterate until no more spaces.
3422 return current_space_ != LAST_SPACE;
3423}
3424
3425
3426ObjectIterator* SpaceIterator::next() {
3427 if (iterator_ != NULL) {
3428 delete iterator_;
3429 iterator_ = NULL;
3430 // Move to the next space
3431 current_space_++;
3432 if (current_space_ > LAST_SPACE) {
3433 return NULL;
3434 }
3435 }
3436
3437 // Return iterator for the new current space.
3438 return CreateIterator();
3439}
3440
3441
3442// Create an iterator for the space to iterate.
3443ObjectIterator* SpaceIterator::CreateIterator() {
3444 ASSERT(iterator_ == NULL);
3445
3446 switch (current_space_) {
3447 case NEW_SPACE:
3448 iterator_ = new SemiSpaceIterator(Heap::new_space());
3449 break;
ager@chromium.org9258b6b2008-09-11 09:11:10 +00003450 case OLD_POINTER_SPACE:
3451 iterator_ = new HeapObjectIterator(Heap::old_pointer_space());
3452 break;
3453 case OLD_DATA_SPACE:
3454 iterator_ = new HeapObjectIterator(Heap::old_data_space());
kasper.lund7276f142008-07-30 08:49:36 +00003455 break;
3456 case CODE_SPACE:
3457 iterator_ = new HeapObjectIterator(Heap::code_space());
3458 break;
3459 case MAP_SPACE:
3460 iterator_ = new HeapObjectIterator(Heap::map_space());
3461 break;
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +00003462 case CELL_SPACE:
3463 iterator_ = new HeapObjectIterator(Heap::cell_space());
3464 break;
kasper.lund7276f142008-07-30 08:49:36 +00003465 case LO_SPACE:
3466 iterator_ = new LargeObjectIterator(Heap::lo_space());
3467 break;
3468 }
3469
3470 // Return the newly allocated iterator;
3471 ASSERT(iterator_ != NULL);
3472 return iterator_;
3473}
3474
3475
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003476HeapIterator::HeapIterator() {
3477 Init();
3478}
3479
3480
3481HeapIterator::~HeapIterator() {
3482 Shutdown();
3483}
3484
3485
3486void HeapIterator::Init() {
3487 // Start the iteration.
3488 space_iterator_ = new SpaceIterator();
3489 object_iterator_ = space_iterator_->next();
3490}
3491
3492
3493void HeapIterator::Shutdown() {
3494 // Make sure the last iterator is deallocated.
3495 delete space_iterator_;
3496 space_iterator_ = NULL;
3497 object_iterator_ = NULL;
3498}
3499
3500
3501bool HeapIterator::has_next() {
3502 // No iterator means we are done.
3503 if (object_iterator_ == NULL) return false;
3504
3505 if (object_iterator_->has_next_object()) {
3506 // If the current iterator has more objects we are fine.
3507 return true;
3508 } else {
3509 // Go though the spaces looking for one that has objects.
3510 while (space_iterator_->has_next()) {
3511 object_iterator_ = space_iterator_->next();
3512 if (object_iterator_->has_next_object()) {
3513 return true;
3514 }
3515 }
3516 }
3517 // Done with the last space.
3518 object_iterator_ = NULL;
3519 return false;
3520}
3521
3522
3523HeapObject* HeapIterator::next() {
3524 if (has_next()) {
3525 return object_iterator_->next_object();
3526 } else {
3527 return NULL;
3528 }
3529}
3530
3531
3532void HeapIterator::reset() {
3533 // Restart the iterator.
3534 Shutdown();
3535 Init();
3536}
3537
3538
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003539#ifdef DEBUG
3540
3541static bool search_for_any_global;
3542static Object* search_target;
3543static bool found_target;
3544static List<Object*> object_stack(20);
3545
3546
3547// Tags 0, 1, and 3 are used. Use 2 for marking visited HeapObject.
3548static const int kMarkTag = 2;
3549
3550static void MarkObjectRecursively(Object** p);
3551class MarkObjectVisitor : public ObjectVisitor {
3552 public:
3553 void VisitPointers(Object** start, Object** end) {
3554 // Copy all HeapObject pointers in [start, end)
3555 for (Object** p = start; p < end; p++) {
3556 if ((*p)->IsHeapObject())
3557 MarkObjectRecursively(p);
3558 }
3559 }
3560};
3561
3562static MarkObjectVisitor mark_visitor;
3563
3564static void MarkObjectRecursively(Object** p) {
3565 if (!(*p)->IsHeapObject()) return;
3566
3567 HeapObject* obj = HeapObject::cast(*p);
3568
3569 Object* map = obj->map();
3570
3571 if (!map->IsHeapObject()) return; // visited before
3572
3573 if (found_target) return; // stop if target found
3574 object_stack.Add(obj);
3575 if ((search_for_any_global && obj->IsJSGlobalObject()) ||
3576 (!search_for_any_global && (obj == search_target))) {
3577 found_target = true;
3578 return;
3579 }
3580
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003581 // not visited yet
3582 Map* map_p = reinterpret_cast<Map*>(HeapObject::cast(map));
3583
3584 Address map_addr = map_p->address();
3585
3586 obj->set_map(reinterpret_cast<Map*>(map_addr + kMarkTag));
3587
3588 MarkObjectRecursively(&map);
3589
3590 obj->IterateBody(map_p->instance_type(), obj->SizeFromMap(map_p),
3591 &mark_visitor);
3592
3593 if (!found_target) // don't pop if found the target
3594 object_stack.RemoveLast();
3595}
3596
3597
3598static void UnmarkObjectRecursively(Object** p);
3599class UnmarkObjectVisitor : public ObjectVisitor {
3600 public:
3601 void VisitPointers(Object** start, Object** end) {
3602 // Copy all HeapObject pointers in [start, end)
3603 for (Object** p = start; p < end; p++) {
3604 if ((*p)->IsHeapObject())
3605 UnmarkObjectRecursively(p);
3606 }
3607 }
3608};
3609
3610static UnmarkObjectVisitor unmark_visitor;
3611
3612static void UnmarkObjectRecursively(Object** p) {
3613 if (!(*p)->IsHeapObject()) return;
3614
3615 HeapObject* obj = HeapObject::cast(*p);
3616
3617 Object* map = obj->map();
3618
3619 if (map->IsHeapObject()) return; // unmarked already
3620
3621 Address map_addr = reinterpret_cast<Address>(map);
3622
3623 map_addr -= kMarkTag;
3624
3625 ASSERT_TAG_ALIGNED(map_addr);
3626
3627 HeapObject* map_p = HeapObject::FromAddress(map_addr);
3628
3629 obj->set_map(reinterpret_cast<Map*>(map_p));
3630
3631 UnmarkObjectRecursively(reinterpret_cast<Object**>(&map_p));
3632
3633 obj->IterateBody(Map::cast(map_p)->instance_type(),
3634 obj->SizeFromMap(Map::cast(map_p)),
3635 &unmark_visitor);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003636}
3637
3638
3639static void MarkRootObjectRecursively(Object** root) {
3640 if (search_for_any_global) {
3641 ASSERT(search_target == NULL);
3642 } else {
3643 ASSERT(search_target->IsHeapObject());
3644 }
3645 found_target = false;
3646 object_stack.Clear();
3647
3648 MarkObjectRecursively(root);
3649 UnmarkObjectRecursively(root);
3650
3651 if (found_target) {
3652 PrintF("=====================================\n");
3653 PrintF("==== Path to object ====\n");
3654 PrintF("=====================================\n\n");
3655
3656 ASSERT(!object_stack.is_empty());
3657 for (int i = 0; i < object_stack.length(); i++) {
3658 if (i > 0) PrintF("\n |\n |\n V\n\n");
3659 Object* obj = object_stack[i];
3660 obj->Print();
3661 }
3662 PrintF("=====================================\n");
3663 }
3664}
3665
3666
3667// Helper class for visiting HeapObjects recursively.
3668class MarkRootVisitor: public ObjectVisitor {
3669 public:
3670 void VisitPointers(Object** start, Object** end) {
3671 // Visit all HeapObject pointers in [start, end)
3672 for (Object** p = start; p < end; p++) {
3673 if ((*p)->IsHeapObject())
3674 MarkRootObjectRecursively(p);
3675 }
3676 }
3677};
3678
3679
3680// Triggers a depth-first traversal of reachable objects from roots
3681// and finds a path to a specific heap object and prints it.
3682void Heap::TracePathToObject() {
3683 search_target = NULL;
3684 search_for_any_global = false;
3685
3686 MarkRootVisitor root_visitor;
3687 IterateRoots(&root_visitor);
3688}
3689
3690
3691// Triggers a depth-first traversal of reachable objects from roots
3692// and finds a path to any global object and prints it. Useful for
3693// determining the source for leaks of global objects.
3694void Heap::TracePathToGlobal() {
3695 search_target = NULL;
3696 search_for_any_global = true;
3697
3698 MarkRootVisitor root_visitor;
3699 IterateRoots(&root_visitor);
3700}
3701#endif
3702
3703
kasper.lund7276f142008-07-30 08:49:36 +00003704GCTracer::GCTracer()
3705 : start_time_(0.0),
3706 start_size_(0.0),
3707 gc_count_(0),
3708 full_gc_count_(0),
3709 is_compacting_(false),
3710 marked_count_(0) {
3711 // These two fields reflect the state of the previous full collection.
3712 // Set them before they are changed by the collector.
3713 previous_has_compacted_ = MarkCompactCollector::HasCompacted();
3714 previous_marked_count_ = MarkCompactCollector::previous_marked_count();
3715 if (!FLAG_trace_gc) return;
3716 start_time_ = OS::TimeCurrentMillis();
3717 start_size_ = SizeOfHeapObjects();
3718}
3719
3720
3721GCTracer::~GCTracer() {
3722 if (!FLAG_trace_gc) return;
3723 // Printf ONE line iff flag is set.
3724 PrintF("%s %.1f -> %.1f MB, %d ms.\n",
3725 CollectorString(),
3726 start_size_, SizeOfHeapObjects(),
3727 static_cast<int>(OS::TimeCurrentMillis() - start_time_));
kasperl@chromium.orge959c182009-07-27 08:59:04 +00003728
3729#if defined(ENABLE_LOGGING_AND_PROFILING)
3730 Heap::PrintShortHeapStatistics();
3731#endif
kasper.lund7276f142008-07-30 08:49:36 +00003732}
3733
3734
3735const char* GCTracer::CollectorString() {
3736 switch (collector_) {
3737 case SCAVENGER:
3738 return "Scavenge";
3739 case MARK_COMPACTOR:
3740 return MarkCompactCollector::HasCompacted() ? "Mark-compact"
3741 : "Mark-sweep";
3742 }
3743 return "Unknown GC";
3744}
3745
3746
ager@chromium.org5aa501c2009-06-23 07:57:28 +00003747int KeyedLookupCache::Hash(Map* map, String* name) {
3748 // Uses only lower 32 bits if pointers are larger.
3749 uintptr_t addr_hash =
3750 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(map)) >> 2;
3751 return (addr_hash ^ name->Hash()) % kLength;
3752}
3753
3754
3755int KeyedLookupCache::Lookup(Map* map, String* name) {
3756 int index = Hash(map, name);
3757 Key& key = keys_[index];
3758 if ((key.map == map) && key.name->Equals(name)) {
3759 return field_offsets_[index];
3760 }
3761 return -1;
3762}
3763
3764
3765void KeyedLookupCache::Update(Map* map, String* name, int field_offset) {
3766 String* symbol;
3767 if (Heap::LookupSymbolIfExists(name, &symbol)) {
3768 int index = Hash(map, symbol);
3769 Key& key = keys_[index];
3770 key.map = map;
3771 key.name = symbol;
3772 field_offsets_[index] = field_offset;
3773 }
3774}
3775
3776
3777void KeyedLookupCache::Clear() {
3778 for (int index = 0; index < kLength; index++) keys_[index].map = NULL;
3779}
3780
3781
3782KeyedLookupCache::Key KeyedLookupCache::keys_[KeyedLookupCache::kLength];
3783
3784
3785int KeyedLookupCache::field_offsets_[KeyedLookupCache::kLength];
3786
3787
3788void DescriptorLookupCache::Clear() {
3789 for (int index = 0; index < kLength; index++) keys_[index].array = NULL;
3790}
3791
3792
3793DescriptorLookupCache::Key
3794DescriptorLookupCache::keys_[DescriptorLookupCache::kLength];
3795
3796int DescriptorLookupCache::results_[DescriptorLookupCache::kLength];
3797
3798
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +00003799#ifdef DEBUG
3800bool Heap::GarbageCollectionGreedyCheck() {
3801 ASSERT(FLAG_gc_greedy);
3802 if (Bootstrapper::IsActive()) return true;
3803 if (disallow_allocation_failure()) return true;
3804 return CollectGarbage(0, NEW_SPACE);
3805}
3806#endif
3807
ager@chromium.org18ad94b2009-09-02 08:22:29 +00003808
3809TranscendentalCache::TranscendentalCache(TranscendentalCache::Type t)
3810 : type_(t) {
3811 uint32_t in0 = 0xffffffffu; // Bit-pattern for a NaN that isn't
3812 uint32_t in1 = 0xffffffffu; // generated by the FPU.
3813 for (int i = 0; i < kCacheSize; i++) {
3814 elements_[i].in[0] = in0;
3815 elements_[i].in[1] = in1;
3816 elements_[i].output = NULL;
3817 }
3818}
3819
3820
3821TranscendentalCache* TranscendentalCache::caches_[kNumberOfCaches];
3822
3823
3824void TranscendentalCache::Clear() {
3825 for (int i = 0; i < kNumberOfCaches; i++) {
3826 if (caches_[i] != NULL) {
3827 delete caches_[i];
3828 caches_[i] = NULL;
3829 }
3830 }
3831}
3832
3833
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00003834} } // namespace v8::internal