commit ad0b3a35857d2cd2db720028ebc51176191e2219
author Ian Rogers <irogers@google.com> Mon Apr 16 14:50:24 2012 -0700
committer jeffhao <jeffhao@google.com> Fri Apr 20 19:01:23 2012 -0700
tree e6cfbb8a5c9e6127796e0dd5912787416ec87bfd
parent 174651dea03956e160a2cff0d842954823c49134

Support for a set of verifier failures.

(cherry picked from commit 0d60484cbb0c70acc60965b015e94c2e9cb9f1e7)

Change-Id: I70eb1121390305c436a2bed2c7835c870c0c3972

src/verifier/reg_type_cache.cc

diff --git a/src/verifier/reg_type_cache.cc b/src/verifier/reg_type_cache.cc
index d06377a..53b7a76 100644
--- a/src/verifier/reg_type_cache.cc
+++ b/src/verifier/reg_type_cache.cc
@@ -32,7 +32,7 @@
     case Primitive::kPrimFloat:   return RegType::kRegTypeFloat;
     case Primitive::kPrimDouble:  return RegType::kRegTypeDoubleLo;
     case Primitive::kPrimVoid:
-    default:                      return RegType::kRegTypeUnknown;
+    default:                      return RegType::kRegTypeConflict;
   }
 }
 
@@ -48,12 +48,12 @@
       case 'F': return RegType::kRegTypeFloat;
       case 'D': return RegType::kRegTypeDoubleLo;
       case 'V':
-      default:  return RegType::kRegTypeUnknown;
+      default:  return RegType::kRegTypeConflict;
     }
   } else if (descriptor[0] == 'L' || descriptor[0] == '[') {
     return RegType::kRegTypeReference;
   } else {
-    return RegType::kRegTypeUnknown;
+    return RegType::kRegTypeConflict;
   }
 }
 
@@ -115,7 +115,7 @@
       } else {
         // The descriptor is broken return the unknown type as there's nothing sensible that
         // could be done at runtime
-        return Unknown();
+        return Conflict();
       }
     }
   }
@@ -201,15 +201,30 @@
   return *entry;
 }
 
-const RegType& RegTypeCache::UninitializedThisArgument(Class* klass) {
-  for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
-    RegType* cur_entry = entries_[i];
-    if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) {
-      return *cur_entry;
+const RegType& RegTypeCache::UninitializedThisArgument(const RegType& type) {
+  // TODO: implement descriptor version.
+  RegType* entry;
+  if (type.IsUnresolvedTypes()) {
+    String* descriptor = type.GetDescriptor();
+    for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
+      RegType* cur_entry = entries_[i];
+      if (cur_entry->IsUnresolvedAndUninitializedThisReference() &&
+          cur_entry->GetDescriptor() == descriptor) {
+        return *cur_entry;
+      }
     }
+    entry = new RegType(RegType::kRegTypeUnresolvedAndUninitializedThisReference, descriptor, 0,
+                        entries_.size());
+  } else {
+    Class* klass = type.GetClass();
+    for (size_t i = RegType::kRegTypeLastFixedLocation + 1; i < entries_.size(); i++) {
+      RegType* cur_entry = entries_[i];
+      if (cur_entry->IsUninitializedThisReference() && cur_entry->GetClass() == klass) {
+        return *cur_entry;
+      }
+    }
+    entry = new RegType(RegType::kRegTypeUninitializedThisReference, klass, 0, entries_.size());
   }
-  RegType* entry = new RegType(RegType::kRegTypeUninitializedThisReference, klass, 0,
-                               entries_.size());
   entries_.push_back(entry);
   return *entry;
 }