src/3rdparty/v8/src/objects-debug.cc

   1 // Copyright 2012 the V8 project authors. All rights reserved.
   2 // 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 "disassembler.h"
  31 #include "disasm.h"
  32 #include "jsregexp.h"
  33 #include "objects-visiting.h"
  34
  35 namespace v8 {
  36 namespace internal {
  37
  38 #ifdef DEBUG
  39
  40 void MaybeObject::Verify() {
  41   Object* this_as_object;
  42   if (ToObject(&this_as_object)) {
  43     if (this_as_object->IsSmi()) {
  44       Smi::cast(this_as_object)->SmiVerify();
  45     } else {
  46       HeapObject::cast(this_as_object)->HeapObjectVerify();
  47     }
  48   } else {
  49     Failure::cast(this)->FailureVerify();
  50   }
  51 }
  52
  53
  54 void Object::VerifyPointer(Object* p) {
  55   if (p->IsHeapObject()) {
  56     HeapObject::VerifyHeapPointer(p);
  57   } else {
  58     ASSERT(p->IsSmi());
  59   }
  60 }
  61
  62
  63 void Smi::SmiVerify() {
  64   ASSERT(IsSmi());
  65 }
  66
  67
  68 void Failure::FailureVerify() {
  69   ASSERT(IsFailure());
  70 }
  71
  72
  73 void HeapObject::HeapObjectVerify() {
  74   InstanceType instance_type = map()->instance_type();
  75
  76   if (instance_type < FIRST_NONSTRING_TYPE) {
  77     String::cast(this)->StringVerify();
  78     return;
  79   }
  80
  81   switch (instance_type) {
  82     case MAP_TYPE:
  83       Map::cast(this)->MapVerify();
  84       break;
  85     case HEAP_NUMBER_TYPE:
  86       HeapNumber::cast(this)->HeapNumberVerify();
  87       break;
  88     case FIXED_ARRAY_TYPE:
  89       FixedArray::cast(this)->FixedArrayVerify();
  90       break;
  91     case FIXED_DOUBLE_ARRAY_TYPE:
  92       FixedDoubleArray::cast(this)->FixedDoubleArrayVerify();
  93       break;
  94     case BYTE_ARRAY_TYPE:
  95       ByteArray::cast(this)->ByteArrayVerify();
  96       break;
  97     case FREE_SPACE_TYPE:
  98       FreeSpace::cast(this)->FreeSpaceVerify();
  99       break;
 100     case EXTERNAL_PIXEL_ARRAY_TYPE:
 101       ExternalPixelArray::cast(this)->ExternalPixelArrayVerify();
 102       break;
 103     case EXTERNAL_BYTE_ARRAY_TYPE:
 104       ExternalByteArray::cast(this)->ExternalByteArrayVerify();
 105       break;
 106     case EXTERNAL_UNSIGNED_BYTE_ARRAY_TYPE:
 107       ExternalUnsignedByteArray::cast(this)->ExternalUnsignedByteArrayVerify();
 108       break;
 109     case EXTERNAL_SHORT_ARRAY_TYPE:
 110       ExternalShortArray::cast(this)->ExternalShortArrayVerify();
 111       break;
 112     case EXTERNAL_UNSIGNED_SHORT_ARRAY_TYPE:
 113       ExternalUnsignedShortArray::cast(this)->
 114           ExternalUnsignedShortArrayVerify();
 115       break;
 116     case EXTERNAL_INT_ARRAY_TYPE:
 117       ExternalIntArray::cast(this)->ExternalIntArrayVerify();
 118       break;
 119     case EXTERNAL_UNSIGNED_INT_ARRAY_TYPE:
 120       ExternalUnsignedIntArray::cast(this)->ExternalUnsignedIntArrayVerify();
 121       break;
 122     case EXTERNAL_FLOAT_ARRAY_TYPE:
 123       ExternalFloatArray::cast(this)->ExternalFloatArrayVerify();
 124       break;
 125     case EXTERNAL_DOUBLE_ARRAY_TYPE:
 126       ExternalDoubleArray::cast(this)->ExternalDoubleArrayVerify();
 127       break;
 128     case CODE_TYPE:
 129       Code::cast(this)->CodeVerify();
 130       break;
 131     case ODDBALL_TYPE:
 132       Oddball::cast(this)->OddballVerify();
 133       break;
 134     case JS_OBJECT_TYPE:
 135     case JS_CONTEXT_EXTENSION_OBJECT_TYPE:
 136       JSObject::cast(this)->JSObjectVerify();
 137       break;
 138     case JS_MODULE_TYPE:
 139       JSModule::cast(this)->JSModuleVerify();
 140       break;
 141     case JS_VALUE_TYPE:
 142       JSValue::cast(this)->JSValueVerify();
 143       break;
 144     case JS_DATE_TYPE:
 145       JSDate::cast(this)->JSDateVerify();
 146       break;
 147     case JS_FUNCTION_TYPE:
 148       JSFunction::cast(this)->JSFunctionVerify();
 149       break;
 150     case JS_GLOBAL_PROXY_TYPE:
 151       JSGlobalProxy::cast(this)->JSGlobalProxyVerify();
 152       break;
 153     case JS_GLOBAL_OBJECT_TYPE:
 154       JSGlobalObject::cast(this)->JSGlobalObjectVerify();
 155       break;
 156     case JS_BUILTINS_OBJECT_TYPE:
 157       JSBuiltinsObject::cast(this)->JSBuiltinsObjectVerify();
 158       break;
 159     case JS_GLOBAL_PROPERTY_CELL_TYPE:
 160       JSGlobalPropertyCell::cast(this)->JSGlobalPropertyCellVerify();
 161       break;
 162     case JS_ARRAY_TYPE:
 163       JSArray::cast(this)->JSArrayVerify();
 164       break;
 165     case JS_SET_TYPE:
 166       JSSet::cast(this)->JSSetVerify();
 167       break;
 168     case JS_MAP_TYPE:
 169       JSMap::cast(this)->JSMapVerify();
 170       break;
 171     case JS_WEAK_MAP_TYPE:
 172       JSWeakMap::cast(this)->JSWeakMapVerify();
 173       break;
 174     case JS_REGEXP_TYPE:
 175       JSRegExp::cast(this)->JSRegExpVerify();
 176       break;
 177     case FILLER_TYPE:
 178       break;
 179     case JS_PROXY_TYPE:
 180       JSProxy::cast(this)->JSProxyVerify();
 181       break;
 182     case JS_FUNCTION_PROXY_TYPE:
 183       JSFunctionProxy::cast(this)->JSFunctionProxyVerify();
 184       break;
 185     case FOREIGN_TYPE:
 186       Foreign::cast(this)->ForeignVerify();
 187       break;
 188     case SHARED_FUNCTION_INFO_TYPE:
 189       SharedFunctionInfo::cast(this)->SharedFunctionInfoVerify();
 190       break;
 191     case JS_MESSAGE_OBJECT_TYPE:
 192       JSMessageObject::cast(this)->JSMessageObjectVerify();
 193       break;
 194
 195 #define MAKE_STRUCT_CASE(NAME, Name, name) \
 196   case NAME##_TYPE:                        \
 197     Name::cast(this)->Name##Verify();      \
 198     break;
 199     STRUCT_LIST(MAKE_STRUCT_CASE)
 200 #undef MAKE_STRUCT_CASE
 201
 202     default:
 203       UNREACHABLE();
 204       break;
 205   }
 206 }
 207
 208
 209 void HeapObject::VerifyHeapPointer(Object* p) {
 210   ASSERT(p->IsHeapObject());
 211   ASSERT(HEAP->Contains(HeapObject::cast(p)));
 212 }
 213
 214
 215 void HeapNumber::HeapNumberVerify() {
 216   ASSERT(IsHeapNumber());
 217 }
 218
 219
 220 void ByteArray::ByteArrayVerify() {
 221   ASSERT(IsByteArray());
 222 }
 223
 224
 225 void FreeSpace::FreeSpaceVerify() {
 226   ASSERT(IsFreeSpace());
 227 }
 228
 229
 230 void ExternalPixelArray::ExternalPixelArrayVerify() {
 231   ASSERT(IsExternalPixelArray());
 232 }
 233
 234
 235 void ExternalByteArray::ExternalByteArrayVerify() {
 236   ASSERT(IsExternalByteArray());
 237 }
 238
 239
 240 void ExternalUnsignedByteArray::ExternalUnsignedByteArrayVerify() {
 241   ASSERT(IsExternalUnsignedByteArray());
 242 }
 243
 244
 245 void ExternalShortArray::ExternalShortArrayVerify() {
 246   ASSERT(IsExternalShortArray());
 247 }
 248
 249
 250 void ExternalUnsignedShortArray::ExternalUnsignedShortArrayVerify() {
 251   ASSERT(IsExternalUnsignedShortArray());
 252 }
 253
 254
 255 void ExternalIntArray::ExternalIntArrayVerify() {
 256   ASSERT(IsExternalIntArray());
 257 }
 258
 259
 260 void ExternalUnsignedIntArray::ExternalUnsignedIntArrayVerify() {
 261   ASSERT(IsExternalUnsignedIntArray());
 262 }
 263
 264
 265 void ExternalFloatArray::ExternalFloatArrayVerify() {
 266   ASSERT(IsExternalFloatArray());
 267 }
 268
 269
 270 void ExternalDoubleArray::ExternalDoubleArrayVerify() {
 271   ASSERT(IsExternalDoubleArray());
 272 }
 273
 274
 275 void JSObject::JSObjectVerify() {
 276   VerifyHeapPointer(properties());
 277   VerifyHeapPointer(elements());
 278
 279   if (GetElementsKind() == NON_STRICT_ARGUMENTS_ELEMENTS) {
 280     ASSERT(this->elements()->IsFixedArray());
 281     ASSERT(this->elements()->length() >= 2);
 282   }
 283
 284   if (HasFastProperties()) {
 285     CHECK_EQ(map()->unused_property_fields(),
 286              (map()->inobject_properties() + properties()->length() -
 287               map()->NextFreePropertyIndex()));
 288   }
 289   ASSERT_EQ((map()->has_fast_elements() ||
 290              map()->has_fast_smi_only_elements() ||
 291              (elements() == GetHeap()->empty_fixed_array())),
 292             (elements()->map() == GetHeap()->fixed_array_map() ||
 293              elements()->map() == GetHeap()->fixed_cow_array_map()));
 294   ASSERT(map()->has_fast_elements() == HasFastElements());
 295 }
 296
 297
 298 void Map::MapVerify() {
 299   ASSERT(!HEAP->InNewSpace(this));
 300   ASSERT(FIRST_TYPE <= instance_type() && instance_type() <= LAST_TYPE);
 301   ASSERT(instance_size() == kVariableSizeSentinel ||
 302          (kPointerSize <= instance_size() &&
 303           instance_size() < HEAP->Capacity()));
 304   VerifyHeapPointer(prototype());
 305   VerifyHeapPointer(instance_descriptors());
 306   SLOW_ASSERT(instance_descriptors()->IsSortedNoDuplicates());
 307   SLOW_ASSERT(instance_descriptors()->IsConsistentWithBackPointers(this));
 308 }
 309
 310
 311 void Map::SharedMapVerify() {
 312   MapVerify();
 313   ASSERT(is_shared());
 314   ASSERT(instance_descriptors()->IsEmpty());
 315   ASSERT_EQ(0, pre_allocated_property_fields());
 316   ASSERT_EQ(0, unused_property_fields());
 317   ASSERT_EQ(StaticVisitorBase::GetVisitorId(instance_type(), instance_size()),
 318       visitor_id());
 319 }
 320
 321
 322 void CodeCache::CodeCacheVerify() {
 323   VerifyHeapPointer(default_cache());
 324   VerifyHeapPointer(normal_type_cache());
 325   ASSERT(default_cache()->IsFixedArray());
 326   ASSERT(normal_type_cache()->IsUndefined()
 327          || normal_type_cache()->IsCodeCacheHashTable());
 328 }
 329
 330
 331 void PolymorphicCodeCache::PolymorphicCodeCacheVerify() {
 332   VerifyHeapPointer(cache());
 333   ASSERT(cache()->IsUndefined() || cache()->IsPolymorphicCodeCacheHashTable());
 334 }
 335
 336
 337 void TypeFeedbackInfo::TypeFeedbackInfoVerify() {
 338   VerifyObjectField(kIcTotalCountOffset);
 339   VerifyObjectField(kIcWithTypeinfoCountOffset);
 340   VerifyHeapPointer(type_feedback_cells());
 341 }
 342
 343
 344 void AliasedArgumentsEntry::AliasedArgumentsEntryVerify() {
 345   VerifySmiField(kAliasedContextSlot);
 346 }
 347
 348
 349 void FixedArray::FixedArrayVerify() {
 350   for (int i = 0; i < length(); i++) {
 351     Object* e = get(i);
 352     if (e->IsHeapObject()) {
 353       VerifyHeapPointer(e);
 354     } else {
 355       e->Verify();
 356     }
 357   }
 358 }
 359
 360
 361 void FixedDoubleArray::FixedDoubleArrayVerify() {
 362   for (int i = 0; i < length(); i++) {
 363     if (!is_the_hole(i)) {
 364       double value = get_scalar(i);
 365       ASSERT(!isnan(value) ||
 366              (BitCast<uint64_t>(value) ==
 367               BitCast<uint64_t>(canonical_not_the_hole_nan_as_double())) ||
 368              ((BitCast<uint64_t>(value) & Double::kSignMask) != 0));
 369     }
 370   }
 371 }
 372
 373
 374 void JSModule::JSModuleVerify() {
 375   Object* v = context();
 376   if (v->IsHeapObject()) {
 377     VerifyHeapPointer(v);
 378   }
 379   CHECK(v->IsUndefined() || v->IsModuleContext());
 380 }
 381
 382
 383 void JSValue::JSValueVerify() {
 384   Object* v = value();
 385   if (v->IsHeapObject()) {
 386     VerifyHeapPointer(v);
 387   }
 388 }
 389
 390
 391 void JSDate::JSDateVerify() {
 392   if (value()->IsHeapObject()) {
 393     VerifyHeapPointer(value());
 394   }
 395   CHECK(value()->IsUndefined() || value()->IsSmi() || value()->IsHeapNumber());
 396   CHECK(year()->IsUndefined() || year()->IsSmi() || year()->IsNaN());
 397   CHECK(month()->IsUndefined() || month()->IsSmi() || month()->IsNaN());
 398   CHECK(day()->IsUndefined() || day()->IsSmi() || day()->IsNaN());
 399   CHECK(weekday()->IsUndefined() || weekday()->IsSmi() || weekday()->IsNaN());
 400   CHECK(hour()->IsUndefined() || hour()->IsSmi() || hour()->IsNaN());
 401   CHECK(min()->IsUndefined() || min()->IsSmi() || min()->IsNaN());
 402   CHECK(sec()->IsUndefined() || sec()->IsSmi() || sec()->IsNaN());
 403   CHECK(cache_stamp()->IsUndefined() ||
 404         cache_stamp()->IsSmi() ||
 405         cache_stamp()->IsNaN());
 406
 407   if (month()->IsSmi()) {
 408     int month = Smi::cast(this->month())->value();
 409     CHECK(0 <= month && month <= 11);
 410   }
 411   if (day()->IsSmi()) {
 412     int day = Smi::cast(this->day())->value();
 413     CHECK(1 <= day && day <= 31);
 414   }
 415   if (hour()->IsSmi()) {
 416     int hour = Smi::cast(this->hour())->value();
 417     CHECK(0 <= hour && hour <= 23);
 418   }
 419   if (min()->IsSmi()) {
 420     int min = Smi::cast(this->min())->value();
 421     CHECK(0 <= min && min <= 59);
 422   }
 423   if (sec()->IsSmi()) {
 424     int sec = Smi::cast(this->sec())->value();
 425     CHECK(0 <= sec && sec <= 59);
 426   }
 427   if (weekday()->IsSmi()) {
 428     int weekday = Smi::cast(this->weekday())->value();
 429     CHECK(0 <= weekday && weekday <= 6);
 430   }
 431   if (cache_stamp()->IsSmi()) {
 432     CHECK(Smi::cast(cache_stamp())->value() <=
 433           Smi::cast(Isolate::Current()->date_cache()->stamp())->value());
 434   }
 435 }
 436
 437
 438 void JSMessageObject::JSMessageObjectVerify() {
 439   CHECK(IsJSMessageObject());
 440   CHECK(type()->IsString());
 441   CHECK(arguments()->IsJSArray());
 442   VerifyObjectField(kStartPositionOffset);
 443   VerifyObjectField(kEndPositionOffset);
 444   VerifyObjectField(kArgumentsOffset);
 445   VerifyObjectField(kScriptOffset);
 446   VerifyObjectField(kStackTraceOffset);
 447   VerifyObjectField(kStackFramesOffset);
 448 }
 449
 450
 451 void String::StringVerify() {
 452   CHECK(IsString());
 453   CHECK(length() >= 0 && length() <= Smi::kMaxValue);
 454   if (IsSymbol()) {
 455     CHECK(!HEAP->InNewSpace(this));
 456   }
 457   if (IsConsString()) {
 458     ConsString::cast(this)->ConsStringVerify();
 459   } else if (IsSlicedString()) {
 460     SlicedString::cast(this)->SlicedStringVerify();
 461   }
 462 }
 463
 464
 465 void ConsString::ConsStringVerify() {
 466   CHECK(this->first()->IsString());
 467   CHECK(this->second() == GetHeap()->empty_string() ||
 468         this->second()->IsString());
 469   CHECK(this->length() >= ConsString::kMinLength);
 470   if (this->IsFlat()) {
 471     // A flat cons can only be created by String::SlowTryFlatten.
 472     // Afterwards, the first part may be externalized.
 473     CHECK(this->first()->IsSeqString() || this->first()->IsExternalString());
 474   }
 475 }
 476
 477
 478 void SlicedString::SlicedStringVerify() {
 479   CHECK(!this->parent()->IsConsString());
 480   CHECK(!this->parent()->IsSlicedString());
 481   CHECK(this->length() >= SlicedString::kMinLength);
 482 }
 483
 484
 485 void JSFunction::JSFunctionVerify() {
 486   CHECK(IsJSFunction());
 487   VerifyObjectField(kPrototypeOrInitialMapOffset);
 488   VerifyObjectField(kNextFunctionLinkOffset);
 489   CHECK(code()->IsCode());
 490   CHECK(next_function_link()->IsUndefined() ||
 491         next_function_link()->IsJSFunction());
 492 }
 493
 494
 495 void SharedFunctionInfo::SharedFunctionInfoVerify() {
 496   CHECK(IsSharedFunctionInfo());
 497   VerifyObjectField(kNameOffset);
 498   VerifyObjectField(kCodeOffset);
 499   VerifyObjectField(kScopeInfoOffset);
 500   VerifyObjectField(kInstanceClassNameOffset);
 501   VerifyObjectField(kFunctionDataOffset);
 502   VerifyObjectField(kScriptOffset);
 503   VerifyObjectField(kDebugInfoOffset);
 504 }
 505
 506
 507 void JSGlobalProxy::JSGlobalProxyVerify() {
 508   CHECK(IsJSGlobalProxy());
 509   JSObjectVerify();
 510   VerifyObjectField(JSGlobalProxy::kContextOffset);
 511   // Make sure that this object has no properties, elements.
 512   CHECK_EQ(0, properties()->length());
 513   CHECK(HasFastElements());
 514   CHECK_EQ(0, FixedArray::cast(elements())->length());
 515 }
 516
 517
 518 void JSGlobalObject::JSGlobalObjectVerify() {
 519   CHECK(IsJSGlobalObject());
 520   JSObjectVerify();
 521   for (int i = GlobalObject::kBuiltinsOffset;
 522        i < JSGlobalObject::kSize;
 523        i += kPointerSize) {
 524     VerifyObjectField(i);
 525   }
 526 }
 527
 528
 529 void JSBuiltinsObject::JSBuiltinsObjectVerify() {
 530   CHECK(IsJSBuiltinsObject());
 531   JSObjectVerify();
 532   for (int i = GlobalObject::kBuiltinsOffset;
 533        i < JSBuiltinsObject::kSize;
 534        i += kPointerSize) {
 535     VerifyObjectField(i);
 536   }
 537 }
 538
 539
 540 void Oddball::OddballVerify() {
 541   CHECK(IsOddball());
 542   VerifyHeapPointer(to_string());
 543   Object* number = to_number();
 544   if (number->IsHeapObject()) {
 545     ASSERT(number == HEAP->nan_value());
 546   } else {
 547     ASSERT(number->IsSmi());
 548     int value = Smi::cast(number)->value();
 549     // Hidden oddballs have negative smis.
 550     const int kLeastHiddenOddballNumber = -4;
 551     ASSERT(value <= 1);
 552     ASSERT(value >= kLeastHiddenOddballNumber);
 553   }
 554 }
 555
 556
 557 void JSGlobalPropertyCell::JSGlobalPropertyCellVerify() {
 558   CHECK(IsJSGlobalPropertyCell());
 559   VerifyObjectField(kValueOffset);
 560 }
 561
 562
 563 void Code::CodeVerify() {
 564   CHECK(IsAligned(reinterpret_cast<intptr_t>(instruction_start()),
 565                   kCodeAlignment));
 566   relocation_info()->Verify();
 567   Address last_gc_pc = NULL;
 568   for (RelocIterator it(this); !it.done(); it.next()) {
 569     it.rinfo()->Verify();
 570     // Ensure that GC will not iterate twice over the same pointer.
 571     if (RelocInfo::IsGCRelocMode(it.rinfo()->rmode())) {
 572       CHECK(it.rinfo()->pc() != last_gc_pc);
 573       last_gc_pc = it.rinfo()->pc();
 574     }
 575   }
 576 }
 577
 578
 579 void JSArray::JSArrayVerify() {
 580   JSObjectVerify();
 581   ASSERT(length()->IsNumber() || length()->IsUndefined());
 582   ASSERT(elements()->IsUndefined() ||
 583          elements()->IsFixedArray() ||
 584          elements()->IsFixedDoubleArray());
 585 }
 586
 587
 588 void JSSet::JSSetVerify() {
 589   CHECK(IsJSSet());
 590   JSObjectVerify();
 591   VerifyHeapPointer(table());
 592   ASSERT(table()->IsHashTable() || table()->IsUndefined());
 593 }
 594
 595
 596 void JSMap::JSMapVerify() {
 597   CHECK(IsJSMap());
 598   JSObjectVerify();
 599   VerifyHeapPointer(table());
 600   ASSERT(table()->IsHashTable() || table()->IsUndefined());
 601 }
 602
 603
 604 void JSWeakMap::JSWeakMapVerify() {
 605   CHECK(IsJSWeakMap());
 606   JSObjectVerify();
 607   VerifyHeapPointer(table());
 608   ASSERT(table()->IsHashTable() || table()->IsUndefined());
 609 }
 610
 611
 612 void JSRegExp::JSRegExpVerify() {
 613   JSObjectVerify();
 614   ASSERT(data()->IsUndefined() || data()->IsFixedArray());
 615   switch (TypeTag()) {
 616     case JSRegExp::ATOM: {
 617       FixedArray* arr = FixedArray::cast(data());
 618       ASSERT(arr->get(JSRegExp::kAtomPatternIndex)->IsString());
 619       break;
 620     }
 621     case JSRegExp::IRREGEXP: {
 622       bool is_native = RegExpImpl::UsesNativeRegExp();
 623
 624       FixedArray* arr = FixedArray::cast(data());
 625       Object* ascii_data = arr->get(JSRegExp::kIrregexpASCIICodeIndex);
 626       // Smi : Not compiled yet (-1) or code prepared for flushing.
 627       // JSObject: Compilation error.
 628       // Code/ByteArray: Compiled code.
 629       ASSERT(ascii_data->IsSmi() ||
 630              (is_native ? ascii_data->IsCode() : ascii_data->IsByteArray()));
 631       Object* uc16_data = arr->get(JSRegExp::kIrregexpUC16CodeIndex);
 632       ASSERT(uc16_data->IsSmi() ||
 633              (is_native ? uc16_data->IsCode() : uc16_data->IsByteArray()));
 634
 635       Object* ascii_saved = arr->get(JSRegExp::kIrregexpASCIICodeSavedIndex);
 636       ASSERT(ascii_saved->IsSmi() || ascii_saved->IsString() ||
 637              ascii_saved->IsCode());
 638       Object* uc16_saved = arr->get(JSRegExp::kIrregexpUC16CodeSavedIndex);
 639       ASSERT(uc16_saved->IsSmi() || uc16_saved->IsString() ||
 640              uc16_saved->IsCode());
 641
 642       ASSERT(arr->get(JSRegExp::kIrregexpCaptureCountIndex)->IsSmi());
 643       ASSERT(arr->get(JSRegExp::kIrregexpMaxRegisterCountIndex)->IsSmi());
 644       break;
 645     }
 646     default:
 647       ASSERT_EQ(JSRegExp::NOT_COMPILED, TypeTag());
 648       ASSERT(data()->IsUndefined());
 649       break;
 650   }
 651 }
 652
 653
 654 void JSProxy::JSProxyVerify() {
 655   CHECK(IsJSProxy());
 656   VerifyPointer(handler());
 657   ASSERT(hash()->IsSmi() || hash()->IsUndefined());
 658 }
 659
 660
 661 void JSFunctionProxy::JSFunctionProxyVerify() {
 662   CHECK(IsJSFunctionProxy());
 663   JSProxyVerify();
 664   VerifyPointer(call_trap());
 665   VerifyPointer(construct_trap());
 666 }
 667
 668
 669 void Foreign::ForeignVerify() {
 670   ASSERT(IsForeign());
 671 }
 672
 673
 674 void AccessorInfo::AccessorInfoVerify() {
 675   CHECK(IsAccessorInfo());
 676   VerifyPointer(getter());
 677   VerifyPointer(setter());
 678   VerifyPointer(name());
 679   VerifyPointer(data());
 680   VerifyPointer(flag());
 681 }
 682
 683
 684 void AccessorPair::AccessorPairVerify() {
 685   CHECK(IsAccessorPair());
 686   VerifyPointer(getter());
 687   VerifyPointer(setter());
 688 }
 689
 690
 691 void AccessCheckInfo::AccessCheckInfoVerify() {
 692   CHECK(IsAccessCheckInfo());
 693   VerifyPointer(named_callback());
 694   VerifyPointer(indexed_callback());
 695   VerifyPointer(data());
 696 }
 697
 698
 699 void InterceptorInfo::InterceptorInfoVerify() {
 700   CHECK(IsInterceptorInfo());
 701   VerifyPointer(getter());
 702   VerifyPointer(setter());
 703   VerifyPointer(query());
 704   VerifyPointer(deleter());
 705   VerifyPointer(enumerator());
 706   VerifyPointer(data());
 707 }
 708
 709
 710 void CallHandlerInfo::CallHandlerInfoVerify() {
 711   CHECK(IsCallHandlerInfo());
 712   VerifyPointer(callback());
 713   VerifyPointer(data());
 714 }
 715
 716
 717 void TemplateInfo::TemplateInfoVerify() {
 718   VerifyPointer(tag());
 719   VerifyPointer(property_list());
 720 }
 721
 722 void FunctionTemplateInfo::FunctionTemplateInfoVerify() {
 723   CHECK(IsFunctionTemplateInfo());
 724   TemplateInfoVerify();
 725   VerifyPointer(serial_number());
 726   VerifyPointer(call_code());
 727   VerifyPointer(property_accessors());
 728   VerifyPointer(prototype_template());
 729   VerifyPointer(parent_template());
 730   VerifyPointer(named_property_handler());
 731   VerifyPointer(indexed_property_handler());
 732   VerifyPointer(instance_template());
 733   VerifyPointer(signature());
 734   VerifyPointer(access_check_info());
 735 }
 736
 737
 738 void ObjectTemplateInfo::ObjectTemplateInfoVerify() {
 739   CHECK(IsObjectTemplateInfo());
 740   TemplateInfoVerify();
 741   VerifyPointer(constructor());
 742   VerifyPointer(internal_field_count());
 743 }
 744
 745
 746 void SignatureInfo::SignatureInfoVerify() {
 747   CHECK(IsSignatureInfo());
 748   VerifyPointer(receiver());
 749   VerifyPointer(args());
 750 }
 751
 752
 753 void TypeSwitchInfo::TypeSwitchInfoVerify() {
 754   CHECK(IsTypeSwitchInfo());
 755   VerifyPointer(types());
 756 }
 757
 758
 759 void Script::ScriptVerify() {
 760   CHECK(IsScript());
 761   VerifyPointer(source());
 762   VerifyPointer(name());
 763   line_offset()->SmiVerify();
 764   column_offset()->SmiVerify();
 765   VerifyPointer(data());
 766   VerifyPointer(wrapper());
 767   type()->SmiVerify();
 768   VerifyPointer(line_ends());
 769   VerifyPointer(id());
 770 }
 771
 772
 773 #ifdef ENABLE_DEBUGGER_SUPPORT
 774 void DebugInfo::DebugInfoVerify() {
 775   CHECK(IsDebugInfo());
 776   VerifyPointer(shared());
 777   VerifyPointer(original_code());
 778   VerifyPointer(code());
 779   VerifyPointer(break_points());
 780 }
 781
 782
 783 void BreakPointInfo::BreakPointInfoVerify() {
 784   CHECK(IsBreakPointInfo());
 785   code_position()->SmiVerify();
 786   source_position()->SmiVerify();
 787   statement_position()->SmiVerify();
 788   VerifyPointer(break_point_objects());
 789 }
 790 #endif  // ENABLE_DEBUGGER_SUPPORT
 791
 792
 793 void JSObject::IncrementSpillStatistics(SpillInformation* info) {
 794   info->number_of_objects_++;
 795   // Named properties
 796   if (HasFastProperties()) {
 797     info->number_of_objects_with_fast_properties_++;
 798     info->number_of_fast_used_fields_   += map()->NextFreePropertyIndex();
 799     info->number_of_fast_unused_fields_ += map()->unused_property_fields();
 800   } else {
 801     StringDictionary* dict = property_dictionary();
 802     info->number_of_slow_used_properties_ += dict->NumberOfElements();
 803     info->number_of_slow_unused_properties_ +=
 804         dict->Capacity() - dict->NumberOfElements();
 805   }
 806   // Indexed properties
 807   switch (GetElementsKind()) {
 808     case FAST_ELEMENTS: {
 809       info->number_of_objects_with_fast_elements_++;
 810       int holes = 0;
 811       FixedArray* e = FixedArray::cast(elements());
 812       int len = e->length();
 813       Heap* heap = HEAP;
 814       for (int i = 0; i < len; i++) {
 815         if (e->get(i) == heap->the_hole_value()) holes++;
 816       }
 817       info->number_of_fast_used_elements_   += len - holes;
 818       info->number_of_fast_unused_elements_ += holes;
 819       break;
 820     }
 821     case EXTERNAL_PIXEL_ELEMENTS: {
 822       info->number_of_objects_with_fast_elements_++;
 823       ExternalPixelArray* e = ExternalPixelArray::cast(elements());
 824       info->number_of_fast_used_elements_ += e->length();
 825       break;
 826     }
 827     case DICTIONARY_ELEMENTS: {
 828       SeededNumberDictionary* dict = element_dictionary();
 829       info->number_of_slow_used_elements_ += dict->NumberOfElements();
 830       info->number_of_slow_unused_elements_ +=
 831           dict->Capacity() - dict->NumberOfElements();
 832       break;
 833     }
 834     default:
 835       UNREACHABLE();
 836       break;
 837   }
 838 }
 839
 840
 841 void JSObject::SpillInformation::Clear() {
 842   number_of_objects_ = 0;
 843   number_of_objects_with_fast_properties_ = 0;
 844   number_of_objects_with_fast_elements_ = 0;
 845   number_of_fast_used_fields_ = 0;
 846   number_of_fast_unused_fields_ = 0;
 847   number_of_slow_used_properties_ = 0;
 848   number_of_slow_unused_properties_ = 0;
 849   number_of_fast_used_elements_ = 0;
 850   number_of_fast_unused_elements_ = 0;
 851   number_of_slow_used_elements_ = 0;
 852   number_of_slow_unused_elements_ = 0;
 853 }
 854
 855 void JSObject::SpillInformation::Print() {
 856   PrintF("\n  JSObject Spill Statistics (#%d):\n", number_of_objects_);
 857
 858   PrintF("    - fast properties (#%d): %d (used) %d (unused)\n",
 859          number_of_objects_with_fast_properties_,
 860          number_of_fast_used_fields_, number_of_fast_unused_fields_);
 861
 862   PrintF("    - slow properties (#%d): %d (used) %d (unused)\n",
 863          number_of_objects_ - number_of_objects_with_fast_properties_,
 864          number_of_slow_used_properties_, number_of_slow_unused_properties_);
 865
 866   PrintF("    - fast elements (#%d): %d (used) %d (unused)\n",
 867          number_of_objects_with_fast_elements_,
 868          number_of_fast_used_elements_, number_of_fast_unused_elements_);
 869
 870   PrintF("    - slow elements (#%d): %d (used) %d (unused)\n",
 871          number_of_objects_ - number_of_objects_with_fast_elements_,
 872          number_of_slow_used_elements_, number_of_slow_unused_elements_);
 873
 874   PrintF("\n");
 875 }
 876
 877
 878 bool DescriptorArray::IsSortedNoDuplicates() {
 879   String* current_key = NULL;
 880   uint32_t current = 0;
 881   for (int i = 0; i < number_of_descriptors(); i++) {
 882     String* key = GetKey(i);
 883     if (key == current_key) {
 884       PrintDescriptors();
 885       return false;
 886     }
 887     current_key = key;
 888     uint32_t hash = GetKey(i)->Hash();
 889     if (hash < current) {
 890       PrintDescriptors();
 891       return false;
 892     }
 893     current = hash;
 894   }
 895   return true;
 896 }
 897
 898
 899 static bool CheckOneBackPointer(Map* current_map, Object* target) {
 900   return !target->IsMap() || Map::cast(target)->GetBackPointer() == current_map;
 901 }
 902
 903
 904 bool DescriptorArray::IsConsistentWithBackPointers(Map* current_map) {
 905   for (int i = 0; i < number_of_descriptors(); ++i) {
 906     switch (GetType(i)) {
 907       case MAP_TRANSITION:
 908       case CONSTANT_TRANSITION:
 909         if (!CheckOneBackPointer(current_map, GetValue(i))) {
 910           return false;
 911         }
 912         break;
 913       case ELEMENTS_TRANSITION: {
 914         Object* object = GetValue(i);
 915         if (!CheckOneBackPointer(current_map, object)) {
 916           return false;
 917         }
 918         if (object->IsFixedArray()) {
 919           FixedArray* array = FixedArray::cast(object);
 920           for (int i = 0; i < array->length(); ++i) {
 921             if (!CheckOneBackPointer(current_map, array->get(i))) {
 922               return false;
 923             }
 924           }
 925         }
 926         break;
 927       }
 928       case CALLBACKS: {
 929         Object* object = GetValue(i);
 930         if (object->IsAccessorPair()) {
 931           AccessorPair* accessors = AccessorPair::cast(object);
 932           if (!CheckOneBackPointer(current_map, accessors->getter())) {
 933             return false;
 934           }
 935           if (!CheckOneBackPointer(current_map, accessors->setter())) {
 936             return false;
 937           }
 938         }
 939         break;
 940       }
 941       case NORMAL:
 942       case FIELD:
 943       case CONSTANT_FUNCTION:
 944       case HANDLER:
 945       case INTERCEPTOR:
 946       case NULL_DESCRIPTOR:
 947         break;
 948     }
 949   }
 950   return true;
 951 }
 952
 953
 954 void JSFunctionResultCache::JSFunctionResultCacheVerify() {
 955   JSFunction::cast(get(kFactoryIndex))->Verify();
 956
 957   int size = Smi::cast(get(kCacheSizeIndex))->value();
 958   ASSERT(kEntriesIndex <= size);
 959   ASSERT(size <= length());
 960   ASSERT_EQ(0, size % kEntrySize);
 961
 962   int finger = Smi::cast(get(kFingerIndex))->value();
 963   ASSERT(kEntriesIndex <= finger);
 964   ASSERT((finger < size) || (finger == kEntriesIndex && finger == size));
 965   ASSERT_EQ(0, finger % kEntrySize);
 966
 967   if (FLAG_enable_slow_asserts) {
 968     for (int i = kEntriesIndex; i < size; i++) {
 969       ASSERT(!get(i)->IsTheHole());
 970       get(i)->Verify();
 971     }
 972     for (int i = size; i < length(); i++) {
 973       ASSERT(get(i)->IsTheHole());
 974       get(i)->Verify();
 975     }
 976   }
 977 }
 978
 979
 980 void NormalizedMapCache::NormalizedMapCacheVerify() {
 981   FixedArray::cast(this)->Verify();
 982   if (FLAG_enable_slow_asserts) {
 983     for (int i = 0; i < length(); i++) {
 984       Object* e = get(i);
 985       if (e->IsMap()) {
 986         Map::cast(e)->SharedMapVerify();
 987       } else {
 988         ASSERT(e->IsUndefined());
 989       }
 990     }
 991   }
 992 }
 993
 994
 995 void Map::ZapInstanceDescriptors() {
 996   DescriptorArray* descriptors = instance_descriptors();
 997   if (descriptors == GetHeap()->empty_descriptor_array()) return;
 998   FixedArray* contents = FixedArray::cast(
 999       descriptors->get(DescriptorArray::kContentArrayIndex));
1000   MemsetPointer(descriptors->data_start(),
1001                 GetHeap()->the_hole_value(),
1002                 descriptors->length());
1003   MemsetPointer(contents->data_start(),
1004                 GetHeap()->the_hole_value(),
1005                 contents->length());
1006 }
1007
1008
1009 void Map::ZapPrototypeTransitions() {
1010   FixedArray* proto_transitions = prototype_transitions();
1011   MemsetPointer(proto_transitions->data_start(),
1012                 GetHeap()->the_hole_value(),
1013                 proto_transitions->length());
1014 }
1015
1016
1017 #endif  // DEBUG
1018
1019 } }  // namespace v8::internal