reg_type_cache.cc revision b99b8d6cffe08d8c9d30175c936e5c88d3101802
1/* 2 * Copyright (C) 2012 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#include "reg_type_cache-inl.h" 18 19#include "base/casts.h" 20#include "class_linker-inl.h" 21#include "dex_file-inl.h" 22#include "mirror/class-inl.h" 23#include "mirror/object-inl.h" 24#include "object_utils.h" 25 26namespace art { 27namespace verifier { 28 29bool RegTypeCache::primitive_initialized_ = false; 30uint16_t RegTypeCache::primitive_count_ = 0; 31PreciseConstType* RegTypeCache::small_precise_constants_[kMaxSmallConstant - kMinSmallConstant + 1]; 32 33static bool MatchingPrecisionForClass(RegType* entry, bool precise) 34 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) { 35 if (entry->IsPreciseReference() == precise) { 36 // We were or weren't looking for a precise reference and we found what we need. 37 return true; 38 } else { 39 if (!precise && entry->GetClass()->CannotBeAssignedFromOtherTypes()) { 40 // We weren't looking for a precise reference, as we're looking up based on a descriptor, but 41 // we found a matching entry based on the descriptor. Return the precise entry in that case. 42 return true; 43 } 44 return false; 45 } 46} 47 48void RegTypeCache::FillPrimitiveAndSmallConstantTypes() { 49 entries_.push_back(UndefinedType::GetInstance()); 50 entries_.push_back(ConflictType::GetInstance()); 51 entries_.push_back(BooleanType::GetInstance()); 52 entries_.push_back(ByteType::GetInstance()); 53 entries_.push_back(ShortType::GetInstance()); 54 entries_.push_back(CharType::GetInstance()); 55 entries_.push_back(IntegerType::GetInstance()); 56 entries_.push_back(LongLoType::GetInstance()); 57 entries_.push_back(LongHiType::GetInstance()); 58 entries_.push_back(FloatType::GetInstance()); 59 entries_.push_back(DoubleLoType::GetInstance()); 60 entries_.push_back(DoubleHiType::GetInstance()); 61 for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) { 62 int32_t i = value - kMinSmallConstant; 63 DCHECK_EQ(entries_.size(), small_precise_constants_[i]->GetId()); 64 entries_.push_back(small_precise_constants_[i]); 65 } 66 DCHECK_EQ(entries_.size(), primitive_count_); 67} 68 69const RegType& RegTypeCache::FromDescriptor(mirror::ClassLoader* loader, const char* descriptor, 70 bool precise) { 71 DCHECK(RegTypeCache::primitive_initialized_); 72 if (descriptor[1] == '\0') { 73 switch (descriptor[0]) { 74 case 'Z': 75 return Boolean(); 76 case 'B': 77 return Byte(); 78 case 'S': 79 return Short(); 80 case 'C': 81 return Char(); 82 case 'I': 83 return Integer(); 84 case 'J': 85 return LongLo(); 86 case 'F': 87 return Float(); 88 case 'D': 89 return DoubleLo(); 90 case 'V': // For void types, conflict types. 91 default: 92 return Conflict(); 93 } 94 } else if (descriptor[0] == 'L' || descriptor[0] == '[') { 95 return From(loader, descriptor, precise); 96 } else { 97 return Conflict(); 98 } 99}; 100 101const RegType& RegTypeCache::RegTypeFromPrimitiveType(Primitive::Type prim_type) const { 102 CHECK(RegTypeCache::primitive_initialized_); 103 switch (prim_type) { 104 case Primitive::kPrimBoolean: 105 return *BooleanType::GetInstance(); 106 case Primitive::kPrimByte: 107 return *ByteType::GetInstance(); 108 case Primitive::kPrimShort: 109 return *ShortType::GetInstance(); 110 case Primitive::kPrimChar: 111 return *CharType::GetInstance(); 112 case Primitive::kPrimInt: 113 return *IntegerType::GetInstance(); 114 case Primitive::kPrimLong: 115 return *LongLoType::GetInstance(); 116 case Primitive::kPrimFloat: 117 return *FloatType::GetInstance(); 118 case Primitive::kPrimDouble: 119 return *DoubleLoType::GetInstance(); 120 case Primitive::kPrimVoid: 121 default: 122 return *ConflictType::GetInstance(); 123 } 124} 125 126bool RegTypeCache::MatchDescriptor(size_t idx, const char* descriptor, bool precise) { 127 RegType* entry = entries_[idx]; 128 if (entry->descriptor_ != descriptor) { 129 return false; 130 } 131 if (entry->HasClass()) { 132 return MatchingPrecisionForClass(entry, precise); 133 } 134 // There is no notion of precise unresolved references, the precise information is just dropped 135 // on the floor. 136 DCHECK(entry->IsUnresolvedReference()); 137 return true; 138} 139 140mirror::Class* RegTypeCache::ResolveClass(const char* descriptor, mirror::ClassLoader* loader) { 141 // Class was not found, must create new type. 142 // Try resolving class 143 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 144 Thread* self = Thread::Current(); 145 StackHandleScope<1> hs(self); 146 Handle<mirror::ClassLoader> class_loader(hs.NewHandle(loader)); 147 mirror::Class* klass = NULL; 148 if (can_load_classes_) { 149 klass = class_linker->FindClass(self, descriptor, class_loader); 150 } else { 151 klass = class_linker->LookupClass(descriptor, loader); 152 if (klass != nullptr && !klass->IsLoaded()) { 153 // We found the class but without it being loaded its not safe for use. 154 klass = nullptr; 155 } 156 } 157 return klass; 158} 159 160const RegType& RegTypeCache::From(mirror::ClassLoader* loader, const char* descriptor, 161 bool precise) { 162 // Try looking up the class in the cache first. 163 for (size_t i = primitive_count_; i < entries_.size(); i++) { 164 if (MatchDescriptor(i, descriptor, precise)) { 165 return *(entries_[i]); 166 } 167 } 168 // Class not found in the cache, will create a new type for that. 169 // Try resolving class. 170 mirror::Class* klass = ResolveClass(descriptor, loader); 171 if (klass != NULL) { 172 // Class resolved, first look for the class in the list of entries 173 // Class was not found, must create new type. 174 // To pass the verification, the type should be imprecise, 175 // instantiable or an interface with the precise type set to false. 176 DCHECK(!precise || klass->IsInstantiable()); 177 // Create a precise type if: 178 // 1- Class is final and NOT an interface. a precise interface is meaningless !! 179 // 2- Precise Flag passed as true. 180 RegType* entry; 181 // Create an imprecise type if we can't tell for a fact that it is precise. 182 if (klass->CannotBeAssignedFromOtherTypes() || precise) { 183 DCHECK(!(klass->IsAbstract()) || klass->IsArrayClass()); 184 DCHECK(!klass->IsInterface()); 185 entry = new PreciseReferenceType(klass, descriptor, entries_.size()); 186 } else { 187 entry = new ReferenceType(klass, descriptor, entries_.size()); 188 } 189 AddEntry(entry); 190 return *entry; 191 } else { // Class not resolved. 192 // We tried loading the class and failed, this might get an exception raised 193 // so we want to clear it before we go on. 194 if (can_load_classes_) { 195 DCHECK(Thread::Current()->IsExceptionPending()); 196 Thread::Current()->ClearException(); 197 } else { 198 DCHECK(!Thread::Current()->IsExceptionPending()); 199 } 200 if (IsValidDescriptor(descriptor)) { 201 RegType* entry = new UnresolvedReferenceType(descriptor, entries_.size()); 202 AddEntry(entry); 203 return *entry; 204 } else { 205 // The descriptor is broken return the unknown type as there's nothing sensible that 206 // could be done at runtime 207 return Conflict(); 208 } 209 } 210} 211 212const RegType& RegTypeCache::FromClass(const char* descriptor, mirror::Class* klass, bool precise) { 213 DCHECK(klass != nullptr && !klass->IsErroneous()); 214 if (klass->IsPrimitive()) { 215 // Note: precise isn't used for primitive classes. A char is assignable to an int. All 216 // primitive classes are final. 217 return RegTypeFromPrimitiveType(klass->GetPrimitiveType()); 218 } else { 219 // Look for the reference in the list of entries to have. 220 for (size_t i = primitive_count_; i < entries_.size(); i++) { 221 RegType* cur_entry = entries_[i]; 222 if (cur_entry->klass_ == klass && MatchingPrecisionForClass(cur_entry, precise)) { 223 return *cur_entry; 224 } 225 } 226 // No reference to the class was found, create new reference. 227 RegType* entry; 228 if (precise) { 229 entry = new PreciseReferenceType(klass, descriptor, entries_.size()); 230 } else { 231 entry = new ReferenceType(klass, descriptor, entries_.size()); 232 } 233 AddEntry(entry); 234 return *entry; 235 } 236} 237 238RegTypeCache::RegTypeCache(bool can_load_classes) : can_load_classes_(can_load_classes) { 239 if (kIsDebugBuild && can_load_classes) { 240 Thread::Current()->AssertThreadSuspensionIsAllowable(); 241 } 242 entries_.reserve(64); 243 FillPrimitiveAndSmallConstantTypes(); 244} 245 246RegTypeCache::~RegTypeCache() { 247 CHECK_LE(primitive_count_, entries_.size()); 248 // Delete only the non primitive types. 249 if (entries_.size() == kNumPrimitivesAndSmallConstants) { 250 // All entries are from the global pool, nothing to delete. 251 return; 252 } 253 std::vector<RegType*>::iterator non_primitive_begin = entries_.begin(); 254 std::advance(non_primitive_begin, kNumPrimitivesAndSmallConstants); 255 STLDeleteContainerPointers(non_primitive_begin, entries_.end()); 256} 257 258void RegTypeCache::ShutDown() { 259 if (RegTypeCache::primitive_initialized_) { 260 UndefinedType::Destroy(); 261 ConflictType::Destroy(); 262 BooleanType::Destroy(); 263 ByteType::Destroy(); 264 ShortType::Destroy(); 265 CharType::Destroy(); 266 IntegerType::Destroy(); 267 LongLoType::Destroy(); 268 LongHiType::Destroy(); 269 FloatType::Destroy(); 270 DoubleLoType::Destroy(); 271 DoubleHiType::Destroy(); 272 for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) { 273 PreciseConstType* type = small_precise_constants_[value - kMinSmallConstant]; 274 delete type; 275 small_precise_constants_[value - kMinSmallConstant] = nullptr; 276 } 277 RegTypeCache::primitive_initialized_ = false; 278 RegTypeCache::primitive_count_ = 0; 279 } 280} 281 282template <class Type> 283Type* RegTypeCache::CreatePrimitiveTypeInstance(const std::string& descriptor) { 284 mirror::Class* klass = NULL; 285 // Try loading the class from linker. 286 if (!descriptor.empty()) { 287 klass = art::Runtime::Current()->GetClassLinker()->FindSystemClass(Thread::Current(), 288 descriptor.c_str()); 289 } 290 Type* entry = Type::CreateInstance(klass, descriptor, RegTypeCache::primitive_count_); 291 RegTypeCache::primitive_count_++; 292 return entry; 293} 294 295void RegTypeCache::CreatePrimitiveAndSmallConstantTypes() { 296 CreatePrimitiveTypeInstance<UndefinedType>(""); 297 CreatePrimitiveTypeInstance<ConflictType>(""); 298 CreatePrimitiveTypeInstance<BooleanType>("Z"); 299 CreatePrimitiveTypeInstance<ByteType>("B"); 300 CreatePrimitiveTypeInstance<ShortType>("S"); 301 CreatePrimitiveTypeInstance<CharType>("C"); 302 CreatePrimitiveTypeInstance<IntegerType>("I"); 303 CreatePrimitiveTypeInstance<LongLoType>("J"); 304 CreatePrimitiveTypeInstance<LongHiType>("J"); 305 CreatePrimitiveTypeInstance<FloatType>("F"); 306 CreatePrimitiveTypeInstance<DoubleLoType>("D"); 307 CreatePrimitiveTypeInstance<DoubleHiType>("D"); 308 for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) { 309 PreciseConstType* type = new PreciseConstType(value, primitive_count_); 310 small_precise_constants_[value - kMinSmallConstant] = type; 311 primitive_count_++; 312 } 313} 314 315const RegType& RegTypeCache::FromUnresolvedMerge(const RegType& left, const RegType& right) { 316 std::set<uint16_t> types; 317 if (left.IsUnresolvedMergedReference()) { 318 RegType& non_const(const_cast<RegType&>(left)); 319 types = (down_cast<UnresolvedMergedType*>(&non_const))->GetMergedTypes(); 320 } else { 321 types.insert(left.GetId()); 322 } 323 if (right.IsUnresolvedMergedReference()) { 324 RegType& non_const(const_cast<RegType&>(right)); 325 std::set<uint16_t> right_types = (down_cast<UnresolvedMergedType*>(&non_const))->GetMergedTypes(); 326 types.insert(right_types.begin(), right_types.end()); 327 } else { 328 types.insert(right.GetId()); 329 } 330 // Check if entry already exists. 331 for (size_t i = primitive_count_; i < entries_.size(); i++) { 332 RegType* cur_entry = entries_[i]; 333 if (cur_entry->IsUnresolvedMergedReference()) { 334 std::set<uint16_t> cur_entry_types = 335 (down_cast<UnresolvedMergedType*>(cur_entry))->GetMergedTypes(); 336 if (cur_entry_types == types) { 337 return *cur_entry; 338 } 339 } 340 } 341 // Create entry. 342 RegType* entry = new UnresolvedMergedType(left.GetId(), right.GetId(), this, entries_.size()); 343 AddEntry(entry); 344 if (kIsDebugBuild) { 345 UnresolvedMergedType* tmp_entry = down_cast<UnresolvedMergedType*>(entry); 346 std::set<uint16_t> check_types = tmp_entry->GetMergedTypes(); 347 CHECK(check_types == types); 348 } 349 return *entry; 350} 351 352const RegType& RegTypeCache::FromUnresolvedSuperClass(const RegType& child) { 353 // Check if entry already exists. 354 for (size_t i = primitive_count_; i < entries_.size(); i++) { 355 RegType* cur_entry = entries_[i]; 356 if (cur_entry->IsUnresolvedSuperClass()) { 357 UnresolvedSuperClass* tmp_entry = 358 down_cast<UnresolvedSuperClass*>(cur_entry); 359 uint16_t unresolved_super_child_id = 360 tmp_entry->GetUnresolvedSuperClassChildId(); 361 if (unresolved_super_child_id == child.GetId()) { 362 return *cur_entry; 363 } 364 } 365 } 366 RegType* entry = new UnresolvedSuperClass(child.GetId(), this, entries_.size()); 367 AddEntry(entry); 368 return *entry; 369} 370 371const UninitializedType& RegTypeCache::Uninitialized(const RegType& type, uint32_t allocation_pc) { 372 UninitializedType* entry = NULL; 373 const std::string& descriptor(type.GetDescriptor()); 374 if (type.IsUnresolvedTypes()) { 375 for (size_t i = primitive_count_; i < entries_.size(); i++) { 376 RegType* cur_entry = entries_[i]; 377 if (cur_entry->IsUnresolvedAndUninitializedReference() && 378 down_cast<UnresolvedUninitializedRefType*>(cur_entry)->GetAllocationPc() == allocation_pc && 379 (cur_entry->GetDescriptor() == descriptor)) { 380 return *down_cast<UnresolvedUninitializedRefType*>(cur_entry); 381 } 382 } 383 entry = new UnresolvedUninitializedRefType(descriptor, allocation_pc, entries_.size()); 384 } else { 385 mirror::Class* klass = type.GetClass(); 386 for (size_t i = primitive_count_; i < entries_.size(); i++) { 387 RegType* cur_entry = entries_[i]; 388 if (cur_entry->IsUninitializedReference() && 389 down_cast<UninitializedReferenceType*>(cur_entry) 390 ->GetAllocationPc() == allocation_pc && 391 cur_entry->GetClass() == klass) { 392 return *down_cast<UninitializedReferenceType*>(cur_entry); 393 } 394 } 395 entry = new UninitializedReferenceType(klass, descriptor, allocation_pc, entries_.size()); 396 } 397 AddEntry(entry); 398 return *entry; 399} 400 401const RegType& RegTypeCache::FromUninitialized(const RegType& uninit_type) { 402 RegType* entry; 403 404 if (uninit_type.IsUnresolvedTypes()) { 405 const std::string& descriptor(uninit_type.GetDescriptor()); 406 for (size_t i = primitive_count_; i < entries_.size(); i++) { 407 RegType* cur_entry = entries_[i]; 408 if (cur_entry->IsUnresolvedReference() && 409 cur_entry->GetDescriptor() == descriptor) { 410 return *cur_entry; 411 } 412 } 413 entry = new UnresolvedReferenceType(descriptor.c_str(), entries_.size()); 414 } else { 415 mirror::Class* klass = uninit_type.GetClass(); 416 if (uninit_type.IsUninitializedThisReference() && !klass->IsFinal()) { 417 // For uninitialized "this reference" look for reference types that are not precise. 418 for (size_t i = primitive_count_; i < entries_.size(); i++) { 419 RegType* cur_entry = entries_[i]; 420 if (cur_entry->IsReference() && cur_entry->GetClass() == klass) { 421 return *cur_entry; 422 } 423 } 424 entry = new ReferenceType(klass, "", entries_.size()); 425 } else if (klass->IsInstantiable()) { 426 // We're uninitialized because of allocation, look or create a precise type as allocations 427 // may only create objects of that type. 428 for (size_t i = primitive_count_; i < entries_.size(); i++) { 429 RegType* cur_entry = entries_[i]; 430 if (cur_entry->IsPreciseReference() && cur_entry->GetClass() == klass) { 431 return *cur_entry; 432 } 433 } 434 entry = new PreciseReferenceType(klass, uninit_type.GetDescriptor(), entries_.size()); 435 } else { 436 return Conflict(); 437 } 438 } 439 AddEntry(entry); 440 return *entry; 441} 442 443const ImpreciseConstType& RegTypeCache::ByteConstant() { 444 const ConstantType& result = FromCat1Const(std::numeric_limits<jbyte>::min(), false); 445 DCHECK(result.IsImpreciseConstant()); 446 return *down_cast<const ImpreciseConstType*>(&result); 447} 448 449const ImpreciseConstType& RegTypeCache::CharConstant() { 450 int32_t jchar_max = static_cast<int32_t>(std::numeric_limits<jchar>::max()); 451 const ConstantType& result = FromCat1Const(jchar_max, false); 452 DCHECK(result.IsImpreciseConstant()); 453 return *down_cast<const ImpreciseConstType*>(&result); 454} 455 456const ImpreciseConstType& RegTypeCache::ShortConstant() { 457 const ConstantType& result = FromCat1Const(std::numeric_limits<jshort>::min(), false); 458 DCHECK(result.IsImpreciseConstant()); 459 return *down_cast<const ImpreciseConstType*>(&result); 460} 461 462const ImpreciseConstType& RegTypeCache::IntConstant() { 463 const ConstantType& result = FromCat1Const(std::numeric_limits<jint>::max(), false); 464 DCHECK(result.IsImpreciseConstant()); 465 return *down_cast<const ImpreciseConstType*>(&result); 466} 467 468const ImpreciseConstType& RegTypeCache::PosByteConstant() { 469 const ConstantType& result = FromCat1Const(std::numeric_limits<jbyte>::max(), false); 470 DCHECK(result.IsImpreciseConstant()); 471 return *down_cast<const ImpreciseConstType*>(&result); 472} 473 474const ImpreciseConstType& RegTypeCache::PosShortConstant() { 475 const ConstantType& result = FromCat1Const(std::numeric_limits<jshort>::max(), false); 476 DCHECK(result.IsImpreciseConstant()); 477 return *down_cast<const ImpreciseConstType*>(&result); 478} 479 480const UninitializedType& RegTypeCache::UninitializedThisArgument(const RegType& type) { 481 UninitializedType* entry; 482 const std::string& descriptor(type.GetDescriptor()); 483 if (type.IsUnresolvedTypes()) { 484 for (size_t i = primitive_count_; i < entries_.size(); i++) { 485 RegType* cur_entry = entries_[i]; 486 if (cur_entry->IsUnresolvedAndUninitializedThisReference() && 487 cur_entry->GetDescriptor() == descriptor) { 488 return *down_cast<UninitializedType*>(cur_entry); 489 } 490 } 491 entry = new UnresolvedUninitializedThisRefType(descriptor, entries_.size()); 492 } else { 493 mirror::Class* klass = type.GetClass(); 494 for (size_t i = primitive_count_; i < entries_.size(); i++) { 495 RegType* cur_entry = entries_[i]; 496 if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) { 497 return *down_cast<UninitializedType*>(cur_entry); 498 } 499 } 500 entry = new UninitializedThisReferenceType(klass, descriptor, entries_.size()); 501 } 502 AddEntry(entry); 503 return *entry; 504} 505 506const ConstantType& RegTypeCache::FromCat1NonSmallConstant(int32_t value, bool precise) { 507 for (size_t i = primitive_count_; i < entries_.size(); i++) { 508 RegType* cur_entry = entries_[i]; 509 if (cur_entry->klass_ == NULL && cur_entry->IsConstant() && 510 cur_entry->IsPreciseConstant() == precise && 511 (down_cast<ConstantType*>(cur_entry))->ConstantValue() == value) { 512 return *down_cast<ConstantType*>(cur_entry); 513 } 514 } 515 ConstantType* entry; 516 if (precise) { 517 entry = new PreciseConstType(value, entries_.size()); 518 } else { 519 entry = new ImpreciseConstType(value, entries_.size()); 520 } 521 AddEntry(entry); 522 return *entry; 523} 524 525const ConstantType& RegTypeCache::FromCat2ConstLo(int32_t value, bool precise) { 526 for (size_t i = primitive_count_; i < entries_.size(); i++) { 527 RegType* cur_entry = entries_[i]; 528 if (cur_entry->IsConstantLo() && (cur_entry->IsPrecise() == precise) && 529 (down_cast<ConstantType*>(cur_entry))->ConstantValueLo() == value) { 530 return *down_cast<ConstantType*>(cur_entry); 531 } 532 } 533 ConstantType* entry; 534 if (precise) { 535 entry = new PreciseConstLoType(value, entries_.size()); 536 } else { 537 entry = new ImpreciseConstLoType(value, entries_.size()); 538 } 539 AddEntry(entry); 540 return *entry; 541} 542 543const ConstantType& RegTypeCache::FromCat2ConstHi(int32_t value, bool precise) { 544 for (size_t i = primitive_count_; i < entries_.size(); i++) { 545 RegType* cur_entry = entries_[i]; 546 if (cur_entry->IsConstantHi() && (cur_entry->IsPrecise() == precise) && 547 (down_cast<ConstantType*>(cur_entry))->ConstantValueHi() == value) { 548 return *down_cast<ConstantType*>(cur_entry); 549 } 550 } 551 ConstantType* entry; 552 if (precise) { 553 entry = new PreciseConstHiType(value, entries_.size()); 554 } else { 555 entry = new ImpreciseConstHiType(value, entries_.size()); 556 } 557 AddEntry(entry); 558 return *entry; 559} 560 561const RegType& RegTypeCache::GetComponentType(const RegType& array, mirror::ClassLoader* loader) { 562 if (!array.IsArrayTypes()) { 563 return Conflict(); 564 } else if (array.IsUnresolvedTypes()) { 565 const std::string& descriptor(array.GetDescriptor()); 566 const std::string component(descriptor.substr(1, descriptor.size() - 1)); 567 return FromDescriptor(loader, component.c_str(), false); 568 } else { 569 mirror::Class* klass = array.GetClass()->GetComponentType(); 570 if (klass->IsErroneous()) { 571 // Arrays may have erroneous component types, use unresolved in that case. 572 // We assume that the primitive classes are not erroneous, so we know it is a 573 // reference type. 574 return FromDescriptor(loader, klass->GetDescriptor().c_str(), false); 575 } else { 576 return FromClass(klass->GetDescriptor().c_str(), klass, 577 klass->CannotBeAssignedFromOtherTypes()); 578 } 579 } 580} 581 582void RegTypeCache::Dump(std::ostream& os) { 583 for (size_t i = 0; i < entries_.size(); i++) { 584 RegType* cur_entry = entries_[i]; 585 if (cur_entry != NULL) { 586 os << i << ": " << cur_entry->Dump() << "\n"; 587 } 588 } 589} 590 591void RegTypeCache::VisitRoots(RootCallback* callback, void* arg) { 592 for (RegType* entry : entries_) { 593 entry->VisitRoots(callback, arg); 594 } 595} 596 597void RegTypeCache::AddEntry(RegType* new_entry) { 598 entries_.push_back(new_entry); 599} 600 601} // namespace verifier 602} // namespace art 603