verifier: Use `RegTypeCache::kUndefinedCacheId` more.

Test: m test-art-host-gtest
Test: testrunner.py --host --optimizing
Change-Id: I941caf6c03bea0413f3d2b2af7aeadd5595ac0d6

6 files changed, 33 insertions, 41 deletions

diff --git a/runtime/verifier/method_verifier.cc b/runtime/verifier/method_verifier.cc
index 383b5d1b9a..88b2066aa0 100644
--- a/runtime/verifier/method_verifier.cc
+++ b/runtime/verifier/method_verifier.cc
@@ -81,13 +81,12 @@ void PcToRegisterLineTable::Init(InstructionFlags* flags,
                                  uint32_t insns_size,
                                  uint16_t registers_size,
                                  ArenaAllocator& allocator,
-                                 RegTypeCache* reg_types,
                                  uint32_t interesting_dex_pc) {
   DCHECK_GT(insns_size, 0U);
   register_lines_.resize(insns_size);
   for (uint32_t i = 0; i < insns_size; i++) {
     if ((i == interesting_dex_pc) || flags[i].IsBranchTarget()) {
-      register_lines_[i].reset(RegisterLine::Create(registers_size, allocator, reg_types));
+      register_lines_[i].reset(RegisterLine::Create(registers_size, allocator));
     }
   }
 }
@@ -2202,11 +2201,10 @@ bool MethodVerifier<kVerifierDebug>::VerifyCodeFlow() {
                   code_item_accessor_.InsnsSizeInCodeUnits(),
                   registers_size,
                   allocator_,
-                  GetRegTypeCache(),
                   interesting_dex_pc_);
 
-  work_line_.reset(RegisterLine::Create(registers_size, allocator_, GetRegTypeCache()));
-  saved_line_.reset(RegisterLine::Create(registers_size, allocator_, GetRegTypeCache()));
+  work_line_.reset(RegisterLine::Create(registers_size, allocator_));
+  saved_line_.reset(RegisterLine::Create(registers_size, allocator_));
 
   /* Initialize register types of method arguments. */
   if (!SetTypesFromSignature()) {
@@ -3211,8 +3209,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
             !orig_type.IsZeroOrNull() &&
             IsStrictlyAssignableFrom(orig_type, cast_type.Merge(orig_type, &reg_types_, this))) {
           RegisterLine* update_line = RegisterLine::Create(code_item_accessor_.RegistersSize(),
-                                                           allocator_,
-                                                           GetRegTypeCache());
+                                                           allocator_);
           if (inst->Opcode() == Instruction::IF_EQZ) {
             fallthrough_line.reset(update_line);
           } else {
@@ -3420,7 +3417,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
                          dex_file_->GetTypeDescriptorView(return_type_idx));
       const RegType& return_type = reg_types_.FromTypeIndex(return_type_idx);
       if (!return_type.IsLowHalf()) {
-        work_line_->SetResultRegisterType(this, return_type);
+        work_line_->SetResultRegisterType(return_type);
       } else {
         work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
       }
@@ -3483,7 +3480,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
       }
       const RegType& return_type = reg_types_.FromTypeIndex(return_type_idx);
       if (!return_type.IsLowHalf()) {
-        work_line_->SetResultRegisterType(this, return_type);
+        work_line_->SetResultRegisterType(return_type);
       } else {
         work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
       }
@@ -3502,7 +3499,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
                          dex_file_->GetTypeDescriptorView(return_type_idx));
       const RegType& return_type = reg_types_.FromTypeIndex(return_type_idx);
       if (!return_type.IsLowHalf()) {
-        work_line_->SetResultRegisterType(this, return_type);
+        work_line_->SetResultRegisterType(return_type);
       } else {
         work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
       }
@@ -3553,7 +3550,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
                          dex_file_->GetTypeDescriptorView(return_type_idx));
       const RegType& return_type = reg_types_.FromTypeIndex(return_type_idx);
       if (!return_type.IsLowHalf()) {
-        work_line_->SetResultRegisterType(this, return_type);
+        work_line_->SetResultRegisterType(return_type);
       } else {
         work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
       }
@@ -3583,7 +3580,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
       const RegType& return_type =
           reg_types_.FromTypeIndex(dex_file_->GetProtoId(proto_idx).return_type_idx_);
       if (!return_type.IsLowHalf()) {
-        work_line_->SetResultRegisterType(this, return_type);
+        work_line_->SetResultRegisterType(return_type);
       } else {
         work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
       }
@@ -3614,7 +3611,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
       // Step 3. Propagate return type information
       const RegType& return_type = reg_types_.FromTypeIndex(proto_id.return_type_idx_);
       if (!return_type.IsLowHalf()) {
-        work_line_->SetResultRegisterType(this, return_type);
+        work_line_->SetResultRegisterType(return_type);
       } else {
         work_line_->SetResultRegisterTypeWide(return_type, return_type.HighHalf(&reg_types_));
       }
@@ -3850,7 +3847,7 @@ bool MethodVerifier<kVerifierDebug>::CodeFlowVerifyInstruction(uint32_t* start_g
    * not expensive and it makes our debugging output cleaner.)
    */
   if (!just_set_result) {
-    work_line_->SetResultTypeToUnknown(GetRegTypeCache());
+    work_line_->SetResultTypeToUnknown();
   }
 
   /*
@@ -4762,7 +4759,7 @@ void MethodVerifierImpl::VerifyNewArray(const Instruction* inst,
         }
       }
       // filled-array result goes into "result" register
-      work_line_->SetResultRegisterType(this, res_type);
+      work_line_->SetResultRegisterType(res_type);
     }
   }
 }
@@ -5184,7 +5181,7 @@ bool MethodVerifier<kVerifierDebug>::UpdateRegisters(uint32_t next_insn,
   } else {
     RegisterLineArenaUniquePtr copy;
     if (kVerifierDebug) {
-      copy.reset(RegisterLine::Create(target_line->NumRegs(), allocator_, GetRegTypeCache()));
+      copy.reset(RegisterLine::Create(target_line->NumRegs(), allocator_));
       copy->CopyFromLine(target_line);
     }
     changed = target_line->MergeRegisters(this, merge_line);
diff --git a/runtime/verifier/method_verifier.h b/runtime/verifier/method_verifier.h
index 36c033ab64..af47ba1e36 100644
--- a/runtime/verifier/method_verifier.h
+++ b/runtime/verifier/method_verifier.h
@@ -76,7 +76,6 @@ class PcToRegisterLineTable {
             uint32_t insns_size,
             uint16_t registers_size,
             ArenaAllocator& allocator,
-            RegTypeCache* reg_types,
             uint32_t interesting_dex_pc);
 
   bool IsInitialized() const {
diff --git a/runtime/verifier/register_line-inl.h b/runtime/verifier/register_line-inl.h
index a775ac5561..9511fce3fe 100644
--- a/runtime/verifier/register_line-inl.h
+++ b/runtime/verifier/register_line-inl.h
@@ -97,16 +97,16 @@ inline void RegisterLine::SetRegisterTypeWide(uint32_t vdst,
   SetRegisterTypeWideImpl(vdst, new_type1.GetId(), new_type2.GetId());
 }
 
-inline void RegisterLine::SetResultTypeToUnknown(RegTypeCache* reg_types) {
-  result_[0] = reg_types->Undefined().GetId();
-  result_[1] = result_[0];
+inline void RegisterLine::SetResultTypeToUnknown() {
+  result_[0] = RegTypeCache::kUndefinedCacheId;
+  result_[1] = RegTypeCache::kUndefinedCacheId;
 }
 
-inline void RegisterLine::SetResultRegisterType(MethodVerifier* verifier, const RegType& new_type) {
+inline void RegisterLine::SetResultRegisterType(const RegType& new_type) {
   DCHECK(!new_type.IsLowHalf());
   DCHECK(!new_type.IsHighHalf());
   result_[0] = new_type.GetId();
-  result_[1] = verifier->GetRegTypeCache()->Undefined().GetId();
+  result_[1] = RegTypeCache::kUndefinedCacheId;
 }
 
 inline void RegisterLine::SetResultRegisterTypeWide(const RegType& new_type1,
@@ -206,16 +206,12 @@ inline size_t RegisterLine::ComputeSize(size_t num_regs) {
   return OFFSETOF_MEMBER(RegisterLine, line_) + num_regs * sizeof(uint16_t);
 }
 
-inline RegisterLine* RegisterLine::Create(size_t num_regs,
-                                          ArenaAllocator& allocator,
-                                          RegTypeCache* reg_types) {
+inline RegisterLine* RegisterLine::Create(size_t num_regs, ArenaAllocator& allocator) {
   void* memory = allocator.Alloc(ComputeSize(num_regs));
-  return new (memory) RegisterLine(num_regs, allocator, reg_types);
+  return new (memory) RegisterLine(num_regs, allocator);
 }
 
-inline RegisterLine::RegisterLine(size_t num_regs,
-                                  ArenaAllocator& allocator,
-                                  RegTypeCache* reg_types)
+inline RegisterLine::RegisterLine(size_t num_regs, ArenaAllocator& allocator)
     : num_regs_(num_regs),
       allocation_dex_pcs_(nullptr),
       monitors_(allocator.Adapter(kArenaAllocVerifier)),
@@ -227,7 +223,7 @@ inline RegisterLine::RegisterLine(size_t num_regs,
   DCHECK(std::all_of(line_,
                      line_ + num_regs_,
                      [](auto id) { return id == RegTypeCache::kUndefinedCacheId;}));
-  SetResultTypeToUnknown(reg_types);
+  SetResultTypeToUnknown();
 }
 
 inline void RegisterLine::ClearRegToLockDepth(size_t reg, size_t depth) {
diff --git a/runtime/verifier/register_line.cc b/runtime/verifier/register_line.cc
index 6c4227cf8e..f6774b89f6 100644
--- a/runtime/verifier/register_line.cc
+++ b/runtime/verifier/register_line.cc
@@ -141,9 +141,9 @@ void RegisterLine::CopyResultRegister1(MethodVerifier* verifier, uint32_t vdst,
     verifier->Fail(VERIFY_ERROR_BAD_CLASS_HARD)
         << "copyRes1 v" << vdst << "<- result0"  << " type=" << type;
   } else {
-    DCHECK(verifier->GetRegTypeCache()->GetFromId(result_[1]).IsUndefined());
+    DCHECK_EQ(result_[1], RegTypeCache::kUndefinedCacheId);
     SetRegisterType<LockOp::kClear>(vdst, type);
-    result_[0] = verifier->GetRegTypeCache()->Undefined().GetId();
+    result_[0] = RegTypeCache::kUndefinedCacheId;
   }
 }
 
@@ -160,8 +160,8 @@ void RegisterLine::CopyResultRegister2(MethodVerifier* verifier, uint32_t vdst)
   } else {
     DCHECK(type_l.CheckWidePair(type_h));  // Set should never allow this case
     SetRegisterTypeWide(vdst, type_l, type_h);  // also sets the high
-    result_[0] = verifier->GetRegTypeCache()->Undefined().GetId();
-    result_[1] = verifier->GetRegTypeCache()->Undefined().GetId();
+    result_[0] = RegTypeCache::kUndefinedCacheId;
+    result_[1] = RegTypeCache::kUndefinedCacheId;
   }
 }
 
@@ -283,7 +283,7 @@ bool RegisterLine::MergeRegisters(MethodVerifier* verifier, const RegisterLine*
           incoming_line->allocation_dex_pcs_ != nullptr &&
           allocation_dex_pcs_[idx] != incoming_line->allocation_dex_pcs_[idx] &&
           needs_allocation_dex_pc()) {
-        line_[idx] = verifier->GetRegTypeCache()->Conflict().GetId();
+        line_[idx] = RegTypeCache::kConflictCacheId;
       }
     }
   }
diff --git a/runtime/verifier/register_line.h b/runtime/verifier/register_line.h
index 19c2e2084f..e85e99b8de 100644
--- a/runtime/verifier/register_line.h
+++ b/runtime/verifier/register_line.h
@@ -76,7 +76,7 @@ class RegisterLine {
       std::numeric_limits<RegisterStackMask>::digits;
 
   // Create a register line of num_regs registers.
-  static RegisterLine* Create(size_t num_regs, ArenaAllocator& allocator, RegTypeCache* reg_types);
+  static RegisterLine* Create(size_t num_regs, ArenaAllocator& allocator);
 
   // Implement category-1 "move" instructions. Copy a 32-bit value from "vsrc" to "vdst".
   void CopyRegister1(MethodVerifier* verifier, uint32_t vdst, uint32_t vsrc, TypeCategory cat)
@@ -98,7 +98,7 @@ class RegisterLine {
       REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Set the invisible result register to unknown
-  void SetResultTypeToUnknown(RegTypeCache* reg_types) REQUIRES_SHARED(Locks::mutator_lock_);
+  void SetResultTypeToUnknown() REQUIRES_SHARED(Locks::mutator_lock_);
 
   // Set the type of register N, verifying that the register is valid.  If "newType" is the "Lo"
   // part of a 64-bit value, register N+1 will be set to "newType+1".
@@ -123,7 +123,7 @@ class RegisterLine {
       REQUIRES_SHARED(Locks::mutator_lock_);
 
   /* Set the type of the "result" register. */
-  void SetResultRegisterType(MethodVerifier* verifier, const RegType& new_type)
+  void SetResultRegisterType(const RegType& new_type)
       REQUIRES_SHARED(Locks::mutator_lock_);
 
   void SetResultRegisterTypeWide(const RegType& new_type1, const RegType& new_type2)
@@ -305,7 +305,7 @@ class RegisterLine {
     reg_to_lock_depths_.erase(reg);
   }
 
-  RegisterLine(size_t num_regs, ArenaAllocator& allocator, RegTypeCache* reg_types);
+  RegisterLine(size_t num_regs, ArenaAllocator& allocator);
 
   static constexpr uint32_t kNoDexPc = static_cast<uint32_t>(-1);
 
diff --git a/runtime/verifier/register_line_test.cc b/runtime/verifier/register_line_test.cc
index 4d0f0c20cd..0490683a86 100644
--- a/runtime/verifier/register_line_test.cc
+++ b/runtime/verifier/register_line_test.cc
@@ -120,8 +120,8 @@ TEST_F(RegisterLineTest, NewInstanceDexPcsMerging) {
   constexpr size_t kNumRegs = 1u;
   constexpr uint32_t kVReg = 0u;
   ArenaAllocator& allocator = GetArenaAllocator(verifier.get());
-  RegisterLineArenaUniquePtr line1(RegisterLine::Create(kNumRegs, allocator, &reg_types));
-  RegisterLineArenaUniquePtr line2(RegisterLine::Create(kNumRegs, allocator, &reg_types));
+  RegisterLineArenaUniquePtr line1(RegisterLine::Create(kNumRegs, allocator));
+  RegisterLineArenaUniquePtr line2(RegisterLine::Create(kNumRegs, allocator));
   for (const TestCase& test_case : test_cases) {
     ASSERT_TRUE(test_case.reg_type1.IsUninitializedTypes() ||
                 test_case.reg_type2.IsUninitializedTypes());