OLD | NEW |
1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file | 1 // Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file |
2 // for details. All rights reserved. Use of this source code is governed by a | 2 // for details. All rights reserved. Use of this source code is governed by a |
3 // BSD-style license that can be found in the LICENSE file. | 3 // BSD-style license that can be found in the LICENSE file. |
4 | 4 |
5 #include "vm/raw_object.h" | 5 #include "vm/raw_object.h" |
6 | 6 |
7 #include "vm/become.h" | 7 #include "vm/become.h" |
8 #include "vm/class_table.h" | 8 #include "vm/class_table.h" |
9 #include "vm/dart.h" | 9 #include "vm/dart.h" |
10 #include "vm/freelist.h" | 10 #include "vm/freelist.h" |
11 #include "vm/isolate.h" | 11 #include "vm/isolate.h" |
12 #include "vm/object.h" | 12 #include "vm/object.h" |
13 #include "vm/visitor.h" | 13 #include "vm/visitor.h" |
14 | 14 |
15 | |
16 namespace dart { | 15 namespace dart { |
17 | 16 |
18 void RawObject::Validate(Isolate* isolate) const { | 17 void RawObject::Validate(Isolate* isolate) const { |
19 if (Object::void_class_ == reinterpret_cast<RawClass*>(kHeapObjectTag)) { | 18 if (Object::void_class_ == reinterpret_cast<RawClass*>(kHeapObjectTag)) { |
20 // Validation relies on properly initialized class classes. Skip if the | 19 // Validation relies on properly initialized class classes. Skip if the |
21 // VM is still being initialized. | 20 // VM is still being initialized. |
22 return; | 21 return; |
23 } | 22 } |
24 // All Smi values are valid. | 23 // All Smi values are valid. |
25 if (!IsHeapObject()) { | 24 if (!IsHeapObject()) { |
(...skipping 17 matching lines...) Expand all Loading... |
43 (isolate->class_table()->At(class_id) == NULL)) { | 42 (isolate->class_table()->At(class_id) == NULL)) { |
44 // Null class not yet initialized; skip. | 43 // Null class not yet initialized; skip. |
45 return; | 44 return; |
46 } | 45 } |
47 intptr_t size = SizeTag::decode(tags); | 46 intptr_t size = SizeTag::decode(tags); |
48 if (size != 0 && size != SizeFromClass()) { | 47 if (size != 0 && size != SizeFromClass()) { |
49 FATAL1("Inconsistent class size encountered %" Pd "\n", size); | 48 FATAL1("Inconsistent class size encountered %" Pd "\n", size); |
50 } | 49 } |
51 } | 50 } |
52 | 51 |
53 | |
54 intptr_t RawObject::SizeFromClass() const { | 52 intptr_t RawObject::SizeFromClass() const { |
55 // Only reasonable to be called on heap objects. | 53 // Only reasonable to be called on heap objects. |
56 ASSERT(IsHeapObject()); | 54 ASSERT(IsHeapObject()); |
57 | 55 |
58 intptr_t class_id = GetClassId(); | 56 intptr_t class_id = GetClassId(); |
59 intptr_t instance_size = 0; | 57 intptr_t instance_size = 0; |
60 switch (class_id) { | 58 switch (class_id) { |
61 case kCodeCid: { | 59 case kCodeCid: { |
62 const RawCode* raw_code = reinterpret_cast<const RawCode*>(this); | 60 const RawCode* raw_code = reinterpret_cast<const RawCode*>(this); |
63 intptr_t pointer_offsets_length = | 61 intptr_t pointer_offsets_length = |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
211 } while ((instance_size > tags_size) && (--retries_remaining > 0)); | 209 } while ((instance_size > tags_size) && (--retries_remaining > 0)); |
212 } | 210 } |
213 if ((instance_size != tags_size) && (tags_size != 0)) { | 211 if ((instance_size != tags_size) && (tags_size != 0)) { |
214 FATAL3("Size mismatch: %" Pd " from class vs %" Pd " from tags %x\n", | 212 FATAL3("Size mismatch: %" Pd " from class vs %" Pd " from tags %x\n", |
215 instance_size, tags_size, tags); | 213 instance_size, tags_size, tags); |
216 } | 214 } |
217 #endif // DEBUG | 215 #endif // DEBUG |
218 return instance_size; | 216 return instance_size; |
219 } | 217 } |
220 | 218 |
221 | |
222 intptr_t RawObject::VisitPointersPredefined(ObjectPointerVisitor* visitor, | 219 intptr_t RawObject::VisitPointersPredefined(ObjectPointerVisitor* visitor, |
223 intptr_t class_id) { | 220 intptr_t class_id) { |
224 ASSERT(class_id < kNumPredefinedCids); | 221 ASSERT(class_id < kNumPredefinedCids); |
225 | 222 |
226 intptr_t size = 0; | 223 intptr_t size = 0; |
227 | 224 |
228 // Only reasonable to be called on heap objects. | 225 // Only reasonable to be called on heap objects. |
229 ASSERT(IsHeapObject()); | 226 ASSERT(IsHeapObject()); |
230 | 227 |
231 switch (class_id) { | 228 switch (class_id) { |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
281 OS::Print("Class Id: %" Pd "\n", class_id); | 278 OS::Print("Class Id: %" Pd "\n", class_id); |
282 UNREACHABLE(); | 279 UNREACHABLE(); |
283 break; | 280 break; |
284 } | 281 } |
285 | 282 |
286 ASSERT(size != 0); | 283 ASSERT(size != 0); |
287 ASSERT(size == Size()); | 284 ASSERT(size == Size()); |
288 return size; | 285 return size; |
289 } | 286 } |
290 | 287 |
291 | |
292 bool RawObject::FindObject(FindObjectVisitor* visitor) { | 288 bool RawObject::FindObject(FindObjectVisitor* visitor) { |
293 ASSERT(visitor != NULL); | 289 ASSERT(visitor != NULL); |
294 return visitor->FindObject(this); | 290 return visitor->FindObject(this); |
295 } | 291 } |
296 | 292 |
297 | |
298 intptr_t RawClass::VisitClassPointers(RawClass* raw_obj, | 293 intptr_t RawClass::VisitClassPointers(RawClass* raw_obj, |
299 ObjectPointerVisitor* visitor) { | 294 ObjectPointerVisitor* visitor) { |
300 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 295 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
301 return Class::InstanceSize(); | 296 return Class::InstanceSize(); |
302 } | 297 } |
303 | 298 |
304 | |
305 intptr_t RawUnresolvedClass::VisitUnresolvedClassPointers( | 299 intptr_t RawUnresolvedClass::VisitUnresolvedClassPointers( |
306 RawUnresolvedClass* raw_obj, | 300 RawUnresolvedClass* raw_obj, |
307 ObjectPointerVisitor* visitor) { | 301 ObjectPointerVisitor* visitor) { |
308 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 302 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
309 return UnresolvedClass::InstanceSize(); | 303 return UnresolvedClass::InstanceSize(); |
310 } | 304 } |
311 | 305 |
312 | |
313 intptr_t RawAbstractType::VisitAbstractTypePointers( | 306 intptr_t RawAbstractType::VisitAbstractTypePointers( |
314 RawAbstractType* raw_obj, | 307 RawAbstractType* raw_obj, |
315 ObjectPointerVisitor* visitor) { | 308 ObjectPointerVisitor* visitor) { |
316 // RawAbstractType is an abstract class. | 309 // RawAbstractType is an abstract class. |
317 UNREACHABLE(); | 310 UNREACHABLE(); |
318 return 0; | 311 return 0; |
319 } | 312 } |
320 | 313 |
321 | |
322 intptr_t RawType::VisitTypePointers(RawType* raw_obj, | 314 intptr_t RawType::VisitTypePointers(RawType* raw_obj, |
323 ObjectPointerVisitor* visitor) { | 315 ObjectPointerVisitor* visitor) { |
324 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 316 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
325 return Type::InstanceSize(); | 317 return Type::InstanceSize(); |
326 } | 318 } |
327 | 319 |
328 | |
329 intptr_t RawTypeRef::VisitTypeRefPointers(RawTypeRef* raw_obj, | 320 intptr_t RawTypeRef::VisitTypeRefPointers(RawTypeRef* raw_obj, |
330 ObjectPointerVisitor* visitor) { | 321 ObjectPointerVisitor* visitor) { |
331 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 322 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
332 return TypeRef::InstanceSize(); | 323 return TypeRef::InstanceSize(); |
333 } | 324 } |
334 | 325 |
335 | |
336 intptr_t RawTypeParameter::VisitTypeParameterPointers( | 326 intptr_t RawTypeParameter::VisitTypeParameterPointers( |
337 RawTypeParameter* raw_obj, | 327 RawTypeParameter* raw_obj, |
338 ObjectPointerVisitor* visitor) { | 328 ObjectPointerVisitor* visitor) { |
339 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 329 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
340 return TypeParameter::InstanceSize(); | 330 return TypeParameter::InstanceSize(); |
341 } | 331 } |
342 | 332 |
343 | |
344 intptr_t RawBoundedType::VisitBoundedTypePointers( | 333 intptr_t RawBoundedType::VisitBoundedTypePointers( |
345 RawBoundedType* raw_obj, | 334 RawBoundedType* raw_obj, |
346 ObjectPointerVisitor* visitor) { | 335 ObjectPointerVisitor* visitor) { |
347 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 336 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
348 return BoundedType::InstanceSize(); | 337 return BoundedType::InstanceSize(); |
349 } | 338 } |
350 | 339 |
351 | |
352 intptr_t RawMixinAppType::VisitMixinAppTypePointers( | 340 intptr_t RawMixinAppType::VisitMixinAppTypePointers( |
353 RawMixinAppType* raw_obj, | 341 RawMixinAppType* raw_obj, |
354 ObjectPointerVisitor* visitor) { | 342 ObjectPointerVisitor* visitor) { |
355 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 343 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
356 return MixinAppType::InstanceSize(); | 344 return MixinAppType::InstanceSize(); |
357 } | 345 } |
358 | 346 |
359 | |
360 intptr_t RawTypeArguments::VisitTypeArgumentsPointers( | 347 intptr_t RawTypeArguments::VisitTypeArgumentsPointers( |
361 RawTypeArguments* raw_obj, | 348 RawTypeArguments* raw_obj, |
362 ObjectPointerVisitor* visitor) { | 349 ObjectPointerVisitor* visitor) { |
363 intptr_t length = Smi::Value(raw_obj->ptr()->length_); | 350 intptr_t length = Smi::Value(raw_obj->ptr()->length_); |
364 visitor->VisitPointers(raw_obj->from(), raw_obj->to(length)); | 351 visitor->VisitPointers(raw_obj->from(), raw_obj->to(length)); |
365 return TypeArguments::InstanceSize(length); | 352 return TypeArguments::InstanceSize(length); |
366 } | 353 } |
367 | 354 |
368 | |
369 intptr_t RawPatchClass::VisitPatchClassPointers(RawPatchClass* raw_obj, | 355 intptr_t RawPatchClass::VisitPatchClassPointers(RawPatchClass* raw_obj, |
370 ObjectPointerVisitor* visitor) { | 356 ObjectPointerVisitor* visitor) { |
371 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 357 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
372 return PatchClass::InstanceSize(); | 358 return PatchClass::InstanceSize(); |
373 } | 359 } |
374 | 360 |
375 | |
376 intptr_t RawClosure::VisitClosurePointers(RawClosure* raw_obj, | 361 intptr_t RawClosure::VisitClosurePointers(RawClosure* raw_obj, |
377 ObjectPointerVisitor* visitor) { | 362 ObjectPointerVisitor* visitor) { |
378 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 363 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
379 return Closure::InstanceSize(); | 364 return Closure::InstanceSize(); |
380 } | 365 } |
381 | 366 |
382 | |
383 intptr_t RawClosureData::VisitClosureDataPointers( | 367 intptr_t RawClosureData::VisitClosureDataPointers( |
384 RawClosureData* raw_obj, | 368 RawClosureData* raw_obj, |
385 ObjectPointerVisitor* visitor) { | 369 ObjectPointerVisitor* visitor) { |
386 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 370 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
387 return ClosureData::InstanceSize(); | 371 return ClosureData::InstanceSize(); |
388 } | 372 } |
389 | 373 |
390 | |
391 intptr_t RawSignatureData::VisitSignatureDataPointers( | 374 intptr_t RawSignatureData::VisitSignatureDataPointers( |
392 RawSignatureData* raw_obj, | 375 RawSignatureData* raw_obj, |
393 ObjectPointerVisitor* visitor) { | 376 ObjectPointerVisitor* visitor) { |
394 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 377 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
395 return SignatureData::InstanceSize(); | 378 return SignatureData::InstanceSize(); |
396 } | 379 } |
397 | 380 |
398 | |
399 intptr_t RawRedirectionData::VisitRedirectionDataPointers( | 381 intptr_t RawRedirectionData::VisitRedirectionDataPointers( |
400 RawRedirectionData* raw_obj, | 382 RawRedirectionData* raw_obj, |
401 ObjectPointerVisitor* visitor) { | 383 ObjectPointerVisitor* visitor) { |
402 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 384 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
403 return RedirectionData::InstanceSize(); | 385 return RedirectionData::InstanceSize(); |
404 } | 386 } |
405 | 387 |
406 | |
407 bool RawFunction::CheckUsageCounter(RawFunction* raw_fun) { | 388 bool RawFunction::CheckUsageCounter(RawFunction* raw_fun) { |
408 // NOTE: This code runs while GC is in progress and runs within | 389 // NOTE: This code runs while GC is in progress and runs within |
409 // a NoHandleScope block. Hence it is not okay to use regular Zone or | 390 // a NoHandleScope block. Hence it is not okay to use regular Zone or |
410 // Scope handles. We use direct stack handles, and so the raw pointers in | 391 // Scope handles. We use direct stack handles, and so the raw pointers in |
411 // these handles are not traversed. The use of handles is mainly to | 392 // these handles are not traversed. The use of handles is mainly to |
412 // be able to reuse the handle based code and avoid having to add | 393 // be able to reuse the handle based code and avoid having to add |
413 // helper functions to the raw object interface. | 394 // helper functions to the raw object interface. |
414 Function fn; | 395 Function fn; |
415 fn = raw_fun; | 396 fn = raw_fun; |
416 | 397 |
417 // The function may not have code. | 398 // The function may not have code. |
418 if (!fn.HasCode()) return false; | 399 if (!fn.HasCode()) return false; |
419 // These may not increment the usage counter. | 400 // These may not increment the usage counter. |
420 if (fn.is_intrinsic()) return false; | 401 if (fn.is_intrinsic()) return false; |
421 | 402 |
422 if (fn.usage_counter() >= 0) { | 403 if (fn.usage_counter() >= 0) { |
423 fn.set_usage_counter(fn.usage_counter() / 2); | 404 fn.set_usage_counter(fn.usage_counter() / 2); |
424 } | 405 } |
425 return FLAG_always_drop_code || (fn.usage_counter() == 0); | 406 return FLAG_always_drop_code || (fn.usage_counter() == 0); |
426 } | 407 } |
427 | 408 |
428 | |
429 bool RawFunction::ShouldVisitCode(RawCode* raw_code) { | 409 bool RawFunction::ShouldVisitCode(RawCode* raw_code) { |
430 // NOTE: This code runs while GC is in progress and runs within | 410 // NOTE: This code runs while GC is in progress and runs within |
431 // a NoHandleScope block. Hence it is not okay to use regular Zone or | 411 // a NoHandleScope block. Hence it is not okay to use regular Zone or |
432 // Scope handles. We use direct stack handles, and so the raw pointers in | 412 // Scope handles. We use direct stack handles, and so the raw pointers in |
433 // these handles are not traversed. The use of handles is mainly to | 413 // these handles are not traversed. The use of handles is mainly to |
434 // be able to reuse the handle based code and avoid having to add | 414 // be able to reuse the handle based code and avoid having to add |
435 // helper functions to the raw object interface. | 415 // helper functions to the raw object interface. |
436 Code code; | 416 Code code; |
437 code = raw_code; | 417 code = raw_code; |
438 if (code.IsNull()) return true; | 418 if (code.IsNull()) return true; |
439 if (code.is_optimized()) return true; | 419 if (code.is_optimized()) return true; |
440 if (code.HasBreakpoint()) return true; | 420 if (code.HasBreakpoint()) return true; |
441 return false; | 421 return false; |
442 } | 422 } |
443 | 423 |
444 | |
445 intptr_t RawFunction::VisitFunctionPointers(RawFunction* raw_obj, | 424 intptr_t RawFunction::VisitFunctionPointers(RawFunction* raw_obj, |
446 ObjectPointerVisitor* visitor) { | 425 ObjectPointerVisitor* visitor) { |
447 if (visitor->visit_function_code() || !CheckUsageCounter(raw_obj)) { | 426 if (visitor->visit_function_code() || !CheckUsageCounter(raw_obj)) { |
448 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 427 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
449 return Function::InstanceSize(); | 428 return Function::InstanceSize(); |
450 } | 429 } |
451 #if defined(DART_PRECOMPILED_RUNTIME) | 430 #if defined(DART_PRECOMPILED_RUNTIME) |
452 UNREACHABLE(); | 431 UNREACHABLE(); |
453 #else | 432 #else |
454 visitor->VisitPointers(raw_obj->from(), raw_obj->to_no_code()); | 433 visitor->VisitPointers(raw_obj->from(), raw_obj->to_no_code()); |
455 | 434 |
456 if (ShouldVisitCode(raw_obj->ptr()->code_)) { | 435 if (ShouldVisitCode(raw_obj->ptr()->code_)) { |
457 visitor->VisitPointer( | 436 visitor->VisitPointer( |
458 reinterpret_cast<RawObject**>(&raw_obj->ptr()->code_)); | 437 reinterpret_cast<RawObject**>(&raw_obj->ptr()->code_)); |
459 } else { | 438 } else { |
460 visitor->add_skipped_code_function(raw_obj); | 439 visitor->add_skipped_code_function(raw_obj); |
461 } | 440 } |
462 | 441 |
463 if (ShouldVisitCode(raw_obj->ptr()->unoptimized_code_)) { | 442 if (ShouldVisitCode(raw_obj->ptr()->unoptimized_code_)) { |
464 visitor->VisitPointer( | 443 visitor->VisitPointer( |
465 reinterpret_cast<RawObject**>(&raw_obj->ptr()->unoptimized_code_)); | 444 reinterpret_cast<RawObject**>(&raw_obj->ptr()->unoptimized_code_)); |
466 } else { | 445 } else { |
467 visitor->add_skipped_code_function(raw_obj); | 446 visitor->add_skipped_code_function(raw_obj); |
468 } | 447 } |
469 #endif | 448 #endif |
470 return Function::InstanceSize(); | 449 return Function::InstanceSize(); |
471 } | 450 } |
472 | 451 |
473 | |
474 intptr_t RawField::VisitFieldPointers(RawField* raw_obj, | 452 intptr_t RawField::VisitFieldPointers(RawField* raw_obj, |
475 ObjectPointerVisitor* visitor) { | 453 ObjectPointerVisitor* visitor) { |
476 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 454 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
477 return Field::InstanceSize(); | 455 return Field::InstanceSize(); |
478 } | 456 } |
479 | 457 |
480 | |
481 intptr_t RawLiteralToken::VisitLiteralTokenPointers( | 458 intptr_t RawLiteralToken::VisitLiteralTokenPointers( |
482 RawLiteralToken* raw_obj, | 459 RawLiteralToken* raw_obj, |
483 ObjectPointerVisitor* visitor) { | 460 ObjectPointerVisitor* visitor) { |
484 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 461 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
485 return LiteralToken::InstanceSize(); | 462 return LiteralToken::InstanceSize(); |
486 } | 463 } |
487 | 464 |
488 | |
489 intptr_t RawTokenStream::VisitTokenStreamPointers( | 465 intptr_t RawTokenStream::VisitTokenStreamPointers( |
490 RawTokenStream* raw_obj, | 466 RawTokenStream* raw_obj, |
491 ObjectPointerVisitor* visitor) { | 467 ObjectPointerVisitor* visitor) { |
492 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 468 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
493 return TokenStream::InstanceSize(); | 469 return TokenStream::InstanceSize(); |
494 } | 470 } |
495 | 471 |
496 | |
497 intptr_t RawScript::VisitScriptPointers(RawScript* raw_obj, | 472 intptr_t RawScript::VisitScriptPointers(RawScript* raw_obj, |
498 ObjectPointerVisitor* visitor) { | 473 ObjectPointerVisitor* visitor) { |
499 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 474 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
500 return Script::InstanceSize(); | 475 return Script::InstanceSize(); |
501 } | 476 } |
502 | 477 |
503 | |
504 intptr_t RawLibrary::VisitLibraryPointers(RawLibrary* raw_obj, | 478 intptr_t RawLibrary::VisitLibraryPointers(RawLibrary* raw_obj, |
505 ObjectPointerVisitor* visitor) { | 479 ObjectPointerVisitor* visitor) { |
506 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 480 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
507 return Library::InstanceSize(); | 481 return Library::InstanceSize(); |
508 } | 482 } |
509 | 483 |
510 | |
511 intptr_t RawLibraryPrefix::VisitLibraryPrefixPointers( | 484 intptr_t RawLibraryPrefix::VisitLibraryPrefixPointers( |
512 RawLibraryPrefix* raw_obj, | 485 RawLibraryPrefix* raw_obj, |
513 ObjectPointerVisitor* visitor) { | 486 ObjectPointerVisitor* visitor) { |
514 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 487 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
515 return LibraryPrefix::InstanceSize(); | 488 return LibraryPrefix::InstanceSize(); |
516 } | 489 } |
517 | 490 |
518 | |
519 intptr_t RawNamespace::VisitNamespacePointers(RawNamespace* raw_obj, | 491 intptr_t RawNamespace::VisitNamespacePointers(RawNamespace* raw_obj, |
520 ObjectPointerVisitor* visitor) { | 492 ObjectPointerVisitor* visitor) { |
521 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 493 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
522 return Namespace::InstanceSize(); | 494 return Namespace::InstanceSize(); |
523 } | 495 } |
524 | 496 |
525 | |
526 bool RawCode::ContainsPC(RawObject* raw_obj, uword pc) { | 497 bool RawCode::ContainsPC(RawObject* raw_obj, uword pc) { |
527 uint32_t tags = raw_obj->ptr()->tags_; | 498 uint32_t tags = raw_obj->ptr()->tags_; |
528 if (RawObject::ClassIdTag::decode(tags) == kCodeCid) { | 499 if (RawObject::ClassIdTag::decode(tags) == kCodeCid) { |
529 RawCode* raw_code = reinterpret_cast<RawCode*>(raw_obj); | 500 RawCode* raw_code = reinterpret_cast<RawCode*>(raw_obj); |
530 return RawInstructions::ContainsPC(raw_code->ptr()->instructions_, pc); | 501 return RawInstructions::ContainsPC(raw_code->ptr()->instructions_, pc); |
531 } | 502 } |
532 return false; | 503 return false; |
533 } | 504 } |
534 | 505 |
535 | |
536 intptr_t RawCode::VisitCodePointers(RawCode* raw_obj, | 506 intptr_t RawCode::VisitCodePointers(RawCode* raw_obj, |
537 ObjectPointerVisitor* visitor) { | 507 ObjectPointerVisitor* visitor) { |
538 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 508 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
539 | 509 |
540 RawCode* obj = raw_obj->ptr(); | 510 RawCode* obj = raw_obj->ptr(); |
541 intptr_t length = Code::PtrOffBits::decode(obj->state_bits_); | 511 intptr_t length = Code::PtrOffBits::decode(obj->state_bits_); |
542 #if defined(TARGET_ARCH_IA32) | 512 #if defined(TARGET_ARCH_IA32) |
543 // On IA32 only we embed pointers to objects directly in the generated | 513 // On IA32 only we embed pointers to objects directly in the generated |
544 // instructions. The variable portion of a Code object describes where to | 514 // instructions. The variable portion of a Code object describes where to |
545 // find those pointers for tracing. | 515 // find those pointers for tracing. |
546 if (Code::AliveBit::decode(obj->state_bits_)) { | 516 if (Code::AliveBit::decode(obj->state_bits_)) { |
547 uword entry_point = reinterpret_cast<uword>(obj->instructions_->ptr()) + | 517 uword entry_point = reinterpret_cast<uword>(obj->instructions_->ptr()) + |
548 Instructions::HeaderSize(); | 518 Instructions::HeaderSize(); |
549 for (intptr_t i = 0; i < length; i++) { | 519 for (intptr_t i = 0; i < length; i++) { |
550 int32_t offset = obj->data()[i]; | 520 int32_t offset = obj->data()[i]; |
551 visitor->VisitPointer( | 521 visitor->VisitPointer( |
552 reinterpret_cast<RawObject**>(entry_point + offset)); | 522 reinterpret_cast<RawObject**>(entry_point + offset)); |
553 } | 523 } |
554 } | 524 } |
555 return Code::InstanceSize(length); | 525 return Code::InstanceSize(length); |
556 #else | 526 #else |
557 // On all other architectures, objects are referenced indirectly through | 527 // On all other architectures, objects are referenced indirectly through |
558 // either an ObjectPool or Thread. | 528 // either an ObjectPool or Thread. |
559 ASSERT(length == 0); | 529 ASSERT(length == 0); |
560 return Code::InstanceSize(0); | 530 return Code::InstanceSize(0); |
561 #endif | 531 #endif |
562 } | 532 } |
563 | 533 |
564 | |
565 intptr_t RawObjectPool::VisitObjectPoolPointers(RawObjectPool* raw_obj, | 534 intptr_t RawObjectPool::VisitObjectPoolPointers(RawObjectPool* raw_obj, |
566 ObjectPointerVisitor* visitor) { | 535 ObjectPointerVisitor* visitor) { |
567 visitor->VisitPointer( | 536 visitor->VisitPointer( |
568 reinterpret_cast<RawObject**>(&raw_obj->ptr()->info_array_)); | 537 reinterpret_cast<RawObject**>(&raw_obj->ptr()->info_array_)); |
569 const intptr_t len = raw_obj->ptr()->length_; | 538 const intptr_t len = raw_obj->ptr()->length_; |
570 RawTypedData* info_array = raw_obj->ptr()->info_array_->ptr(); | 539 RawTypedData* info_array = raw_obj->ptr()->info_array_->ptr(); |
571 Entry* first = raw_obj->first_entry(); | 540 Entry* first = raw_obj->first_entry(); |
572 for (intptr_t i = 0; i < len; ++i) { | 541 for (intptr_t i = 0; i < len; ++i) { |
573 ObjectPool::EntryType entry_type = | 542 ObjectPool::EntryType entry_type = |
574 static_cast<ObjectPool::EntryType>(info_array->data()[i]); | 543 static_cast<ObjectPool::EntryType>(info_array->data()[i]); |
575 if (entry_type == ObjectPool::kTaggedObject) { | 544 if (entry_type == ObjectPool::kTaggedObject) { |
576 visitor->VisitPointer(&(first + i)->raw_obj_); | 545 visitor->VisitPointer(&(first + i)->raw_obj_); |
577 } | 546 } |
578 } | 547 } |
579 return ObjectPool::InstanceSize(raw_obj->ptr()->length_); | 548 return ObjectPool::InstanceSize(raw_obj->ptr()->length_); |
580 } | 549 } |
581 | 550 |
582 | |
583 intptr_t RawInstructions::VisitInstructionsPointers( | 551 intptr_t RawInstructions::VisitInstructionsPointers( |
584 RawInstructions* raw_obj, | 552 RawInstructions* raw_obj, |
585 ObjectPointerVisitor* visitor) { | 553 ObjectPointerVisitor* visitor) { |
586 return Instructions::InstanceSize(Instructions::Size(raw_obj)); | 554 return Instructions::InstanceSize(Instructions::Size(raw_obj)); |
587 } | 555 } |
588 | 556 |
589 | |
590 bool RawInstructions::ContainsPC(RawInstructions* raw_instr, uword pc) { | 557 bool RawInstructions::ContainsPC(RawInstructions* raw_instr, uword pc) { |
591 uword start_pc = | 558 uword start_pc = |
592 reinterpret_cast<uword>(raw_instr->ptr()) + Instructions::HeaderSize(); | 559 reinterpret_cast<uword>(raw_instr->ptr()) + Instructions::HeaderSize(); |
593 uword end_pc = start_pc + Instructions::Size(raw_instr); | 560 uword end_pc = start_pc + Instructions::Size(raw_instr); |
594 ASSERT(end_pc > start_pc); | 561 ASSERT(end_pc > start_pc); |
595 return (pc >= start_pc) && (pc < end_pc); | 562 return (pc >= start_pc) && (pc < end_pc); |
596 } | 563 } |
597 | 564 |
598 | |
599 intptr_t RawPcDescriptors::VisitPcDescriptorsPointers( | 565 intptr_t RawPcDescriptors::VisitPcDescriptorsPointers( |
600 RawPcDescriptors* raw_obj, | 566 RawPcDescriptors* raw_obj, |
601 ObjectPointerVisitor* visitor) { | 567 ObjectPointerVisitor* visitor) { |
602 return PcDescriptors::InstanceSize(raw_obj->ptr()->length_); | 568 return PcDescriptors::InstanceSize(raw_obj->ptr()->length_); |
603 } | 569 } |
604 | 570 |
605 | |
606 intptr_t RawCodeSourceMap::VisitCodeSourceMapPointers( | 571 intptr_t RawCodeSourceMap::VisitCodeSourceMapPointers( |
607 RawCodeSourceMap* raw_obj, | 572 RawCodeSourceMap* raw_obj, |
608 ObjectPointerVisitor* visitor) { | 573 ObjectPointerVisitor* visitor) { |
609 return CodeSourceMap::InstanceSize(raw_obj->ptr()->length_); | 574 return CodeSourceMap::InstanceSize(raw_obj->ptr()->length_); |
610 } | 575 } |
611 | 576 |
612 | |
613 intptr_t RawStackMap::VisitStackMapPointers(RawStackMap* raw_obj, | 577 intptr_t RawStackMap::VisitStackMapPointers(RawStackMap* raw_obj, |
614 ObjectPointerVisitor* visitor) { | 578 ObjectPointerVisitor* visitor) { |
615 return StackMap::InstanceSize(raw_obj->ptr()->length_); | 579 return StackMap::InstanceSize(raw_obj->ptr()->length_); |
616 } | 580 } |
617 | 581 |
618 | |
619 intptr_t RawLocalVarDescriptors::VisitLocalVarDescriptorsPointers( | 582 intptr_t RawLocalVarDescriptors::VisitLocalVarDescriptorsPointers( |
620 RawLocalVarDescriptors* raw_obj, | 583 RawLocalVarDescriptors* raw_obj, |
621 ObjectPointerVisitor* visitor) { | 584 ObjectPointerVisitor* visitor) { |
622 intptr_t num_entries = raw_obj->ptr()->num_entries_; | 585 intptr_t num_entries = raw_obj->ptr()->num_entries_; |
623 visitor->VisitPointers(raw_obj->from(), raw_obj->to(num_entries)); | 586 visitor->VisitPointers(raw_obj->from(), raw_obj->to(num_entries)); |
624 return LocalVarDescriptors::InstanceSize(num_entries); | 587 return LocalVarDescriptors::InstanceSize(num_entries); |
625 } | 588 } |
626 | 589 |
627 | |
628 intptr_t RawExceptionHandlers::VisitExceptionHandlersPointers( | 590 intptr_t RawExceptionHandlers::VisitExceptionHandlersPointers( |
629 RawExceptionHandlers* raw_obj, | 591 RawExceptionHandlers* raw_obj, |
630 ObjectPointerVisitor* visitor) { | 592 ObjectPointerVisitor* visitor) { |
631 RawExceptionHandlers* obj = raw_obj->ptr(); | 593 RawExceptionHandlers* obj = raw_obj->ptr(); |
632 intptr_t len = obj->num_entries_; | 594 intptr_t len = obj->num_entries_; |
633 visitor->VisitPointer( | 595 visitor->VisitPointer( |
634 reinterpret_cast<RawObject**>(&obj->handled_types_data_)); | 596 reinterpret_cast<RawObject**>(&obj->handled_types_data_)); |
635 return ExceptionHandlers::InstanceSize(len); | 597 return ExceptionHandlers::InstanceSize(len); |
636 } | 598 } |
637 | 599 |
638 | |
639 intptr_t RawContext::VisitContextPointers(RawContext* raw_obj, | 600 intptr_t RawContext::VisitContextPointers(RawContext* raw_obj, |
640 ObjectPointerVisitor* visitor) { | 601 ObjectPointerVisitor* visitor) { |
641 intptr_t num_variables = raw_obj->ptr()->num_variables_; | 602 intptr_t num_variables = raw_obj->ptr()->num_variables_; |
642 visitor->VisitPointers(raw_obj->from(), raw_obj->to(num_variables)); | 603 visitor->VisitPointers(raw_obj->from(), raw_obj->to(num_variables)); |
643 return Context::InstanceSize(num_variables); | 604 return Context::InstanceSize(num_variables); |
644 } | 605 } |
645 | 606 |
646 | |
647 intptr_t RawContextScope::VisitContextScopePointers( | 607 intptr_t RawContextScope::VisitContextScopePointers( |
648 RawContextScope* raw_obj, | 608 RawContextScope* raw_obj, |
649 ObjectPointerVisitor* visitor) { | 609 ObjectPointerVisitor* visitor) { |
650 intptr_t num_variables = raw_obj->ptr()->num_variables_; | 610 intptr_t num_variables = raw_obj->ptr()->num_variables_; |
651 visitor->VisitPointers(raw_obj->from(), raw_obj->to(num_variables)); | 611 visitor->VisitPointers(raw_obj->from(), raw_obj->to(num_variables)); |
652 return ContextScope::InstanceSize(num_variables); | 612 return ContextScope::InstanceSize(num_variables); |
653 } | 613 } |
654 | 614 |
655 | |
656 intptr_t RawSingleTargetCache::VisitSingleTargetCachePointers( | 615 intptr_t RawSingleTargetCache::VisitSingleTargetCachePointers( |
657 RawSingleTargetCache* raw_obj, | 616 RawSingleTargetCache* raw_obj, |
658 ObjectPointerVisitor* visitor) { | 617 ObjectPointerVisitor* visitor) { |
659 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 618 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
660 return SingleTargetCache::InstanceSize(); | 619 return SingleTargetCache::InstanceSize(); |
661 } | 620 } |
662 | 621 |
663 | |
664 intptr_t RawUnlinkedCall::VisitUnlinkedCallPointers( | 622 intptr_t RawUnlinkedCall::VisitUnlinkedCallPointers( |
665 RawUnlinkedCall* raw_obj, | 623 RawUnlinkedCall* raw_obj, |
666 ObjectPointerVisitor* visitor) { | 624 ObjectPointerVisitor* visitor) { |
667 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 625 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
668 return UnlinkedCall::InstanceSize(); | 626 return UnlinkedCall::InstanceSize(); |
669 } | 627 } |
670 | 628 |
671 | |
672 intptr_t RawICData::VisitICDataPointers(RawICData* raw_obj, | 629 intptr_t RawICData::VisitICDataPointers(RawICData* raw_obj, |
673 ObjectPointerVisitor* visitor) { | 630 ObjectPointerVisitor* visitor) { |
674 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 631 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
675 return ICData::InstanceSize(); | 632 return ICData::InstanceSize(); |
676 } | 633 } |
677 | 634 |
678 | |
679 intptr_t RawMegamorphicCache::VisitMegamorphicCachePointers( | 635 intptr_t RawMegamorphicCache::VisitMegamorphicCachePointers( |
680 RawMegamorphicCache* raw_obj, | 636 RawMegamorphicCache* raw_obj, |
681 ObjectPointerVisitor* visitor) { | 637 ObjectPointerVisitor* visitor) { |
682 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 638 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
683 return MegamorphicCache::InstanceSize(); | 639 return MegamorphicCache::InstanceSize(); |
684 } | 640 } |
685 | 641 |
686 | |
687 intptr_t RawSubtypeTestCache::VisitSubtypeTestCachePointers( | 642 intptr_t RawSubtypeTestCache::VisitSubtypeTestCachePointers( |
688 RawSubtypeTestCache* raw_obj, | 643 RawSubtypeTestCache* raw_obj, |
689 ObjectPointerVisitor* visitor) { | 644 ObjectPointerVisitor* visitor) { |
690 // Make sure that we got here with the tagged pointer as this. | 645 // Make sure that we got here with the tagged pointer as this. |
691 RawSubtypeTestCache* obj = raw_obj->ptr(); | 646 RawSubtypeTestCache* obj = raw_obj->ptr(); |
692 visitor->VisitPointer(reinterpret_cast<RawObject**>(&obj->cache_)); | 647 visitor->VisitPointer(reinterpret_cast<RawObject**>(&obj->cache_)); |
693 return SubtypeTestCache::InstanceSize(); | 648 return SubtypeTestCache::InstanceSize(); |
694 } | 649 } |
695 | 650 |
696 | |
697 intptr_t RawError::VisitErrorPointers(RawError* raw_obj, | 651 intptr_t RawError::VisitErrorPointers(RawError* raw_obj, |
698 ObjectPointerVisitor* visitor) { | 652 ObjectPointerVisitor* visitor) { |
699 // Error is an abstract class. | 653 // Error is an abstract class. |
700 UNREACHABLE(); | 654 UNREACHABLE(); |
701 return 0; | 655 return 0; |
702 } | 656 } |
703 | 657 |
704 | |
705 intptr_t RawApiError::VisitApiErrorPointers(RawApiError* raw_obj, | 658 intptr_t RawApiError::VisitApiErrorPointers(RawApiError* raw_obj, |
706 ObjectPointerVisitor* visitor) { | 659 ObjectPointerVisitor* visitor) { |
707 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 660 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
708 return ApiError::InstanceSize(); | 661 return ApiError::InstanceSize(); |
709 } | 662 } |
710 | 663 |
711 | |
712 intptr_t RawLanguageError::VisitLanguageErrorPointers( | 664 intptr_t RawLanguageError::VisitLanguageErrorPointers( |
713 RawLanguageError* raw_obj, | 665 RawLanguageError* raw_obj, |
714 ObjectPointerVisitor* visitor) { | 666 ObjectPointerVisitor* visitor) { |
715 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 667 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
716 return LanguageError::InstanceSize(); | 668 return LanguageError::InstanceSize(); |
717 } | 669 } |
718 | 670 |
719 | |
720 intptr_t RawUnhandledException::VisitUnhandledExceptionPointers( | 671 intptr_t RawUnhandledException::VisitUnhandledExceptionPointers( |
721 RawUnhandledException* raw_obj, | 672 RawUnhandledException* raw_obj, |
722 ObjectPointerVisitor* visitor) { | 673 ObjectPointerVisitor* visitor) { |
723 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 674 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
724 return UnhandledException::InstanceSize(); | 675 return UnhandledException::InstanceSize(); |
725 } | 676 } |
726 | 677 |
727 | |
728 intptr_t RawUnwindError::VisitUnwindErrorPointers( | 678 intptr_t RawUnwindError::VisitUnwindErrorPointers( |
729 RawUnwindError* raw_obj, | 679 RawUnwindError* raw_obj, |
730 ObjectPointerVisitor* visitor) { | 680 ObjectPointerVisitor* visitor) { |
731 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 681 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
732 return UnwindError::InstanceSize(); | 682 return UnwindError::InstanceSize(); |
733 } | 683 } |
734 | 684 |
735 | |
736 intptr_t RawInstance::VisitInstancePointers(RawInstance* raw_obj, | 685 intptr_t RawInstance::VisitInstancePointers(RawInstance* raw_obj, |
737 ObjectPointerVisitor* visitor) { | 686 ObjectPointerVisitor* visitor) { |
738 // Make sure that we got here with the tagged pointer as this. | 687 // Make sure that we got here with the tagged pointer as this. |
739 ASSERT(raw_obj->IsHeapObject()); | 688 ASSERT(raw_obj->IsHeapObject()); |
740 uint32_t tags = raw_obj->ptr()->tags_; | 689 uint32_t tags = raw_obj->ptr()->tags_; |
741 intptr_t instance_size = SizeTag::decode(tags); | 690 intptr_t instance_size = SizeTag::decode(tags); |
742 if (instance_size == 0) { | 691 if (instance_size == 0) { |
743 RawClass* cls = | 692 RawClass* cls = |
744 visitor->isolate()->GetClassForHeapWalkAt(raw_obj->GetClassId()); | 693 visitor->isolate()->GetClassForHeapWalkAt(raw_obj->GetClassId()); |
745 instance_size = cls->ptr()->instance_size_in_words_ << kWordSizeLog2; | 694 instance_size = cls->ptr()->instance_size_in_words_ << kWordSizeLog2; |
746 } | 695 } |
747 | 696 |
748 // Calculate the first and last raw object pointer fields. | 697 // Calculate the first and last raw object pointer fields. |
749 uword obj_addr = RawObject::ToAddr(raw_obj); | 698 uword obj_addr = RawObject::ToAddr(raw_obj); |
750 uword from = obj_addr + sizeof(RawObject); | 699 uword from = obj_addr + sizeof(RawObject); |
751 uword to = obj_addr + instance_size - kWordSize; | 700 uword to = obj_addr + instance_size - kWordSize; |
752 visitor->VisitPointers(reinterpret_cast<RawObject**>(from), | 701 visitor->VisitPointers(reinterpret_cast<RawObject**>(from), |
753 reinterpret_cast<RawObject**>(to)); | 702 reinterpret_cast<RawObject**>(to)); |
754 return instance_size; | 703 return instance_size; |
755 } | 704 } |
756 | 705 |
757 | |
758 intptr_t RawNumber::VisitNumberPointers(RawNumber* raw_obj, | 706 intptr_t RawNumber::VisitNumberPointers(RawNumber* raw_obj, |
759 ObjectPointerVisitor* visitor) { | 707 ObjectPointerVisitor* visitor) { |
760 // Number is an abstract class. | 708 // Number is an abstract class. |
761 UNREACHABLE(); | 709 UNREACHABLE(); |
762 return 0; | 710 return 0; |
763 } | 711 } |
764 | 712 |
765 | |
766 intptr_t RawInteger::VisitIntegerPointers(RawInteger* raw_obj, | 713 intptr_t RawInteger::VisitIntegerPointers(RawInteger* raw_obj, |
767 ObjectPointerVisitor* visitor) { | 714 ObjectPointerVisitor* visitor) { |
768 // Integer is an abstract class. | 715 // Integer is an abstract class. |
769 UNREACHABLE(); | 716 UNREACHABLE(); |
770 return 0; | 717 return 0; |
771 } | 718 } |
772 | 719 |
773 | |
774 intptr_t RawSmi::VisitSmiPointers(RawSmi* raw_obj, | 720 intptr_t RawSmi::VisitSmiPointers(RawSmi* raw_obj, |
775 ObjectPointerVisitor* visitor) { | 721 ObjectPointerVisitor* visitor) { |
776 // Smi does not have a heap representation. | 722 // Smi does not have a heap representation. |
777 UNREACHABLE(); | 723 UNREACHABLE(); |
778 return 0; | 724 return 0; |
779 } | 725 } |
780 | 726 |
781 | |
782 intptr_t RawMint::VisitMintPointers(RawMint* raw_obj, | 727 intptr_t RawMint::VisitMintPointers(RawMint* raw_obj, |
783 ObjectPointerVisitor* visitor) { | 728 ObjectPointerVisitor* visitor) { |
784 // Make sure that we got here with the tagged pointer as this. | 729 // Make sure that we got here with the tagged pointer as this. |
785 ASSERT(raw_obj->IsHeapObject()); | 730 ASSERT(raw_obj->IsHeapObject()); |
786 return Mint::InstanceSize(); | 731 return Mint::InstanceSize(); |
787 } | 732 } |
788 | 733 |
789 | |
790 intptr_t RawBigint::VisitBigintPointers(RawBigint* raw_obj, | 734 intptr_t RawBigint::VisitBigintPointers(RawBigint* raw_obj, |
791 ObjectPointerVisitor* visitor) { | 735 ObjectPointerVisitor* visitor) { |
792 // Make sure that we got here with the tagged pointer as this. | 736 // Make sure that we got here with the tagged pointer as this. |
793 ASSERT(raw_obj->IsHeapObject()); | 737 ASSERT(raw_obj->IsHeapObject()); |
794 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 738 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
795 return Bigint::InstanceSize(); | 739 return Bigint::InstanceSize(); |
796 } | 740 } |
797 | 741 |
798 | |
799 intptr_t RawDouble::VisitDoublePointers(RawDouble* raw_obj, | 742 intptr_t RawDouble::VisitDoublePointers(RawDouble* raw_obj, |
800 ObjectPointerVisitor* visitor) { | 743 ObjectPointerVisitor* visitor) { |
801 // Make sure that we got here with the tagged pointer as this. | 744 // Make sure that we got here with the tagged pointer as this. |
802 ASSERT(raw_obj->IsHeapObject()); | 745 ASSERT(raw_obj->IsHeapObject()); |
803 return Double::InstanceSize(); | 746 return Double::InstanceSize(); |
804 } | 747 } |
805 | 748 |
806 | |
807 intptr_t RawString::VisitStringPointers(RawString* raw_obj, | 749 intptr_t RawString::VisitStringPointers(RawString* raw_obj, |
808 ObjectPointerVisitor* visitor) { | 750 ObjectPointerVisitor* visitor) { |
809 // String is an abstract class. | 751 // String is an abstract class. |
810 UNREACHABLE(); | 752 UNREACHABLE(); |
811 return 0; | 753 return 0; |
812 } | 754 } |
813 | 755 |
814 | |
815 intptr_t RawOneByteString::VisitOneByteStringPointers( | 756 intptr_t RawOneByteString::VisitOneByteStringPointers( |
816 RawOneByteString* raw_obj, | 757 RawOneByteString* raw_obj, |
817 ObjectPointerVisitor* visitor) { | 758 ObjectPointerVisitor* visitor) { |
818 ASSERT(!raw_obj->ptr()->length_->IsHeapObject()); | 759 ASSERT(!raw_obj->ptr()->length_->IsHeapObject()); |
819 #if !defined(HASH_IN_OBJECT_HEADER) | 760 #if !defined(HASH_IN_OBJECT_HEADER) |
820 ASSERT(!raw_obj->ptr()->hash_->IsHeapObject()); | 761 ASSERT(!raw_obj->ptr()->hash_->IsHeapObject()); |
821 #endif | 762 #endif |
822 intptr_t length = Smi::Value(raw_obj->ptr()->length_); | 763 intptr_t length = Smi::Value(raw_obj->ptr()->length_); |
823 return OneByteString::InstanceSize(length); | 764 return OneByteString::InstanceSize(length); |
824 } | 765 } |
825 | 766 |
826 | |
827 intptr_t RawTwoByteString::VisitTwoByteStringPointers( | 767 intptr_t RawTwoByteString::VisitTwoByteStringPointers( |
828 RawTwoByteString* raw_obj, | 768 RawTwoByteString* raw_obj, |
829 ObjectPointerVisitor* visitor) { | 769 ObjectPointerVisitor* visitor) { |
830 ASSERT(!raw_obj->ptr()->length_->IsHeapObject()); | 770 ASSERT(!raw_obj->ptr()->length_->IsHeapObject()); |
831 #if !defined(HASH_IN_OBJECT_HEADER) | 771 #if !defined(HASH_IN_OBJECT_HEADER) |
832 ASSERT(!raw_obj->ptr()->hash_->IsHeapObject()); | 772 ASSERT(!raw_obj->ptr()->hash_->IsHeapObject()); |
833 #endif | 773 #endif |
834 intptr_t length = Smi::Value(raw_obj->ptr()->length_); | 774 intptr_t length = Smi::Value(raw_obj->ptr()->length_); |
835 return TwoByteString::InstanceSize(length); | 775 return TwoByteString::InstanceSize(length); |
836 } | 776 } |
837 | 777 |
838 | |
839 intptr_t RawExternalOneByteString::VisitExternalOneByteStringPointers( | 778 intptr_t RawExternalOneByteString::VisitExternalOneByteStringPointers( |
840 RawExternalOneByteString* raw_obj, | 779 RawExternalOneByteString* raw_obj, |
841 ObjectPointerVisitor* visitor) { | 780 ObjectPointerVisitor* visitor) { |
842 // Make sure that we got here with the tagged pointer as this. | 781 // Make sure that we got here with the tagged pointer as this. |
843 ASSERT(raw_obj->IsHeapObject()); | 782 ASSERT(raw_obj->IsHeapObject()); |
844 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 783 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
845 return ExternalOneByteString::InstanceSize(); | 784 return ExternalOneByteString::InstanceSize(); |
846 } | 785 } |
847 | 786 |
848 | |
849 intptr_t RawExternalTwoByteString::VisitExternalTwoByteStringPointers( | 787 intptr_t RawExternalTwoByteString::VisitExternalTwoByteStringPointers( |
850 RawExternalTwoByteString* raw_obj, | 788 RawExternalTwoByteString* raw_obj, |
851 ObjectPointerVisitor* visitor) { | 789 ObjectPointerVisitor* visitor) { |
852 // Make sure that we got here with the tagged pointer as this. | 790 // Make sure that we got here with the tagged pointer as this. |
853 ASSERT(raw_obj->IsHeapObject()); | 791 ASSERT(raw_obj->IsHeapObject()); |
854 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 792 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
855 return ExternalTwoByteString::InstanceSize(); | 793 return ExternalTwoByteString::InstanceSize(); |
856 } | 794 } |
857 | 795 |
858 | |
859 intptr_t RawBool::VisitBoolPointers(RawBool* raw_obj, | 796 intptr_t RawBool::VisitBoolPointers(RawBool* raw_obj, |
860 ObjectPointerVisitor* visitor) { | 797 ObjectPointerVisitor* visitor) { |
861 // Make sure that we got here with the tagged pointer as this. | 798 // Make sure that we got here with the tagged pointer as this. |
862 ASSERT(raw_obj->IsHeapObject()); | 799 ASSERT(raw_obj->IsHeapObject()); |
863 return Bool::InstanceSize(); | 800 return Bool::InstanceSize(); |
864 } | 801 } |
865 | 802 |
866 | |
867 intptr_t RawArray::VisitArrayPointers(RawArray* raw_obj, | 803 intptr_t RawArray::VisitArrayPointers(RawArray* raw_obj, |
868 ObjectPointerVisitor* visitor) { | 804 ObjectPointerVisitor* visitor) { |
869 intptr_t length = Smi::Value(raw_obj->ptr()->length_); | 805 intptr_t length = Smi::Value(raw_obj->ptr()->length_); |
870 visitor->VisitPointers(raw_obj->from(), raw_obj->to(length)); | 806 visitor->VisitPointers(raw_obj->from(), raw_obj->to(length)); |
871 return Array::InstanceSize(length); | 807 return Array::InstanceSize(length); |
872 } | 808 } |
873 | 809 |
874 | |
875 intptr_t RawImmutableArray::VisitImmutableArrayPointers( | 810 intptr_t RawImmutableArray::VisitImmutableArrayPointers( |
876 RawImmutableArray* raw_obj, | 811 RawImmutableArray* raw_obj, |
877 ObjectPointerVisitor* visitor) { | 812 ObjectPointerVisitor* visitor) { |
878 return RawArray::VisitArrayPointers(raw_obj, visitor); | 813 return RawArray::VisitArrayPointers(raw_obj, visitor); |
879 } | 814 } |
880 | 815 |
881 | |
882 intptr_t RawGrowableObjectArray::VisitGrowableObjectArrayPointers( | 816 intptr_t RawGrowableObjectArray::VisitGrowableObjectArrayPointers( |
883 RawGrowableObjectArray* raw_obj, | 817 RawGrowableObjectArray* raw_obj, |
884 ObjectPointerVisitor* visitor) { | 818 ObjectPointerVisitor* visitor) { |
885 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 819 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
886 return GrowableObjectArray::InstanceSize(); | 820 return GrowableObjectArray::InstanceSize(); |
887 } | 821 } |
888 | 822 |
889 | |
890 intptr_t RawLinkedHashMap::VisitLinkedHashMapPointers( | 823 intptr_t RawLinkedHashMap::VisitLinkedHashMapPointers( |
891 RawLinkedHashMap* raw_obj, | 824 RawLinkedHashMap* raw_obj, |
892 ObjectPointerVisitor* visitor) { | 825 ObjectPointerVisitor* visitor) { |
893 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 826 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
894 return LinkedHashMap::InstanceSize(); | 827 return LinkedHashMap::InstanceSize(); |
895 } | 828 } |
896 | 829 |
897 | |
898 intptr_t RawFloat32x4::VisitFloat32x4Pointers(RawFloat32x4* raw_obj, | 830 intptr_t RawFloat32x4::VisitFloat32x4Pointers(RawFloat32x4* raw_obj, |
899 ObjectPointerVisitor* visitor) { | 831 ObjectPointerVisitor* visitor) { |
900 ASSERT(raw_obj->IsHeapObject()); | 832 ASSERT(raw_obj->IsHeapObject()); |
901 return Float32x4::InstanceSize(); | 833 return Float32x4::InstanceSize(); |
902 } | 834 } |
903 | 835 |
904 | |
905 intptr_t RawInt32x4::VisitInt32x4Pointers(RawInt32x4* raw_obj, | 836 intptr_t RawInt32x4::VisitInt32x4Pointers(RawInt32x4* raw_obj, |
906 ObjectPointerVisitor* visitor) { | 837 ObjectPointerVisitor* visitor) { |
907 ASSERT(raw_obj->IsHeapObject()); | 838 ASSERT(raw_obj->IsHeapObject()); |
908 return Int32x4::InstanceSize(); | 839 return Int32x4::InstanceSize(); |
909 } | 840 } |
910 | 841 |
911 | |
912 intptr_t RawFloat64x2::VisitFloat64x2Pointers(RawFloat64x2* raw_obj, | 842 intptr_t RawFloat64x2::VisitFloat64x2Pointers(RawFloat64x2* raw_obj, |
913 ObjectPointerVisitor* visitor) { | 843 ObjectPointerVisitor* visitor) { |
914 ASSERT(raw_obj->IsHeapObject()); | 844 ASSERT(raw_obj->IsHeapObject()); |
915 return Float64x2::InstanceSize(); | 845 return Float64x2::InstanceSize(); |
916 } | 846 } |
917 | 847 |
918 intptr_t RawTypedData::VisitTypedDataPointers(RawTypedData* raw_obj, | 848 intptr_t RawTypedData::VisitTypedDataPointers(RawTypedData* raw_obj, |
919 ObjectPointerVisitor* visitor) { | 849 ObjectPointerVisitor* visitor) { |
920 // Make sure that we got here with the tagged pointer as this. | 850 // Make sure that we got here with the tagged pointer as this. |
921 ASSERT(raw_obj->IsHeapObject()); | 851 ASSERT(raw_obj->IsHeapObject()); |
922 intptr_t cid = raw_obj->GetClassId(); | 852 intptr_t cid = raw_obj->GetClassId(); |
923 intptr_t array_len = Smi::Value(raw_obj->ptr()->length_); | 853 intptr_t array_len = Smi::Value(raw_obj->ptr()->length_); |
924 intptr_t lengthInBytes = array_len * TypedData::ElementSizeInBytes(cid); | 854 intptr_t lengthInBytes = array_len * TypedData::ElementSizeInBytes(cid); |
925 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 855 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
926 return TypedData::InstanceSize(lengthInBytes); | 856 return TypedData::InstanceSize(lengthInBytes); |
927 } | 857 } |
928 | 858 |
929 | |
930 intptr_t RawExternalTypedData::VisitExternalTypedDataPointers( | 859 intptr_t RawExternalTypedData::VisitExternalTypedDataPointers( |
931 RawExternalTypedData* raw_obj, | 860 RawExternalTypedData* raw_obj, |
932 ObjectPointerVisitor* visitor) { | 861 ObjectPointerVisitor* visitor) { |
933 // Make sure that we got here with the tagged pointer as this. | 862 // Make sure that we got here with the tagged pointer as this. |
934 ASSERT(raw_obj->IsHeapObject()); | 863 ASSERT(raw_obj->IsHeapObject()); |
935 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 864 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
936 return ExternalTypedData::InstanceSize(); | 865 return ExternalTypedData::InstanceSize(); |
937 } | 866 } |
938 | 867 |
939 intptr_t RawCapability::VisitCapabilityPointers(RawCapability* raw_obj, | 868 intptr_t RawCapability::VisitCapabilityPointers(RawCapability* raw_obj, |
940 ObjectPointerVisitor* visitor) { | 869 ObjectPointerVisitor* visitor) { |
941 // Make sure that we got here with the tagged pointer as this. | 870 // Make sure that we got here with the tagged pointer as this. |
942 ASSERT(raw_obj->IsHeapObject()); | 871 ASSERT(raw_obj->IsHeapObject()); |
943 return Capability::InstanceSize(); | 872 return Capability::InstanceSize(); |
944 } | 873 } |
945 | 874 |
946 | |
947 intptr_t RawReceivePort::VisitReceivePortPointers( | 875 intptr_t RawReceivePort::VisitReceivePortPointers( |
948 RawReceivePort* raw_obj, | 876 RawReceivePort* raw_obj, |
949 ObjectPointerVisitor* visitor) { | 877 ObjectPointerVisitor* visitor) { |
950 // Make sure that we got here with the tagged pointer as this. | 878 // Make sure that we got here with the tagged pointer as this. |
951 ASSERT(raw_obj->IsHeapObject()); | 879 ASSERT(raw_obj->IsHeapObject()); |
952 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 880 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
953 return ReceivePort::InstanceSize(); | 881 return ReceivePort::InstanceSize(); |
954 } | 882 } |
955 | 883 |
956 | |
957 intptr_t RawSendPort::VisitSendPortPointers(RawSendPort* raw_obj, | 884 intptr_t RawSendPort::VisitSendPortPointers(RawSendPort* raw_obj, |
958 ObjectPointerVisitor* visitor) { | 885 ObjectPointerVisitor* visitor) { |
959 // Make sure that we got here with the tagged pointer as this. | 886 // Make sure that we got here with the tagged pointer as this. |
960 ASSERT(raw_obj->IsHeapObject()); | 887 ASSERT(raw_obj->IsHeapObject()); |
961 return SendPort::InstanceSize(); | 888 return SendPort::InstanceSize(); |
962 } | 889 } |
963 | 890 |
964 | |
965 intptr_t RawStackTrace::VisitStackTracePointers(RawStackTrace* raw_obj, | 891 intptr_t RawStackTrace::VisitStackTracePointers(RawStackTrace* raw_obj, |
966 ObjectPointerVisitor* visitor) { | 892 ObjectPointerVisitor* visitor) { |
967 // Make sure that we got here with the tagged pointer as this. | 893 // Make sure that we got here with the tagged pointer as this. |
968 ASSERT(raw_obj->IsHeapObject()); | 894 ASSERT(raw_obj->IsHeapObject()); |
969 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 895 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
970 return StackTrace::InstanceSize(); | 896 return StackTrace::InstanceSize(); |
971 } | 897 } |
972 | 898 |
973 | |
974 intptr_t RawRegExp::VisitRegExpPointers(RawRegExp* raw_obj, | 899 intptr_t RawRegExp::VisitRegExpPointers(RawRegExp* raw_obj, |
975 ObjectPointerVisitor* visitor) { | 900 ObjectPointerVisitor* visitor) { |
976 // Make sure that we got here with the tagged pointer as this. | 901 // Make sure that we got here with the tagged pointer as this. |
977 ASSERT(raw_obj->IsHeapObject()); | 902 ASSERT(raw_obj->IsHeapObject()); |
978 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 903 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
979 return RegExp::InstanceSize(); | 904 return RegExp::InstanceSize(); |
980 } | 905 } |
981 | 906 |
982 | |
983 intptr_t RawWeakProperty::VisitWeakPropertyPointers( | 907 intptr_t RawWeakProperty::VisitWeakPropertyPointers( |
984 RawWeakProperty* raw_obj, | 908 RawWeakProperty* raw_obj, |
985 ObjectPointerVisitor* visitor) { | 909 ObjectPointerVisitor* visitor) { |
986 // Make sure that we got here with the tagged pointer as this. | 910 // Make sure that we got here with the tagged pointer as this. |
987 ASSERT(raw_obj->IsHeapObject()); | 911 ASSERT(raw_obj->IsHeapObject()); |
988 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 912 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
989 return WeakProperty::InstanceSize(); | 913 return WeakProperty::InstanceSize(); |
990 } | 914 } |
991 | 915 |
992 | |
993 intptr_t RawMirrorReference::VisitMirrorReferencePointers( | 916 intptr_t RawMirrorReference::VisitMirrorReferencePointers( |
994 RawMirrorReference* raw_obj, | 917 RawMirrorReference* raw_obj, |
995 ObjectPointerVisitor* visitor) { | 918 ObjectPointerVisitor* visitor) { |
996 // Make sure that we got here with the tagged pointer as this. | 919 // Make sure that we got here with the tagged pointer as this. |
997 ASSERT(raw_obj->IsHeapObject()); | 920 ASSERT(raw_obj->IsHeapObject()); |
998 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 921 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
999 return MirrorReference::InstanceSize(); | 922 return MirrorReference::InstanceSize(); |
1000 } | 923 } |
1001 | 924 |
1002 | |
1003 intptr_t RawUserTag::VisitUserTagPointers(RawUserTag* raw_obj, | 925 intptr_t RawUserTag::VisitUserTagPointers(RawUserTag* raw_obj, |
1004 ObjectPointerVisitor* visitor) { | 926 ObjectPointerVisitor* visitor) { |
1005 // Make sure that we got here with the tagged pointer as this. | 927 // Make sure that we got here with the tagged pointer as this. |
1006 ASSERT(raw_obj->IsHeapObject()); | 928 ASSERT(raw_obj->IsHeapObject()); |
1007 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); | 929 visitor->VisitPointers(raw_obj->from(), raw_obj->to()); |
1008 return UserTag::InstanceSize(); | 930 return UserTag::InstanceSize(); |
1009 } | 931 } |
1010 | 932 |
1011 | |
1012 } // namespace dart | 933 } // namespace dart |
OLD | NEW |