resolved conflicts for merge of df4a39e8 to lmp-dev-plus-aosp

Change-Id: I6dc353b7e3e5a120ddf957accf235ce8f98bca25

diff --cc runtime/runtime.cc
Simple merge

diff --cc runtime/verifier/method_verifier.cc
Simple merge

diff --cc runtime/verifier/method_verifier.h
Simple merge

diff --cc runtime/verifier/reg_type_cache.cc
index 121fccb,63fb2d9..bffec4b
--- 1/runtime/verifier/reg_type_cache.cc
--- 2/runtime/verifier/reg_type_cache.cc
+++ b/runtime/verifier/reg_type_cache.cc
@@@ -555,8 -588,30 +555,30 @@@ void RegTypeCache::Dump(std::ostream& o
    }
  }
  
 -    Undefined().VisitRoots(callback, arg);
 -    Conflict().VisitRoots(callback, arg);
 -    Boolean().VisitRoots(callback, arg);
 -    Byte().VisitRoots(callback, arg);
 -    Short().VisitRoots(callback, arg);
 -    Char().VisitRoots(callback, arg);
 -    Integer().VisitRoots(callback, arg);
 -    LongLo().VisitRoots(callback, arg);
 -    LongHi().VisitRoots(callback, arg);
 -    Float().VisitRoots(callback, arg);
 -    DoubleLo().VisitRoots(callback, arg);
 -    DoubleHi().VisitRoots(callback, arg);
+ void RegTypeCache::VisitStaticRoots(RootCallback* callback, void* arg) {
+   // Visit the primitive types, this is required since if there are no active verifiers they wont
+   // be in the entries array, and therefore not visited as roots.
+   if (primitive_initialized_) {
++    UndefinedType::GetInstance()->VisitRoots(callback, arg);
++    ConflictType::GetInstance()->VisitRoots(callback, arg);
++    BooleanType::GetInstance()->VisitRoots(callback, arg);
++    ByteType::GetInstance()->VisitRoots(callback, arg);
++    ShortType::GetInstance()->VisitRoots(callback, arg);
++    CharType::GetInstance()->VisitRoots(callback, arg);
++    IntegerType::GetInstance()->VisitRoots(callback, arg);
++    LongLoType::GetInstance()->VisitRoots(callback, arg);
++    LongHiType::GetInstance()->VisitRoots(callback, arg);
++    FloatType::GetInstance()->VisitRoots(callback, arg);
++    DoubleLoType::GetInstance()->VisitRoots(callback, arg);
++    DoubleHiType::GetInstance()->VisitRoots(callback, arg);
+     for (int32_t value = kMinSmallConstant; value <= kMaxSmallConstant; ++value) {
+       small_precise_constants_[value - kMinSmallConstant]->VisitRoots(callback, arg);
+     }
+   }
+ }
+ 
  void RegTypeCache::VisitRoots(RootCallback* callback, void* arg) {
 -  for (RegType* entry : entries_) {
 +  for (const RegType* entry : entries_) {
      entry->VisitRoots(callback, arg);
    }
  }

diff --cc runtime/verifier/reg_type_cache.h
index eb17a52,a75aaab..ff7b1f3
--- 1/runtime/verifier/reg_type_cache.h
--- 2/runtime/verifier/reg_type_cache.h
+++ b/runtime/verifier/reg_type_cache.h
@@@ -77,67 -85,69 +77,69 @@@ class RegTypeCache 
    size_t GetCacheSize() {
      return entries_.size();
    }
 -  static RegType& Boolean() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 +  const BooleanType& Boolean() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *BooleanType::GetInstance();
    }
-   const ByteType& Byte() {
 -  static RegType& Byte() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const ByteType& Byte() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *ByteType::GetInstance();
    }
-   const CharType& Char()  {
 -  static RegType& Char() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const CharType& Char() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *CharType::GetInstance();
    }
-   const ShortType& Short()  {
 -  static RegType& Short() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const ShortType& Short() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *ShortType::GetInstance();
    }
-   const IntegerType& Integer() {
 -  static RegType& Integer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const IntegerType& Integer() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *IntegerType::GetInstance();
    }
-   const FloatType& Float() {
 -  static RegType& Float() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const FloatType& Float() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *FloatType::GetInstance();
    }
-   const LongLoType& LongLo() {
 -  static RegType& LongLo() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const LongLoType& LongLo() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *LongLoType::GetInstance();
    }
-   const LongHiType& LongHi() {
 -  static RegType& LongHi() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const LongHiType& LongHi() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *LongHiType::GetInstance();
    }
-   const DoubleLoType& DoubleLo() {
 -  static RegType& DoubleLo() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const DoubleLoType& DoubleLo() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *DoubleLoType::GetInstance();
    }
-   const DoubleHiType& DoubleHi() {
 -  static RegType& DoubleHi() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const DoubleHiType& DoubleHi() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *DoubleHiType::GetInstance();
    }
-   const UndefinedType& Undefined() {
 -  static RegType& Undefined() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
++  const UndefinedType& Undefined() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
      return *UndefinedType::GetInstance();
    }
 -  static RegType& Conflict() {
 +  const ConflictType& Conflict() {
      return *ConflictType::GetInstance();
    }
 -  RegType& JavaLangClass(bool precise) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 -    return From(NULL, "Ljava/lang/Class;", precise);
 -  }
 -  RegType& JavaLangObject(bool precise) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
 -    return From(NULL, "Ljava/lang/Object;", precise);
 -  }
 -  UninitializedType& Uninitialized(RegType& type, uint32_t allocation_pc)
 +
 +  const PreciseReferenceType& JavaLangClass() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const PreciseReferenceType& JavaLangString() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const RegType& JavaLangThrowable(bool precise) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const RegType& JavaLangObject(bool precise) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +
 +  const UninitializedType& Uninitialized(const RegType& type, uint32_t allocation_pc)
        SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    // Create an uninitialized 'this' argument for the given type.
 -  UninitializedType& UninitializedThisArgument(RegType& type)
 +  const UninitializedType& UninitializedThisArgument(const RegType& type)
        SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  RegType& FromUninitialized(RegType& uninit_type)
 +  const RegType& FromUninitialized(const RegType& uninit_type)
        SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  ImpreciseConstType& ByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  ImpreciseConstType& CharConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  ImpreciseConstType& ShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  ImpreciseConstType& IntConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  ImpreciseConstType& PosByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  ImpreciseConstType& PosShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  RegType& GetComponentType(RegType& array, mirror::ClassLoader* loader)
 +  const ImpreciseConstType& ByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const ImpreciseConstType& CharConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const ImpreciseConstType& ShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const ImpreciseConstType& IntConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const ImpreciseConstType& PosByteConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const ImpreciseConstType& PosShortConstant() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 +  const RegType& GetComponentType(const RegType& array, mirror::ClassLoader* loader)
        SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
    void Dump(std::ostream& os) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
 -  RegType& RegTypeFromPrimitiveType(Primitive::Type) const;
 +  const RegType& RegTypeFromPrimitiveType(Primitive::Type) const;
  
    void VisitRoots(RootCallback* callback, void* arg) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
+   static void VisitStaticRoots(RootCallback* callback, void* arg)
+       SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
  
   private:
    void FillPrimitiveAndSmallConstantTypes() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);