blob: 9d79db246675b30890448be4f2df0a8b128b77d4 [file] [log] [blame]
danno@chromium.orgfa458e42012-02-01 10:48:36 +00001// Copyright 2012 the V8 project authors. All rights reserved.
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +00002// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6// * Redistributions of source code must retain the above copyright
7// notice, this list of conditions and the following disclaimer.
8// * Redistributions in binary form must reproduce the above
9// copyright notice, this list of conditions and the following
10// disclaimer in the documentation and/or other materials provided
11// with the distribution.
12// * Neither the name of Google Inc. nor the names of its
13// contributors may be used to endorse or promote products derived
14// from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#ifndef V8_HEAP_INL_H_
29#define V8_HEAP_INL_H_
30
ricow@chromium.orgd236f4d2010-09-01 06:52:08 +000031#include "heap.h"
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000032#include "isolate.h"
fschneider@chromium.orgfb144a02011-05-04 12:43:48 +000033#include "list-inl.h"
34#include "objects.h"
ulan@chromium.org9a21ec42012-03-06 08:42:24 +000035#include "platform.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000036#include "v8-counters.h"
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000037#include "store-buffer.h"
38#include "store-buffer-inl.h"
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000039
kasperl@chromium.org71affb52009-05-26 05:44:31 +000040namespace v8 {
41namespace internal {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +000042
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000043void PromotionQueue::insert(HeapObject* target, int size) {
danno@chromium.orgc612e022011-11-10 11:38:15 +000044 if (emergency_stack_ != NULL) {
45 emergency_stack_->Add(Entry(target, size));
46 return;
47 }
48
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000049 if (NewSpacePage::IsAtStart(reinterpret_cast<Address>(rear_))) {
50 NewSpacePage* rear_page =
51 NewSpacePage::FromAddress(reinterpret_cast<Address>(rear_));
52 ASSERT(!rear_page->prev_page()->is_anchor());
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +000053 rear_ = reinterpret_cast<intptr_t*>(rear_page->prev_page()->area_end());
danno@chromium.orgc612e022011-11-10 11:38:15 +000054 ActivateGuardIfOnTheSamePage();
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000055 }
danno@chromium.orgc612e022011-11-10 11:38:15 +000056
57 if (guard_) {
58 ASSERT(GetHeadPage() ==
59 Page::FromAllocationTop(reinterpret_cast<Address>(limit_)));
60
61 if ((rear_ - 2) < limit_) {
62 RelocateQueueHead();
63 emergency_stack_->Add(Entry(target, size));
64 return;
65 }
66 }
67
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000068 *(--rear_) = reinterpret_cast<intptr_t>(target);
69 *(--rear_) = size;
70 // Assert no overflow into live objects.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +000071#ifdef DEBUG
72 SemiSpace::AssertValidRange(HEAP->new_space()->top(),
73 reinterpret_cast<Address>(rear_));
74#endif
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +000075}
76
77
danno@chromium.orgc612e022011-11-10 11:38:15 +000078void PromotionQueue::ActivateGuardIfOnTheSamePage() {
79 guard_ = guard_ ||
80 heap_->new_space()->active_space()->current_page()->address() ==
81 GetHeadPage()->address();
82}
83
84
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +000085MaybeObject* Heap::AllocateStringFromUtf8(Vector<const char> str,
86 PretenureFlag pretenure) {
87 // Check for ASCII first since this is the common case.
88 if (String::IsAscii(str.start(), str.length())) {
89 // If the string is ASCII, we do not need to convert the characters
90 // since UTF8 is backwards compatible with ASCII.
91 return AllocateStringFromAscii(str, pretenure);
92 }
93 // Non-ASCII and we need to decode.
94 return AllocateStringFromUtf8Slow(str, pretenure);
95}
96
97
lrn@chromium.org303ada72010-10-27 09:33:13 +000098MaybeObject* Heap::AllocateSymbol(Vector<const char> str,
99 int chars,
100 uint32_t hash_field) {
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000101 unibrow::Utf8InputBuffer<> buffer(str.start(),
102 static_cast<unsigned>(str.length()));
sgjesse@chromium.orgac6aa172009-12-04 12:29:05 +0000103 return AllocateInternalSymbol(&buffer, chars, hash_field);
ager@chromium.orga74f0da2008-12-03 16:05:52 +0000104}
105
106
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +0000107MaybeObject* Heap::AllocateAsciiSymbol(Vector<const char> str,
108 uint32_t hash_field) {
109 if (str.length() > SeqAsciiString::kMaxLength) {
110 return Failure::OutOfMemoryException();
111 }
112 // Compute map and object size.
113 Map* map = ascii_symbol_map();
114 int size = SeqAsciiString::SizeFor(str.length());
115
116 // Allocate string.
117 Object* result;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +0000118 { MaybeObject* maybe_result = (size > Page::kMaxNonCodeHeapObjectSize)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000119 ? lo_space_->AllocateRaw(size, NOT_EXECUTABLE)
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +0000120 : old_data_space_->AllocateRaw(size);
121 if (!maybe_result->ToObject(&result)) return maybe_result;
122 }
123
ricow@chromium.org64e3a4b2011-12-13 08:07:27 +0000124 // String maps are all immortal immovable objects.
125 reinterpret_cast<HeapObject*>(result)->set_map_no_write_barrier(map);
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +0000126 // Set length and hash fields of the allocated string.
127 String* answer = String::cast(result);
128 answer->set_length(str.length());
129 answer->set_hash_field(hash_field);
130
131 ASSERT_EQ(size, answer->Size());
132
133 // Fill in the characters.
134 memcpy(answer->address() + SeqAsciiString::kHeaderSize,
135 str.start(), str.length());
136
137 return answer;
138}
139
140
141MaybeObject* Heap::AllocateTwoByteSymbol(Vector<const uc16> str,
142 uint32_t hash_field) {
143 if (str.length() > SeqTwoByteString::kMaxLength) {
144 return Failure::OutOfMemoryException();
145 }
146 // Compute map and object size.
147 Map* map = symbol_map();
148 int size = SeqTwoByteString::SizeFor(str.length());
149
150 // Allocate string.
151 Object* result;
yangguo@chromium.orgab30bb82012-02-24 14:41:46 +0000152 { MaybeObject* maybe_result = (size > Page::kMaxNonCodeHeapObjectSize)
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000153 ? lo_space_->AllocateRaw(size, NOT_EXECUTABLE)
fschneider@chromium.org9e3e0b62011-01-03 10:16:46 +0000154 : old_data_space_->AllocateRaw(size);
155 if (!maybe_result->ToObject(&result)) return maybe_result;
156 }
157
158 reinterpret_cast<HeapObject*>(result)->set_map(map);
159 // Set length and hash fields of the allocated string.
160 String* answer = String::cast(result);
161 answer->set_length(str.length());
162 answer->set_hash_field(hash_field);
163
164 ASSERT_EQ(size, answer->Size());
165
166 // Fill in the characters.
167 memcpy(answer->address() + SeqTwoByteString::kHeaderSize,
168 str.start(), str.length() * kUC16Size);
169
170 return answer;
171}
172
lrn@chromium.org303ada72010-10-27 09:33:13 +0000173MaybeObject* Heap::CopyFixedArray(FixedArray* src) {
whesse@chromium.org4a1fe7d2010-09-27 12:32:04 +0000174 return CopyFixedArrayWithMap(src, src->map());
175}
176
177
ricow@chromium.org2c99e282011-07-28 09:15:17 +0000178MaybeObject* Heap::CopyFixedDoubleArray(FixedDoubleArray* src) {
179 return CopyFixedDoubleArrayWithMap(src, src->map());
180}
181
182
lrn@chromium.org303ada72010-10-27 09:33:13 +0000183MaybeObject* Heap::AllocateRaw(int size_in_bytes,
184 AllocationSpace space,
185 AllocationSpace retry_space) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000186 ASSERT(allocation_allowed_ && gc_state_ == NOT_IN_GC);
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000187 ASSERT(space != NEW_SPACE ||
188 retry_space == OLD_POINTER_SPACE ||
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000189 retry_space == OLD_DATA_SPACE ||
190 retry_space == LO_SPACE);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000191#ifdef DEBUG
192 if (FLAG_gc_interval >= 0 &&
193 !disallow_allocation_failure_ &&
194 Heap::allocation_timeout_-- <= 0) {
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000195 return Failure::RetryAfterGC(space);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000196 }
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000197 isolate_->counters()->objs_since_last_full()->Increment();
198 isolate_->counters()->objs_since_last_young()->Increment();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000199#endif
lrn@chromium.org303ada72010-10-27 09:33:13 +0000200 MaybeObject* result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000201 if (NEW_SPACE == space) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000202 result = new_space_.AllocateRaw(size_in_bytes);
203 if (always_allocate() && result->IsFailure()) {
204 space = retry_space;
205 } else {
206 return result;
207 }
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000208 }
209
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000210 if (OLD_POINTER_SPACE == space) {
211 result = old_pointer_space_->AllocateRaw(size_in_bytes);
212 } else if (OLD_DATA_SPACE == space) {
213 result = old_data_space_->AllocateRaw(size_in_bytes);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000214 } else if (CODE_SPACE == space) {
215 result = code_space_->AllocateRaw(size_in_bytes);
216 } else if (LO_SPACE == space) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000217 result = lo_space_->AllocateRaw(size_in_bytes, NOT_EXECUTABLE);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000218 } else if (CELL_SPACE == space) {
219 result = cell_space_->AllocateRaw(size_in_bytes);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000220 } else {
221 ASSERT(MAP_SPACE == space);
222 result = map_space_->AllocateRaw(size_in_bytes);
223 }
224 if (result->IsFailure()) old_gen_exhausted_ = true;
225 return result;
226}
227
228
erikcorry0ad885c2011-11-21 13:51:57 +0000229MaybeObject* Heap::NumberFromInt32(
230 int32_t value, PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000231 if (Smi::IsValid(value)) return Smi::FromInt(value);
232 // Bypass NumberFromDouble to avoid various redundant checks.
erikcorry0ad885c2011-11-21 13:51:57 +0000233 return AllocateHeapNumber(FastI2D(value), pretenure);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000234}
235
236
erikcorry0ad885c2011-11-21 13:51:57 +0000237MaybeObject* Heap::NumberFromUint32(
238 uint32_t value, PretenureFlag pretenure) {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000239 if ((int32_t)value >= 0 && Smi::IsValid((int32_t)value)) {
240 return Smi::FromInt((int32_t)value);
241 }
242 // Bypass NumberFromDouble to avoid various redundant checks.
erikcorry0ad885c2011-11-21 13:51:57 +0000243 return AllocateHeapNumber(FastUI2D(value), pretenure);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000244}
245
246
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000247void Heap::FinalizeExternalString(String* string) {
248 ASSERT(string->IsExternalString());
249 v8::String::ExternalStringResourceBase** resource_addr =
250 reinterpret_cast<v8::String::ExternalStringResourceBase**>(
251 reinterpret_cast<byte*>(string) +
252 ExternalString::kResourceOffset -
253 kHeapObjectTag);
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000254
vegorov@chromium.org2356e6f2010-06-09 09:38:56 +0000255 // Dispose of the C++ object if it has not already been disposed.
256 if (*resource_addr != NULL) {
257 (*resource_addr)->Dispose();
mstarzinger@chromium.org1b3afd12011-11-29 14:28:56 +0000258 *resource_addr = NULL;
lrn@chromium.org1af7e1b2010-06-07 11:12:01 +0000259 }
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000260}
261
262
lrn@chromium.org303ada72010-10-27 09:33:13 +0000263MaybeObject* Heap::AllocateRawMap() {
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000264#ifdef DEBUG
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000265 isolate_->counters()->objs_since_last_full()->Increment();
266 isolate_->counters()->objs_since_last_young()->Increment();
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000267#endif
lrn@chromium.org303ada72010-10-27 09:33:13 +0000268 MaybeObject* result = map_space_->AllocateRaw(Map::kSize);
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000269 if (result->IsFailure()) old_gen_exhausted_ = true;
sgjesse@chromium.org846fb742009-12-18 08:56:33 +0000270#ifdef DEBUG
271 if (!result->IsFailure()) {
272 // Maps have their own alignment.
fschneider@chromium.org086aac62010-03-17 13:18:24 +0000273 CHECK((reinterpret_cast<intptr_t>(result) & kMapAlignmentMask) ==
274 static_cast<intptr_t>(kHeapObjectTag));
sgjesse@chromium.org846fb742009-12-18 08:56:33 +0000275 }
276#endif
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000277 return result;
278}
279
280
lrn@chromium.org303ada72010-10-27 09:33:13 +0000281MaybeObject* Heap::AllocateRawCell() {
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000282#ifdef DEBUG
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000283 isolate_->counters()->objs_since_last_full()->Increment();
284 isolate_->counters()->objs_since_last_young()->Increment();
kasperl@chromium.orgdefbd102009-07-13 14:04:26 +0000285#endif
lrn@chromium.org303ada72010-10-27 09:33:13 +0000286 MaybeObject* result = cell_space_->AllocateRaw(JSGlobalPropertyCell::kSize);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000287 if (result->IsFailure()) old_gen_exhausted_ = true;
288 return result;
289}
290
291
292bool Heap::InNewSpace(Object* object) {
sgjesse@chromium.orgb302e562010-02-03 11:26:59 +0000293 bool result = new_space_.Contains(object);
294 ASSERT(!result || // Either not in new space
295 gc_state_ != NOT_IN_GC || // ... or in the middle of GC
296 InToSpace(object)); // ... or in to-space (where we allocate).
297 return result;
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000298}
299
300
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000301bool Heap::InNewSpace(Address addr) {
302 return new_space_.Contains(addr);
303}
304
305
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000306bool Heap::InFromSpace(Object* object) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000307 return new_space_.FromSpaceContains(object);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000308}
309
310
311bool Heap::InToSpace(Object* object) {
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000312 return new_space_.ToSpaceContains(object);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000313}
314
315
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000316bool Heap::OldGenerationAllocationLimitReached() {
317 if (!incremental_marking()->IsStopped()) return false;
318 return OldGenerationSpaceAvailable() < 0;
319}
320
321
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000322bool Heap::ShouldBePromoted(Address old_address, int object_size) {
323 // An object should be promoted if:
324 // - the object has survived a scavenge operation or
325 // - to space is already 25% full.
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000326 NewSpacePage* page = NewSpacePage::FromAddress(old_address);
327 Address age_mark = new_space_.age_mark();
328 bool below_mark = page->IsFlagSet(MemoryChunk::NEW_SPACE_BELOW_AGE_MARK) &&
329 (!page->ContainsLimit(age_mark) || old_address < age_mark);
330 return below_mark || (new_space_.Size() + object_size) >=
331 (new_space_.EffectiveCapacity() >> 2);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000332}
333
334
335void Heap::RecordWrite(Address address, int offset) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000336 if (!InNewSpace(address)) store_buffer_.Mark(address + offset);
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000337}
338
339
ager@chromium.orgce5e87b2010-03-10 10:24:18 +0000340void Heap::RecordWrites(Address address, int start, int len) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000341 if (!InNewSpace(address)) {
342 for (int i = 0; i < len; i++) {
343 store_buffer_.Mark(address + start + i * kPointerSize);
344 }
345 }
ager@chromium.orgce5e87b2010-03-10 10:24:18 +0000346}
347
348
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000349OldSpace* Heap::TargetSpace(HeapObject* object) {
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000350 InstanceType type = object->map()->instance_type();
351 AllocationSpace space = TargetSpaceId(type);
352 return (space == OLD_POINTER_SPACE)
353 ? old_pointer_space_
354 : old_data_space_;
355}
356
357
358AllocationSpace Heap::TargetSpaceId(InstanceType type) {
ager@chromium.org9258b6b2008-09-11 09:11:10 +0000359 // Heap numbers and sequential strings are promoted to old data space, all
360 // other object types are promoted to old pointer space. We do not use
kasper.lund7276f142008-07-30 08:49:36 +0000361 // object->IsHeapNumber() and object->IsSeqString() because we already
362 // know that object has the heap object tag.
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000363
364 // These objects are never allocated in new space.
365 ASSERT(type != MAP_TYPE);
366 ASSERT(type != CODE_TYPE);
367 ASSERT(type != ODDBALL_TYPE);
368 ASSERT(type != JS_GLOBAL_PROPERTY_CELL_TYPE);
369
370 if (type < FIRST_NONSTRING_TYPE) {
ricow@chromium.org4668a2c2011-08-29 10:41:00 +0000371 // There are four string representations: sequential strings, external
372 // strings, cons strings, and sliced strings.
373 // Only the latter two contain non-map-word pointers to heap objects.
374 return ((type & kIsIndirectStringMask) == kIsIndirectStringTag)
fschneider@chromium.org0c20e672010-01-14 15:28:53 +0000375 ? OLD_POINTER_SPACE
376 : OLD_DATA_SPACE;
377 } else {
378 return (type <= LAST_DATA_TYPE) ? OLD_DATA_SPACE : OLD_POINTER_SPACE;
379 }
kasper.lund7276f142008-07-30 08:49:36 +0000380}
381
382
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000383void Heap::CopyBlock(Address dst, Address src, int byte_size) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000384 CopyWords(reinterpret_cast<Object**>(dst),
385 reinterpret_cast<Object**>(src),
386 byte_size / kPointerSize);
lrn@chromium.org25156de2010-04-06 13:10:27 +0000387}
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000388
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000389
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000390void Heap::MoveBlock(Address dst, Address src, int byte_size) {
ricow@chromium.orgc9c80822010-04-21 08:22:37 +0000391 ASSERT(IsAligned(byte_size, kPointerSize));
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +0000392
393 int size_in_words = byte_size / kPointerSize;
394
ricow@chromium.org9fa09672011-07-25 11:05:35 +0000395 if ((dst < src) || (dst >= (src + byte_size))) {
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000396 Object** src_slot = reinterpret_cast<Object**>(src);
397 Object** dst_slot = reinterpret_cast<Object**>(dst);
398 Object** end_slot = src_slot + size_in_words;
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +0000399
ricow@chromium.org30ce4112010-05-31 10:38:25 +0000400 while (src_slot != end_slot) {
401 *dst_slot++ = *src_slot++;
whesse@chromium.orgb6e43bb2010-04-14 09:36:28 +0000402 }
403 } else {
404 memmove(dst, src, byte_size);
405 }
406}
407
408
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000409void Heap::ScavengePointer(HeapObject** p) {
410 ScavengeObject(p, *p);
411}
412
413
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000414void Heap::ScavengeObject(HeapObject** p, HeapObject* object) {
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000415 ASSERT(HEAP->InFromSpace(object));
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000416
417 // We use the first word (where the map pointer usually is) of a heap
418 // object to record the forwarding pointer. A forwarding pointer can
419 // point to an old space, the code space, or the to space of the new
420 // generation.
421 MapWord first_word = object->map_word();
422
423 // If the first word is a forwarding address, the object has already been
424 // copied.
425 if (first_word.IsForwardingAddress()) {
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000426 HeapObject* dest = first_word.ToForwardingAddress();
427 ASSERT(HEAP->InFromSpace(*p));
428 *p = dest;
kasperl@chromium.orgb3284ad2009-05-18 06:12:45 +0000429 return;
430 }
431
432 // Call the slow part of scavenge object.
433 return ScavengeObjectSlow(p, object);
434}
435
436
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000437bool Heap::CollectGarbage(AllocationSpace space, const char* gc_reason) {
438 const char* collector_reason = NULL;
439 GarbageCollector collector = SelectGarbageCollector(space, &collector_reason);
440 return CollectGarbage(space, collector, gc_reason, collector_reason);
whesse@chromium.orgf0ac72d2010-11-08 12:47:26 +0000441}
442
443
lrn@chromium.org303ada72010-10-27 09:33:13 +0000444MaybeObject* Heap::PrepareForCompare(String* str) {
fschneider@chromium.org086aac62010-03-17 13:18:24 +0000445 // Always flatten small strings and force flattening of long strings
446 // after we have accumulated a certain amount we failed to flatten.
447 static const int kMaxAlwaysFlattenLength = 32;
448 static const int kFlattenLongThreshold = 16*KB;
449
450 const int length = str->length();
lrn@chromium.org303ada72010-10-27 09:33:13 +0000451 MaybeObject* obj = str->TryFlatten();
fschneider@chromium.org086aac62010-03-17 13:18:24 +0000452 if (length <= kMaxAlwaysFlattenLength ||
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +0000453 unflattened_strings_length_ >= kFlattenLongThreshold) {
fschneider@chromium.org086aac62010-03-17 13:18:24 +0000454 return obj;
455 }
456 if (obj->IsFailure()) {
kmillikin@chromium.org5d8f0e62010-03-24 08:21:20 +0000457 unflattened_strings_length_ += length;
fschneider@chromium.org086aac62010-03-17 13:18:24 +0000458 }
459 return str;
460}
461
462
jkummerow@chromium.org28faa982012-04-13 09:58:30 +0000463intptr_t Heap::AdjustAmountOfExternalAllocatedMemory(
464 intptr_t change_in_bytes) {
erik.corry@gmail.comf2038fb2012-01-16 11:42:08 +0000465 ASSERT(HasBeenSetUp());
jkummerow@chromium.org28faa982012-04-13 09:58:30 +0000466 intptr_t amount = amount_of_external_allocated_memory_ + change_in_bytes;
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000467 if (change_in_bytes >= 0) {
468 // Avoid overflow.
469 if (amount > amount_of_external_allocated_memory_) {
470 amount_of_external_allocated_memory_ = amount;
471 }
jkummerow@chromium.org28faa982012-04-13 09:58:30 +0000472 intptr_t amount_since_last_global_gc =
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000473 amount_of_external_allocated_memory_ -
474 amount_of_external_allocated_memory_at_last_global_gc_;
475 if (amount_since_last_global_gc > external_allocation_limit_) {
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000476 CollectAllGarbage(kNoGCFlags, "external memory allocation limit reached");
kasperl@chromium.orge959c182009-07-27 08:59:04 +0000477 }
478 } else {
479 // Avoid underflow.
480 if (amount >= 0) {
481 amount_of_external_allocated_memory_ = amount;
482 }
483 }
484 ASSERT(amount_of_external_allocated_memory_ >= 0);
485 return amount_of_external_allocated_memory_;
486}
487
488
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000489void Heap::SetLastScriptId(Object* last_script_id) {
kasperl@chromium.org68ac0092009-07-09 06:00:35 +0000490 roots_[kLastScriptIdRootIndex] = last_script_id;
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000491}
492
erik.corry@gmail.comc3b670f2011-10-05 21:44:48 +0000493
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000494Isolate* Heap::isolate() {
495 return reinterpret_cast<Isolate*>(reinterpret_cast<intptr_t>(this) -
496 reinterpret_cast<size_t>(reinterpret_cast<Isolate*>(4)->heap()) + 4);
497}
498
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000499
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000500#ifdef DEBUG
kasperl@chromium.org5a8ca6c2008-10-23 13:57:19 +0000501#define GC_GREEDY_CHECK() \
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000502 if (FLAG_gc_greedy) HEAP->GarbageCollectionGreedyCheck()
whesse@chromium.org4a5224e2010-10-20 12:37:07 +0000503#else
504#define GC_GREEDY_CHECK() { }
505#endif
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000506
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000507// Calls the FUNCTION_CALL function and retries it up to three times
508// to guarantee that any allocations performed during the call will
509// succeed if there's enough memory.
510
lrn@chromium.org303ada72010-10-27 09:33:13 +0000511// Warning: Do not use the identifiers __object__, __maybe_object__ or
512// __scope__ in a call to this macro.
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000513
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000514#define CALL_AND_RETRY(ISOLATE, FUNCTION_CALL, RETURN_VALUE, RETURN_EMPTY)\
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000515 do { \
516 GC_GREEDY_CHECK(); \
lrn@chromium.org303ada72010-10-27 09:33:13 +0000517 MaybeObject* __maybe_object__ = FUNCTION_CALL; \
518 Object* __object__ = NULL; \
519 if (__maybe_object__->ToObject(&__object__)) RETURN_VALUE; \
520 if (__maybe_object__->IsOutOfMemory()) { \
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +0000521 v8::internal::V8::FatalProcessOutOfMemory("CALL_AND_RETRY_0", true);\
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000522 } \
lrn@chromium.org303ada72010-10-27 09:33:13 +0000523 if (!__maybe_object__->IsRetryAfterGC()) RETURN_EMPTY; \
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000524 ISOLATE->heap()->CollectGarbage(Failure::cast(__maybe_object__)-> \
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000525 allocation_space(), \
526 "allocation failure"); \
lrn@chromium.org303ada72010-10-27 09:33:13 +0000527 __maybe_object__ = FUNCTION_CALL; \
528 if (__maybe_object__->ToObject(&__object__)) RETURN_VALUE; \
529 if (__maybe_object__->IsOutOfMemory()) { \
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +0000530 v8::internal::V8::FatalProcessOutOfMemory("CALL_AND_RETRY_1", true);\
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000531 } \
lrn@chromium.org303ada72010-10-27 09:33:13 +0000532 if (!__maybe_object__->IsRetryAfterGC()) RETURN_EMPTY; \
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000533 ISOLATE->counters()->gc_last_resort_from_handles()->Increment(); \
rossberg@chromium.org994edf62012-02-06 10:12:55 +0000534 ISOLATE->heap()->CollectAllAvailableGarbage("last resort gc"); \
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000535 { \
536 AlwaysAllocateScope __scope__; \
lrn@chromium.org303ada72010-10-27 09:33:13 +0000537 __maybe_object__ = FUNCTION_CALL; \
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000538 } \
lrn@chromium.org303ada72010-10-27 09:33:13 +0000539 if (__maybe_object__->ToObject(&__object__)) RETURN_VALUE; \
540 if (__maybe_object__->IsOutOfMemory() || \
541 __maybe_object__->IsRetryAfterGC()) { \
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000542 /* TODO(1181417): Fix this. */ \
lrn@chromium.orgc4e51ac2010-08-09 09:47:21 +0000543 v8::internal::V8::FatalProcessOutOfMemory("CALL_AND_RETRY_2", true);\
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000544 } \
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000545 RETURN_EMPTY; \
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000546 } while (false)
547
548
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000549#define CALL_HEAP_FUNCTION(ISOLATE, FUNCTION_CALL, TYPE) \
550 CALL_AND_RETRY(ISOLATE, \
551 FUNCTION_CALL, \
552 return Handle<TYPE>(TYPE::cast(__object__), ISOLATE), \
kasperl@chromium.org7be3c992009-03-12 07:19:55 +0000553 return Handle<TYPE>())
kasperl@chromium.org9bbf9682008-10-30 11:53:07 +0000554
555
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000556#define CALL_HEAP_FUNCTION_VOID(ISOLATE, FUNCTION_CALL) \
557 CALL_AND_RETRY(ISOLATE, FUNCTION_CALL, return, return)
kasperl@chromium.orgb9123622008-09-17 14:05:56 +0000558
559
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000560#ifdef DEBUG
561
562inline bool Heap::allow_allocation(bool new_state) {
563 bool old = allocation_allowed_;
564 allocation_allowed_ = new_state;
565 return old;
566}
567
568#endif
569
570
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000571void ExternalStringTable::AddString(String* string) {
572 ASSERT(string->IsExternalString());
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000573 if (heap_->InNewSpace(string)) {
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000574 new_space_strings_.Add(string);
575 } else {
576 old_space_strings_.Add(string);
577 }
578}
579
580
581void ExternalStringTable::Iterate(ObjectVisitor* v) {
582 if (!new_space_strings_.is_empty()) {
583 Object** start = &new_space_strings_[0];
584 v->VisitPointers(start, start + new_space_strings_.length());
585 }
586 if (!old_space_strings_.is_empty()) {
587 Object** start = &old_space_strings_[0];
588 v->VisitPointers(start, start + old_space_strings_.length());
589 }
590}
591
592
593// Verify() is inline to avoid ifdef-s around its calls in release
594// mode.
595void ExternalStringTable::Verify() {
596#ifdef DEBUG
597 for (int i = 0; i < new_space_strings_.length(); ++i) {
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +0000598 Object* obj = Object::cast(new_space_strings_[i]);
599 // TODO(yangguo): check that the object is indeed an external string.
600 ASSERT(heap_->InNewSpace(obj));
601 ASSERT(obj != HEAP->raw_unchecked_the_hole_value());
602 if (obj->IsExternalAsciiString()) {
603 ExternalAsciiString* string = ExternalAsciiString::cast(obj);
604 ASSERT(String::IsAscii(string->GetChars(), string->length()));
605 }
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000606 }
607 for (int i = 0; i < old_space_strings_.length(); ++i) {
mstarzinger@chromium.org15613d02012-05-23 12:04:37 +0000608 Object* obj = Object::cast(old_space_strings_[i]);
609 // TODO(yangguo): check that the object is indeed an external string.
610 ASSERT(!heap_->InNewSpace(obj));
611 ASSERT(obj != HEAP->raw_unchecked_the_hole_value());
612 if (obj->IsExternalAsciiString()) {
613 ExternalAsciiString* string = ExternalAsciiString::cast(obj);
614 ASSERT(String::IsAscii(string->GetChars(), string->length()));
615 }
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000616 }
617#endif
618}
619
620
621void ExternalStringTable::AddOldString(String* string) {
622 ASSERT(string->IsExternalString());
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000623 ASSERT(!heap_->InNewSpace(string));
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000624 old_space_strings_.Add(string);
625}
626
627
628void ExternalStringTable::ShrinkNewStrings(int position) {
629 new_space_strings_.Rewind(position);
erik.corry@gmail.com394dbcf2011-10-27 07:38:48 +0000630 if (FLAG_verify_heap) {
631 Verify();
632 }
kmillikin@chromium.org13bd2942009-12-16 15:36:05 +0000633}
634
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000635
636void Heap::ClearInstanceofCache() {
637 set_instanceof_cache_function(the_hole_value());
638}
639
640
641Object* Heap::ToBoolean(bool condition) {
642 return condition ? true_value() : false_value();
643}
644
645
646void Heap::CompletelyClearInstanceofCache() {
647 set_instanceof_cache_map(the_hole_value());
648 set_instanceof_cache_function(the_hole_value());
649}
650
651
652MaybeObject* TranscendentalCache::Get(Type type, double input) {
653 SubCache* cache = caches_[type];
654 if (cache == NULL) {
655 caches_[type] = cache = new SubCache(type);
656 }
657 return cache->Get(input);
658}
659
660
661Address TranscendentalCache::cache_array_address() {
662 return reinterpret_cast<Address>(caches_);
663}
664
665
666double TranscendentalCache::SubCache::Calculate(double input) {
667 switch (type_) {
668 case ACOS:
669 return acos(input);
670 case ASIN:
671 return asin(input);
672 case ATAN:
673 return atan(input);
674 case COS:
ulan@chromium.org9a21ec42012-03-06 08:42:24 +0000675 return fast_cos(input);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000676 case EXP:
677 return exp(input);
678 case LOG:
ulan@chromium.org9a21ec42012-03-06 08:42:24 +0000679 return fast_log(input);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000680 case SIN:
ulan@chromium.org9a21ec42012-03-06 08:42:24 +0000681 return fast_sin(input);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000682 case TAN:
ulan@chromium.org9a21ec42012-03-06 08:42:24 +0000683 return fast_tan(input);
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000684 default:
685 return 0.0; // Never happens.
686 }
687}
688
689
690MaybeObject* TranscendentalCache::SubCache::Get(double input) {
691 Converter c;
692 c.dbl = input;
693 int hash = Hash(c);
694 Element e = elements_[hash];
695 if (e.in[0] == c.integers[0] &&
696 e.in[1] == c.integers[1]) {
697 ASSERT(e.output != NULL);
698 isolate_->counters()->transcendental_cache_hit()->Increment();
699 return e.output;
700 }
701 double answer = Calculate(input);
702 isolate_->counters()->transcendental_cache_miss()->Increment();
703 Object* heap_number;
704 { MaybeObject* maybe_heap_number =
705 isolate_->heap()->AllocateHeapNumber(answer);
706 if (!maybe_heap_number->ToObject(&heap_number)) return maybe_heap_number;
707 }
708 elements_[hash].in[0] = c.integers[0];
709 elements_[hash].in[1] = c.integers[1];
710 elements_[hash].output = heap_number;
711 return heap_number;
712}
713
714
danno@chromium.orgfa458e42012-02-01 10:48:36 +0000715AlwaysAllocateScope::AlwaysAllocateScope() {
716 // We shouldn't hit any nested scopes, because that requires
717 // non-handle code to call handle code. The code still works but
718 // performance will degrade, so we want to catch this situation
719 // in debug mode.
720 ASSERT(HEAP->always_allocate_scope_depth_ == 0);
721 HEAP->always_allocate_scope_depth_++;
sgjesse@chromium.orgea88ce92011-03-23 11:19:56 +0000722}
723
724
danno@chromium.orgfa458e42012-02-01 10:48:36 +0000725AlwaysAllocateScope::~AlwaysAllocateScope() {
726 HEAP->always_allocate_scope_depth_--;
727 ASSERT(HEAP->always_allocate_scope_depth_ == 0);
728}
729
730
731LinearAllocationScope::LinearAllocationScope() {
732 HEAP->linear_allocation_scope_depth_++;
733}
734
735
736LinearAllocationScope::~LinearAllocationScope() {
737 HEAP->linear_allocation_scope_depth_--;
738 ASSERT(HEAP->linear_allocation_scope_depth_ >= 0);
739}
740
741
742#ifdef DEBUG
743void VerifyPointersVisitor::VisitPointers(Object** start, Object** end) {
744 for (Object** current = start; current < end; current++) {
745 if ((*current)->IsHeapObject()) {
746 HeapObject* object = HeapObject::cast(*current);
747 ASSERT(HEAP->Contains(object));
748 ASSERT(object->map()->IsMap());
749 }
750 }
751}
752#endif
753
754
755double GCTracer::SizeOfHeapObjects() {
756 return (static_cast<double>(HEAP->SizeOfObjects())) / MB;
757}
758
759
760#ifdef DEBUG
761DisallowAllocationFailure::DisallowAllocationFailure() {
762 old_state_ = HEAP->disallow_allocation_failure_;
763 HEAP->disallow_allocation_failure_ = true;
764}
765
766
767DisallowAllocationFailure::~DisallowAllocationFailure() {
768 HEAP->disallow_allocation_failure_ = old_state_;
769}
770#endif
771
772
773#ifdef DEBUG
774AssertNoAllocation::AssertNoAllocation() {
775 old_state_ = HEAP->allow_allocation(false);
776}
777
778
779AssertNoAllocation::~AssertNoAllocation() {
780 HEAP->allow_allocation(old_state_);
781}
782
783
784DisableAssertNoAllocation::DisableAssertNoAllocation() {
785 old_state_ = HEAP->allow_allocation(true);
786}
787
788
789DisableAssertNoAllocation::~DisableAssertNoAllocation() {
790 HEAP->allow_allocation(old_state_);
791}
792
793#else
794
795AssertNoAllocation::AssertNoAllocation() { }
796AssertNoAllocation::~AssertNoAllocation() { }
797DisableAssertNoAllocation::DisableAssertNoAllocation() { }
798DisableAssertNoAllocation::~DisableAssertNoAllocation() { }
799
800#endif
801
802
christian.plesner.hansen43d26ec2008-07-03 15:10:15 +0000803} } // namespace v8::internal
804
805#endif // V8_HEAP_INL_H_