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 "reg_type-inl.h"
25
26namespace art {
27namespace verifier {
28
29bool RegTypeCache::primitive_initialized_ = false;
30uint16_t RegTypeCache::primitive_count_ = 0;
31const PreciseConstType* RegTypeCache::small_precise_constants_[kMaxSmallConstant - kMinSmallConstant + 1];
32
33static bool MatchingPrecisionForClass(const 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  DCHECK(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 StringPiece& descriptor, bool precise) {
127  const RegType* entry = entries_[idx];
128  if (descriptor != entry->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 = nullptr;
148  if (can_load_classes_) {
149    klass = class_linker->FindClass(self, descriptor, class_loader);
150  } else {
151    klass = class_linker->LookupClass(self, descriptor, ComputeModifiedUtf8Hash(descriptor),
152                                      loader);
153    if (klass != nullptr && !klass->IsLoaded()) {
154      // We found the class but without it being loaded its not safe for use.
155      klass = nullptr;
156    }
157  }
158  return klass;
159}
160
161const RegType& RegTypeCache::From(mirror::ClassLoader* loader, const char* descriptor,
162                                  bool precise) {
163  // Try looking up the class in the cache first. We use a StringPiece to avoid continual strlen
164  // operations on the descriptor.
165  StringPiece descriptor_sp(descriptor);
166  for (size_t i = primitive_count_; i < entries_.size(); i++) {
167    if (MatchDescriptor(i, descriptor_sp, precise)) {
168      return *(entries_[i]);
169    }
170  }
171  // Class not found in the cache, will create a new type for that.
172  // Try resolving class.
173  mirror::Class* klass = ResolveClass(descriptor, loader);
174  if (klass != nullptr) {
175    // Class resolved, first look for the class in the list of entries
176    // Class was not found, must create new type.
177    // To pass the verification, the type should be imprecise,
178    // instantiable or an interface with the precise type set to false.
179    DCHECK(!precise || klass->IsInstantiable());
180    // Create a precise type if:
181    // 1- Class is final and NOT an interface. a precise interface is meaningless !!
182    // 2- Precise Flag passed as true.
183    RegType* entry;
184    // Create an imprecise type if we can't tell for a fact that it is precise.
185    if (klass->CannotBeAssignedFromOtherTypes() || precise) {
186      DCHECK(!(klass->IsAbstract()) || klass->IsArrayClass());
187      DCHECK(!klass->IsInterface());
188      entry = new PreciseReferenceType(klass, descriptor_sp.as_string(), entries_.size());
189    } else {
190      entry = new ReferenceType(klass, descriptor_sp.as_string(), entries_.size());
191    }
192    AddEntry(entry);
193    return *entry;
194  } else {  // Class not resolved.
195    // We tried loading the class and failed, this might get an exception raised
196    // so we want to clear it before we go on.
197    if (can_load_classes_) {
198      DCHECK(Thread::Current()->IsExceptionPending());
199      Thread::Current()->ClearException();
200    } else {
201      DCHECK(!Thread::Current()->IsExceptionPending());
202    }
203    if (IsValidDescriptor(descriptor)) {
204      RegType* entry = new UnresolvedReferenceType(descriptor_sp.as_string(), entries_.size());
205      AddEntry(entry);
206      return *entry;
207    } else {
208      // The descriptor is broken return the unknown type as there's nothing sensible that
209      // could be done at runtime
210      return Conflict();
211    }
212  }
213}
214
215const RegType& RegTypeCache::FromClass(const char* descriptor, mirror::Class* klass, bool precise) {
216  DCHECK(klass != nullptr);
217  if (klass->IsPrimitive()) {
218    // Note: precise isn't used for primitive classes. A char is assignable to an int. All
219    // primitive classes are final.
220    return RegTypeFromPrimitiveType(klass->GetPrimitiveType());
221  } else {
222    // Look for the reference in the list of entries to have.
223    for (size_t i = primitive_count_; i < entries_.size(); i++) {
224      const RegType* cur_entry = entries_[i];
225      if (cur_entry->klass_.Read() == klass && MatchingPrecisionForClass(cur_entry, precise)) {
226        return *cur_entry;
227      }
228    }
229    // No reference to the class was found, create new reference.
230    RegType* entry;
231    if (precise) {
232      entry = new PreciseReferenceType(klass, descriptor, entries_.size());
233    } else {
234      entry = new ReferenceType(klass, descriptor, entries_.size());
235    }
236    AddEntry(entry);
237    return *entry;
238  }
239}
240
241RegTypeCache::RegTypeCache(bool can_load_classes) : can_load_classes_(can_load_classes) {
242  if (kIsDebugBuild) {
243    Thread::Current()->AssertThreadSuspensionIsAllowable(gAborting == 0);
244  }
245  entries_.reserve(64);
246  FillPrimitiveAndSmallConstantTypes();
247}
248
249RegTypeCache::~RegTypeCache() {
250  CHECK_LE(primitive_count_, entries_.size());
251  // Delete only the non primitive types.
252  if (entries_.size() == kNumPrimitivesAndSmallConstants) {
253    // All entries are from the global pool, nothing to delete.
254    return;
255  }
256  std::vector<const RegType*>::iterator non_primitive_begin = entries_.begin();
257  std::advance(non_primitive_begin, kNumPrimitivesAndSmallConstants);
258  STLDeleteContainerPointers(non_primitive_begin, entries_.end());
259}
260
261void RegTypeCache::ShutDown() {
262  if (RegTypeCache::primitive_initialized_) {
263    UndefinedType::Destroy();
264    ConflictType::Destroy();
265    BooleanType::Destroy();
266    ByteType::Destroy();
267    ShortType::Destroy();
268    CharType::Destroy();
269    IntegerType::Destroy();
270    LongLoType::Destroy();
271    LongHiType::Destroy();
272    FloatType::Destroy();
273    DoubleLoType::Destroy();
274    DoubleHiType::Destroy();
275    for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) {
276      const PreciseConstType* type = small_precise_constants_[value - kMinSmallConstant];
277      delete type;
278      small_precise_constants_[value - kMinSmallConstant] = nullptr;
279    }
280    RegTypeCache::primitive_initialized_ = false;
281    RegTypeCache::primitive_count_ = 0;
282  }
283}
284
285template <class Type>
286const Type* RegTypeCache::CreatePrimitiveTypeInstance(const std::string& descriptor) {
287  mirror::Class* klass = nullptr;
288  // Try loading the class from linker.
289  if (!descriptor.empty()) {
290    klass = art::Runtime::Current()->GetClassLinker()->FindSystemClass(Thread::Current(),
291                                                                       descriptor.c_str());
292    DCHECK(klass != nullptr);
293  }
294  const Type* entry = Type::CreateInstance(klass, descriptor, RegTypeCache::primitive_count_);
295  RegTypeCache::primitive_count_++;
296  return entry;
297}
298
299void RegTypeCache::CreatePrimitiveAndSmallConstantTypes() {
300  CreatePrimitiveTypeInstance<UndefinedType>("");
301  CreatePrimitiveTypeInstance<ConflictType>("");
302  CreatePrimitiveTypeInstance<BooleanType>("Z");
303  CreatePrimitiveTypeInstance<ByteType>("B");
304  CreatePrimitiveTypeInstance<ShortType>("S");
305  CreatePrimitiveTypeInstance<CharType>("C");
306  CreatePrimitiveTypeInstance<IntegerType>("I");
307  CreatePrimitiveTypeInstance<LongLoType>("J");
308  CreatePrimitiveTypeInstance<LongHiType>("J");
309  CreatePrimitiveTypeInstance<FloatType>("F");
310  CreatePrimitiveTypeInstance<DoubleLoType>("D");
311  CreatePrimitiveTypeInstance<DoubleHiType>("D");
312  for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) {
313    PreciseConstType* type = new PreciseConstType(value, primitive_count_);
314    small_precise_constants_[value - kMinSmallConstant] = type;
315    primitive_count_++;
316  }
317}
318
319const RegType& RegTypeCache::FromUnresolvedMerge(const RegType& left, const RegType& right) {
320  BitVector types(1,                                    // Allocate at least a word.
321                  true,                                 // Is expandable.
322                  Allocator::GetMallocAllocator());     // TODO: Arenas in the verifier.
323  const RegType* left_resolved;
324  if (left.IsUnresolvedMergedReference()) {
325    const UnresolvedMergedType* left_merge = down_cast<const UnresolvedMergedType*>(&left);
326    types.Copy(&left_merge->GetUnresolvedTypes());
327    left_resolved = &left_merge->GetResolvedPart();
328  } else if (left.IsUnresolvedTypes()) {
329    types.SetBit(left.GetId());
330    left_resolved = &Zero();
331  } else {
332    left_resolved = &left;
333  }
334
335  const RegType* right_resolved;
336  if (right.IsUnresolvedMergedReference()) {
337    const UnresolvedMergedType* right_merge = down_cast<const UnresolvedMergedType*>(&right);
338    types.Union(&right_merge->GetUnresolvedTypes());
339    right_resolved = &right_merge->GetResolvedPart();
340  } else if (right.IsUnresolvedTypes()) {
341    types.SetBit(right.GetId());
342    right_resolved = &Zero();
343  } else {
344    right_resolved = &right;
345  }
346
347  // Merge the resolved parts. Left and right might be equal, so use SafeMerge.
348  const RegType& resolved_parts_merged = left_resolved->SafeMerge(*right_resolved, this);
349  // If we get a conflict here, the merge result is a conflict, not an unresolved merge type.
350  if (resolved_parts_merged.IsConflict()) {
351    return Conflict();
352  }
353
354  // Check if entry already exists.
355  for (size_t i = primitive_count_; i < entries_.size(); i++) {
356    const RegType* cur_entry = entries_[i];
357    if (cur_entry->IsUnresolvedMergedReference()) {
358      const UnresolvedMergedType* cmp_type = down_cast<const UnresolvedMergedType*>(cur_entry);
359      const RegType& resolved_part = cmp_type->GetResolvedPart();
360      const BitVector& unresolved_part = cmp_type->GetUnresolvedTypes();
361      // Use SameBitsSet. "types" is expandable to allow merging in the components, but the
362      // BitVector in the final RegType will be made non-expandable.
363      if (&resolved_part == &resolved_parts_merged &&
364              types.SameBitsSet(&unresolved_part)) {
365        return *cur_entry;
366      }
367    }
368  }
369
370  // Create entry.
371  RegType* entry = new UnresolvedMergedType(resolved_parts_merged,
372                                            types,
373                                            this,
374                                            entries_.size());
375  AddEntry(entry);
376  return *entry;
377}
378
379const RegType& RegTypeCache::FromUnresolvedSuperClass(const RegType& child) {
380  // Check if entry already exists.
381  for (size_t i = primitive_count_; i < entries_.size(); i++) {
382    const RegType* cur_entry = entries_[i];
383    if (cur_entry->IsUnresolvedSuperClass()) {
384      const UnresolvedSuperClass* tmp_entry =
385          down_cast<const UnresolvedSuperClass*>(cur_entry);
386      uint16_t unresolved_super_child_id =
387          tmp_entry->GetUnresolvedSuperClassChildId();
388      if (unresolved_super_child_id == child.GetId()) {
389        return *cur_entry;
390      }
391    }
392  }
393  RegType* entry = new UnresolvedSuperClass(child.GetId(), this, entries_.size());
394  AddEntry(entry);
395  return *entry;
396}
397
398const UninitializedType& RegTypeCache::Uninitialized(const RegType& type, uint32_t allocation_pc) {
399  UninitializedType* entry = nullptr;
400  const std::string& descriptor(type.GetDescriptor());
401  if (type.IsUnresolvedTypes()) {
402    for (size_t i = primitive_count_; i < entries_.size(); i++) {
403      const RegType* cur_entry = entries_[i];
404      if (cur_entry->IsUnresolvedAndUninitializedReference() &&
405          down_cast<const UnresolvedUninitializedRefType*>(cur_entry)->GetAllocationPc()
406              == allocation_pc &&
407          (cur_entry->GetDescriptor() == descriptor)) {
408        return *down_cast<const UnresolvedUninitializedRefType*>(cur_entry);
409      }
410    }
411    entry = new UnresolvedUninitializedRefType(descriptor, allocation_pc, entries_.size());
412  } else {
413    mirror::Class* klass = type.GetClass();
414    for (size_t i = primitive_count_; i < entries_.size(); i++) {
415      const RegType* cur_entry = entries_[i];
416      if (cur_entry->IsUninitializedReference() &&
417          down_cast<const UninitializedReferenceType*>(cur_entry)
418              ->GetAllocationPc() == allocation_pc &&
419          cur_entry->GetClass() == klass) {
420        return *down_cast<const UninitializedReferenceType*>(cur_entry);
421      }
422    }
423    entry = new UninitializedReferenceType(klass, descriptor, allocation_pc, entries_.size());
424  }
425  AddEntry(entry);
426  return *entry;
427}
428
429const RegType& RegTypeCache::FromUninitialized(const RegType& uninit_type) {
430  RegType* entry;
431
432  if (uninit_type.IsUnresolvedTypes()) {
433    const std::string& descriptor(uninit_type.GetDescriptor());
434    for (size_t i = primitive_count_; i < entries_.size(); i++) {
435      const RegType* cur_entry = entries_[i];
436      if (cur_entry->IsUnresolvedReference() &&
437          cur_entry->GetDescriptor() == descriptor) {
438        return *cur_entry;
439      }
440    }
441    entry = new UnresolvedReferenceType(descriptor, entries_.size());
442  } else {
443    mirror::Class* klass = uninit_type.GetClass();
444    if (uninit_type.IsUninitializedThisReference() && !klass->IsFinal()) {
445      // For uninitialized "this reference" look for reference types that are not precise.
446      for (size_t i = primitive_count_; i < entries_.size(); i++) {
447        const RegType* cur_entry = entries_[i];
448        if (cur_entry->IsReference() && cur_entry->GetClass() == klass) {
449          return *cur_entry;
450        }
451      }
452      entry = new ReferenceType(klass, "", entries_.size());
453    } else if (klass->IsInstantiable()) {
454      // We're uninitialized because of allocation, look or create a precise type as allocations
455      // may only create objects of that type.
456      for (size_t i = primitive_count_; i < entries_.size(); i++) {
457        const RegType* cur_entry = entries_[i];
458        if (cur_entry->IsPreciseReference() && cur_entry->GetClass() == klass) {
459          return *cur_entry;
460        }
461      }
462      entry = new PreciseReferenceType(klass, uninit_type.GetDescriptor(), entries_.size());
463    } else {
464      return Conflict();
465    }
466  }
467  AddEntry(entry);
468  return *entry;
469}
470
471const UninitializedType& RegTypeCache::UninitializedThisArgument(const RegType& type) {
472  UninitializedType* entry;
473  const std::string& descriptor(type.GetDescriptor());
474  if (type.IsUnresolvedTypes()) {
475    for (size_t i = primitive_count_; i < entries_.size(); i++) {
476      const RegType* cur_entry = entries_[i];
477      if (cur_entry->IsUnresolvedAndUninitializedThisReference() &&
478          cur_entry->GetDescriptor() == descriptor) {
479        return *down_cast<const UninitializedType*>(cur_entry);
480      }
481    }
482    entry = new UnresolvedUninitializedThisRefType(descriptor, entries_.size());
483  } else {
484    mirror::Class* klass = type.GetClass();
485    for (size_t i = primitive_count_; i < entries_.size(); i++) {
486      const RegType* cur_entry = entries_[i];
487      if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) {
488        return *down_cast<const UninitializedType*>(cur_entry);
489      }
490    }
491    entry = new UninitializedThisReferenceType(klass, descriptor, entries_.size());
492  }
493  AddEntry(entry);
494  return *entry;
495}
496
497const ConstantType& RegTypeCache::FromCat1NonSmallConstant(int32_t value, bool precise) {
498  for (size_t i = primitive_count_; i < entries_.size(); i++) {
499    const RegType* cur_entry = entries_[i];
500    if (cur_entry->klass_.IsNull() && cur_entry->IsConstant() &&
501        cur_entry->IsPreciseConstant() == precise &&
502        (down_cast<const ConstantType*>(cur_entry))->ConstantValue() == value) {
503      return *down_cast<const ConstantType*>(cur_entry);
504    }
505  }
506  ConstantType* entry;
507  if (precise) {
508    entry = new PreciseConstType(value, entries_.size());
509  } else {
510    entry = new ImpreciseConstType(value, entries_.size());
511  }
512  AddEntry(entry);
513  return *entry;
514}
515
516const ConstantType& RegTypeCache::FromCat2ConstLo(int32_t value, bool precise) {
517  for (size_t i = primitive_count_; i < entries_.size(); i++) {
518    const RegType* cur_entry = entries_[i];
519    if (cur_entry->IsConstantLo() && (cur_entry->IsPrecise() == precise) &&
520        (down_cast<const ConstantType*>(cur_entry))->ConstantValueLo() == value) {
521      return *down_cast<const ConstantType*>(cur_entry);
522    }
523  }
524  ConstantType* entry;
525  if (precise) {
526    entry = new PreciseConstLoType(value, entries_.size());
527  } else {
528    entry = new ImpreciseConstLoType(value, entries_.size());
529  }
530  AddEntry(entry);
531  return *entry;
532}
533
534const ConstantType& RegTypeCache::FromCat2ConstHi(int32_t value, bool precise) {
535  for (size_t i = primitive_count_; i < entries_.size(); i++) {
536    const RegType* cur_entry = entries_[i];
537    if (cur_entry->IsConstantHi() && (cur_entry->IsPrecise() == precise) &&
538        (down_cast<const ConstantType*>(cur_entry))->ConstantValueHi() == value) {
539      return *down_cast<const ConstantType*>(cur_entry);
540    }
541  }
542  ConstantType* entry;
543  if (precise) {
544    entry = new PreciseConstHiType(value, entries_.size());
545  } else {
546    entry = new ImpreciseConstHiType(value, entries_.size());
547  }
548  AddEntry(entry);
549  return *entry;
550}
551
552const RegType& RegTypeCache::GetComponentType(const RegType& array, mirror::ClassLoader* loader) {
553  if (!array.IsArrayTypes()) {
554    return Conflict();
555  } else if (array.IsUnresolvedTypes()) {
556    const std::string& descriptor(array.GetDescriptor());
557    const std::string component(descriptor.substr(1, descriptor.size() - 1));
558    return FromDescriptor(loader, component.c_str(), false);
559  } else {
560    mirror::Class* klass = array.GetClass()->GetComponentType();
561    std::string temp;
562    if (klass->IsErroneous()) {
563      // Arrays may have erroneous component types, use unresolved in that case.
564      // We assume that the primitive classes are not erroneous, so we know it is a
565      // reference type.
566      return FromDescriptor(loader, klass->GetDescriptor(&temp), false);
567    } else {
568      return FromClass(klass->GetDescriptor(&temp), klass,
569                       klass->CannotBeAssignedFromOtherTypes());
570    }
571  }
572}
573
574void RegTypeCache::Dump(std::ostream& os) {
575  for (size_t i = 0; i < entries_.size(); i++) {
576    const RegType* cur_entry = entries_[i];
577    if (cur_entry != nullptr) {
578      os << i << ": " << cur_entry->Dump() << "\n";
579    }
580  }
581}
582
583void RegTypeCache::VisitStaticRoots(RootVisitor* visitor) {
584  // Visit the primitive types, this is required since if there are no active verifiers they wont
585  // be in the entries array, and therefore not visited as roots.
586  if (primitive_initialized_) {
587    RootInfo ri(kRootUnknown);
588    UndefinedType::GetInstance()->VisitRoots(visitor, ri);
589    ConflictType::GetInstance()->VisitRoots(visitor, ri);
590    BooleanType::GetInstance()->VisitRoots(visitor, ri);
591    ByteType::GetInstance()->VisitRoots(visitor, ri);
592    ShortType::GetInstance()->VisitRoots(visitor, ri);
593    CharType::GetInstance()->VisitRoots(visitor, ri);
594    IntegerType::GetInstance()->VisitRoots(visitor, ri);
595    LongLoType::GetInstance()->VisitRoots(visitor, ri);
596    LongHiType::GetInstance()->VisitRoots(visitor, ri);
597    FloatType::GetInstance()->VisitRoots(visitor, ri);
598    DoubleLoType::GetInstance()->VisitRoots(visitor, ri);
599    DoubleHiType::GetInstance()->VisitRoots(visitor, ri);
600    for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) {
601      small_precise_constants_[value - kMinSmallConstant]->VisitRoots(visitor, ri);
602    }
603  }
604}
605
606void RegTypeCache::VisitRoots(RootVisitor* visitor, const RootInfo& root_info) {
607  // Exclude the static roots that are visited by VisitStaticRoots().
608  for (size_t i = primitive_count_; i < entries_.size(); ++i) {
609    entries_[i]->VisitRoots(visitor, root_info);
610  }
611}
612
613void RegTypeCache::AddEntry(RegType* new_entry) {
614  entries_.push_back(new_entry);
615}
616
617}  // namespace verifier
618}  // namespace art
619