diff --git a/openjdkjvmti/ti_extension.cc b/openjdkjvmti/ti_extension.cc
index 1301697..62c6fb2 100644
--- a/openjdkjvmti/ti_extension.cc
+++ b/openjdkjvmti/ti_extension.cc
@@ -423,7 +423,6 @@
         reinterpret_cast<jvmtiExtensionFunction>(Redefiner::StructurallyRedefineClasses),
         "com.android.art.class.structurally_redefine_classes",
         "Entrypoint for structural class redefinition. Has the same signature as RedefineClasses."
-        " Currently does not support redefining a class and any of its supertypes at the same time."
         " Only supports additive changes, methods and fields may not be removed. Supertypes and"
         " implemented interfaces may not be changed. After calling this"
         " com.android.art.structural_dex_file_load_hook events will be triggered, followed by"
diff --git a/openjdkjvmti/ti_redefine.cc b/openjdkjvmti/ti_redefine.cc
index 1e77be8..c505933 100644
--- a/openjdkjvmti/ti_redefine.cc
+++ b/openjdkjvmti/ti_redefine.cc
@@ -1188,7 +1188,10 @@
         self,
         art::GetClassRoot<art::mirror::ObjectArray<art::mirror::Object>>(runtime->GetClassLinker()),
         redefinitions->size() * kNumSlots))),
-    redefinitions_(redefinitions) {}
+    redefinitions_(redefinitions),
+    initialized_(redefinitions_->size(), false),
+    actually_structural_(redefinitions_->size(), false),
+    initial_structural_(redefinitions_->size(), false) {}
 
   bool IsNull() const REQUIRES_SHARED(art::Locks::mutator_lock_) {
     return arr_.IsNull();
@@ -1260,6 +1263,16 @@
     return art::ObjPtr<art::mirror::ObjectArray<art::mirror::Class>>::DownCast(
         GetSlot(klass_index, kSlotNewClasses));
   }
+  bool IsInitialized(jint klass_index) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    return initialized_[klass_index];
+  }
+  bool IsActuallyStructural(jint klass_index) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    return actually_structural_[klass_index];
+  }
+
+  bool IsInitialStructural(jint klass_index) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    return initial_structural_[klass_index];
+  }
 
   void SetSourceClassLoader(jint klass_index, art::ObjPtr<art::mirror::ClassLoader> loader)
       REQUIRES_SHARED(art::Locks::mutator_lock_) {
@@ -1320,6 +1333,15 @@
       REQUIRES_SHARED(art::Locks::mutator_lock_) {
     SetSlot(klass_index, kSlotNewClasses, klasses);
   }
+  void SetInitialized(jint klass_index) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    initialized_[klass_index] = true;
+  }
+  void SetActuallyStructural(jint klass_index) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    actually_structural_[klass_index] = true;
+  }
+  void SetInitialStructural(jint klass_index) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    initial_structural_[klass_index] = true;
+  }
   int32_t Length() const REQUIRES_SHARED(art::Locks::mutator_lock_) {
     return arr_->GetLength() / kNumSlots;
   }
@@ -1345,6 +1367,14 @@
  private:
   mutable art::Handle<art::mirror::ObjectArray<art::mirror::Object>> arr_;
   std::vector<Redefiner::ClassRedefinition>* redefinitions_;
+  // Used to mark a particular redefinition as fully initialized.
+  std::vector<bool> initialized_;
+  // Used to mark a redefinition as 'actually' structural. That is either the redefinition is
+  // structural or a superclass is.
+  std::vector<bool> actually_structural_;
+  // Used to mark a redefinition as the initial structural redefinition. This redefinition will take
+  // care of updating all of its subtypes.
+  std::vector<bool> initial_structural_;
 
   art::ObjPtr<art::mirror::Object> GetSlot(jint klass_index, DataSlot slot) const
       REQUIRES_SHARED(art::Locks::mutator_lock_) {
@@ -1471,6 +1501,15 @@
       REQUIRES_SHARED(art::Locks::mutator_lock_) {
     return holder_.GetNewClasses(idx_);
   }
+  bool IsInitialized() const REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    return holder_.IsInitialized(idx_);
+  }
+  bool IsActuallyStructural() const REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    return holder_.IsActuallyStructural(idx_);
+  }
+  bool IsInitialStructural() const REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    return holder_.IsInitialStructural(idx_);
+  }
   int32_t GetIndex() const {
     return idx_;
   }
@@ -1527,6 +1566,15 @@
       REQUIRES_SHARED(art::Locks::mutator_lock_) {
     holder_.SetNewClasses(idx_, klasses);
   }
+  void SetInitialized() REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    holder_.SetInitialized(idx_);
+  }
+  void SetActuallyStructural() REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    holder_.SetActuallyStructural(idx_);
+  }
+  void SetInitialStructural() REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    holder_.SetInitialStructural(idx_);
+  }
 
  private:
   int32_t idx_;
@@ -1629,113 +1677,42 @@
   return true;
 }
 
+bool CompareClasses(art::ObjPtr<art::mirror::Class> l, art::ObjPtr<art::mirror::Class> r)
+    REQUIRES_SHARED(art::Locks::mutator_lock_) {
+  auto parents = [](art::ObjPtr<art::mirror::Class> c) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+    uint32_t res = 0;
+    while (!c->IsObjectClass()) {
+      res++;
+      c = c->GetSuperClass();
+    }
+    return res;
+  };
+  return parents(l.Ptr()) < parents(r.Ptr());
+}
+
 bool Redefiner::ClassRedefinition::CollectAndCreateNewInstances(
     /*out*/ RedefinitionDataIter* cur_data) {
-  if (!IsStructuralRedefinition()) {
+  if (!cur_data->IsInitialStructural()) {
+    // An earlier structural redefinition already remade all the instances.
     return true;
   }
+  art::gc::Heap* heap = driver_->runtime_->GetHeap();
   art::VariableSizedHandleScope hs(driver_->self_);
   art::Handle<art::mirror::Class> old_klass(hs.NewHandle(cur_data->GetMirrorClass()));
   std::vector<art::Handle<art::mirror::Object>> old_instances;
-  std::vector<art::Handle<art::mirror::Class>> old_types;
-  art::gc::Heap* heap = driver_->runtime_->GetHeap();
-  auto is_subtype = [&](art::mirror::Object* obj) REQUIRES_SHARED(art::Locks::mutator_lock_) {
-    // We've already waited for class defines to be finished and paused them. All classes should be
-    // either resolved or error. We don't need to do anything with error classes, since they cannot
-    // be accessed in any observable way.
-    return obj->IsClass() && obj->AsClass()->IsResolved() &&
-           old_klass->IsAssignableFrom(obj->AsClass());
-  };
   auto is_instance = [&](art::mirror::Object* obj) REQUIRES_SHARED(art::Locks::mutator_lock_) {
     return obj->InstanceOf(old_klass.Get());
   };
   heap->VisitObjects([&](art::mirror::Object* obj) REQUIRES_SHARED(art::Locks::mutator_lock_) {
     if (is_instance(obj)) {
       old_instances.push_back(hs.NewHandle(obj));
-    } else if (is_subtype(obj)) {
-      old_types.push_back(hs.NewHandle(obj->AsClass()));
     }
   });
   VLOG(plugin) << "Collected " << old_instances.size() << " instances to recreate!";
-  VLOG(plugin) << "Found " << old_types.size() << " types that are/are subtypes of "
-               << old_klass->PrettyClass();
-
-  art::Handle<art::mirror::Class> cls_array_class(
-      hs.NewHandle(art::GetClassRoot<art::mirror::ObjectArray<art::mirror::Class>>(
-          driver_->runtime_->GetClassLinker())));
   art::Handle<art::mirror::ObjectArray<art::mirror::Class>> old_classes_arr(
-      hs.NewHandle(art::mirror::ObjectArray<art::mirror::Class>::Alloc(
-          driver_->self_, cls_array_class.Get(), old_types.size())));
-  if (old_classes_arr.IsNull()) {
-    driver_->self_->AssertPendingOOMException();
-    driver_->self_->ClearException();
-    RecordFailure(ERR(OUT_OF_MEMORY), "Could not allocate old_classes arrays!");
-    return false;
-  }
-  // Sort the old_types topologically.
-  {
-    art::ScopedAssertNoThreadSuspension sants("Sort classes");
-    auto count_distance =
-      [&](art::ObjPtr<art::mirror::Class> c) REQUIRES_SHARED(art::Locks::mutator_lock_) {
-        uint32_t res = 0;
-        while (c != old_klass.Get()) {
-          DCHECK_NE(c, art::GetClassRoot<art::mirror::Object>());
-          res++;
-          c = c->GetSuperClass();
-        }
-        return res;
-      };
-    auto compare_handles = [&](auto l, auto r) REQUIRES_SHARED(art::Locks::mutator_lock_) {
-      return count_distance(l.Get()) < count_distance(r.Get());
-    };
-    // Sort them by the distance to the base-class. This ensures that any class occurs before any of
-    // its subtypes.
-    std::sort(old_types.begin(), old_types.end(), compare_handles);
-  }
-  for (uint32_t i = 0; i < old_types.size(); ++i) {
-    old_classes_arr->Set(i, old_types[i].Get());
-  }
-  cur_data->SetOldClasses(old_classes_arr.Get());
+      hs.NewHandle(cur_data->GetOldClasses()));
   art::Handle<art::mirror::ObjectArray<art::mirror::Class>> new_classes_arr(
-      hs.NewHandle(art::mirror::ObjectArray<art::mirror::Class>::Alloc(
-          driver_->self_, cls_array_class.Get(), old_types.size())));
-  if (new_classes_arr.IsNull()) {
-    driver_->self_->AssertPendingOOMException();
-    driver_->self_->ClearException();
-    RecordFailure(ERR(OUT_OF_MEMORY), "Could not allocate new_classes arrays!");
-    return false;
-  }
-  art::MutableHandle<art::mirror::DexCache> dch(hs.NewHandle<art::mirror::DexCache>(nullptr));
-  art::MutableHandle<art::mirror::Class> superclass(hs.NewHandle<art::mirror::Class>(nullptr));
-  for (size_t i = 0; i < old_types.size(); i++) {
-    art::Handle<art::mirror::Class>& old_class = old_types[i];
-    if (old_class.Get() == cur_data->GetMirrorClass()) {
-      CHECK_EQ(i, 0u) << "original class not at index 0. Bad sort!";
-      new_classes_arr->Set(i, cur_data->GetNewClassObject());
-      continue;
-    } else {
-      auto old_super = std::find_if(old_types.begin(),
-                                    old_types.begin() + i,
-                                    [&](art::Handle<art::mirror::Class>& v)
-                                        REQUIRES_SHARED(art::Locks::mutator_lock_) {
-                                          return v.Get() == old_class->GetSuperClass();
-                                        });
-      // Only the GetMirrorClass should not be in this list.
-      CHECK(old_super != old_types.begin() + i)
-          << "from first " << i << " could not find super of " << old_class->PrettyClass()
-          << " expected to find " << old_class->GetSuperClass()->PrettyClass();
-      superclass.Assign(new_classes_arr->Get(std::distance(old_types.begin(), old_super)));
-      dch.Assign(old_class->GetDexCache());
-      art::ObjPtr<art::mirror::Class> new_class(
-          AllocateNewClassObject(old_class, superclass, dch, old_class->GetDexClassDefIndex()));
-      if (new_class == nullptr) {
-        return false;
-      }
-      new_classes_arr->Set(i, new_class);
-    }
-  }
-  cur_data->SetNewClasses(new_classes_arr.Get());
-
+      hs.NewHandle(cur_data->GetNewClasses()));
   art::Handle<art::mirror::Class> obj_array_class(
       hs.NewHandle(art::GetClassRoot<art::mirror::ObjectArray<art::mirror::Object>>(
           driver_->runtime_->GetClassLinker())));
@@ -1788,10 +1765,10 @@
   return true;
 }
 
-bool Redefiner::ClassRedefinition::FinishRemainingAllocations(
+bool Redefiner::ClassRedefinition::FinishRemainingCommonAllocations(
     /*out*/RedefinitionDataIter* cur_data) {
   art::ScopedObjectAccessUnchecked soa(driver_->self_);
-  art::StackHandleScope<4> hs(driver_->self_);
+  art::StackHandleScope<2> hs(driver_->self_);
   cur_data->SetMirrorClass(GetMirrorClass());
   // This shouldn't allocate
   art::Handle<art::mirror::ClassLoader> loader(hs.NewHandle(GetClassLoader()));
@@ -1829,20 +1806,151 @@
     RecordFailure(ERR(OUT_OF_MEMORY), "Unable to allocate array for original dex file");
     return false;
   }
-  if (added_fields_ || added_methods_) {
-    art::Handle<art::mirror::Class> nc(hs.NewHandle(
-        AllocateNewClassObject(hs.NewHandle(cur_data->GetNewDexCache()))));
+  return true;
+}
+
+bool Redefiner::ClassRedefinition::FinishNewClassAllocations(RedefinitionDataHolder &holder,
+                                                             RedefinitionDataIter *cur_data) {
+  if (cur_data->IsInitialized() || !cur_data->IsActuallyStructural()) {
+    cur_data->SetInitialized();
+    return true;
+  }
+
+  art::VariableSizedHandleScope hs(driver_->self_);
+  // If we weren't the lowest structural redef the superclass would have already initialized us.
+  CHECK(IsStructuralRedefinition());
+  CHECK(cur_data->IsInitialStructural()) << "Should have already been initialized by supertype";
+  auto setup_single_redefinition =
+      [this](RedefinitionDataIter* data, art::Handle<art::mirror::Class> super_class)
+          REQUIRES_SHARED(art::Locks::mutator_lock_) -> art::ObjPtr<art::mirror::Class> {
+    art::StackHandleScope<3> chs(driver_->self_);
+    art::Handle<art::mirror::Class> nc(
+        chs.NewHandle(AllocateNewClassObject(chs.NewHandle(data->GetMirrorClass()),
+                                             super_class,
+                                             chs.NewHandle(data->GetNewDexCache()),
+                                             /*dex_class_def_index*/ 0)));
     if (nc.IsNull()) {
-      return false;
+      return nullptr;
     }
 
-    cur_data->SetNewClassObject(nc.Get());
+    data->SetNewClassObject(nc.Get());
     // We really want to be able to resolve to the new class-object using this dex-cache for
     // verification work. Since we haven't put it in the class-table yet we wll just manually add it
     // to the dex-cache.
     // TODO: We should maybe do this in a better spot.
-    cur_data->GetNewDexCache()->SetResolvedType(nc->GetDexTypeIndex(), nc.Get());
+    data->GetNewDexCache()->SetResolvedType(nc->GetDexTypeIndex(), nc.Get());
+    data->SetInitialized();
+    return nc.Get();
+  };
+
+  std::vector<art::Handle<art::mirror::Class>> old_types;
+  {
+    art::gc::Heap* heap = driver_->runtime_->GetHeap();
+    art::Handle<art::mirror::Class>
+        old_klass(hs.NewHandle(cur_data->GetMirrorClass()));
+    if (setup_single_redefinition(cur_data, hs.NewHandle(old_klass->GetSuperClass())).IsNull()) {
+      return false;
+    }
+    auto is_subtype = [&](art::mirror::Object* obj) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+      // We've already waited for class defines to be finished and paused them. All classes should be
+      // either resolved or error. We don't need to do anything with error classes, since they cannot
+      // be accessed in any observable way.
+      return obj->IsClass() && obj->AsClass()->IsResolved() &&
+            old_klass->IsAssignableFrom(obj->AsClass());
+    };
+    heap->VisitObjects([&](art::mirror::Object* obj) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+      if (is_subtype(obj)) {
+        old_types.push_back(hs.NewHandle(obj->AsClass()));
+      }
+    });
+    VLOG(plugin) << "Found " << old_types.size() << " types that are/are subtypes of "
+                << old_klass->PrettyClass();
   }
+
+  art::Handle<art::mirror::Class> cls_array_class(
+      hs.NewHandle(art::GetClassRoot<art::mirror::ObjectArray<art::mirror::Class>>(
+          driver_->runtime_->GetClassLinker())));
+  art::Handle<art::mirror::ObjectArray<art::mirror::Class>> old_classes_arr(
+      hs.NewHandle(art::mirror::ObjectArray<art::mirror::Class>::Alloc(
+          driver_->self_, cls_array_class.Get(), old_types.size())));
+  if (old_classes_arr.IsNull()) {
+    driver_->self_->AssertPendingOOMException();
+    driver_->self_->ClearException();
+    RecordFailure(ERR(OUT_OF_MEMORY), "Could not allocate old_classes arrays!");
+    return false;
+  }
+  // Sort the old_types topologically.
+  {
+    art::ScopedAssertNoThreadSuspension sants("Sort classes");
+    // Sort them by the distance to the base-class. This ensures that any class occurs before any of
+    // its subtypes.
+    std::sort(old_types.begin(),
+              old_types.end(),
+              [](auto& l, auto& r) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+                return CompareClasses(l.Get(), r.Get());
+              });
+  }
+  for (uint32_t i = 0; i < old_types.size(); ++i) {
+    old_classes_arr->Set(i, old_types[i].Get());
+  }
+  cur_data->SetOldClasses(old_classes_arr.Get());
+
+  art::Handle<art::mirror::ObjectArray<art::mirror::Class>> new_classes_arr(
+      hs.NewHandle(art::mirror::ObjectArray<art::mirror::Class>::Alloc(
+          driver_->self_, cls_array_class.Get(), old_types.size())));
+  if (new_classes_arr.IsNull()) {
+    driver_->self_->AssertPendingOOMException();
+    driver_->self_->ClearException();
+    RecordFailure(ERR(OUT_OF_MEMORY), "Could not allocate new_classes arrays!");
+    return false;
+  }
+
+  art::MutableHandle<art::mirror::DexCache> dch(hs.NewHandle<art::mirror::DexCache>(nullptr));
+  art::MutableHandle<art::mirror::Class> superclass(hs.NewHandle<art::mirror::Class>(nullptr));
+  for (size_t i = 0; i < old_types.size(); i++) {
+    art::Handle<art::mirror::Class>& old_type = old_types[i];
+    if (old_type.Get() == cur_data->GetMirrorClass()) {
+      CHECK_EQ(i, 0u) << "original class not at index 0. Bad sort!";
+      new_classes_arr->Set(i, cur_data->GetNewClassObject());
+      continue;
+    } else {
+      auto old_super = std::find_if(old_types.begin(),
+                                    old_types.begin() + i,
+                                    [&](art::Handle<art::mirror::Class>& v)
+                                        REQUIRES_SHARED(art::Locks::mutator_lock_) {
+                                          return v.Get() == old_type->GetSuperClass();
+                                        });
+      // Only the GetMirrorClass should not be in this list.
+      CHECK(old_super != old_types.begin() + i)
+          << "from first " << i << " could not find super of " << old_type->PrettyClass()
+          << " expected to find " << old_type->GetSuperClass()->PrettyClass();
+      superclass.Assign(new_classes_arr->Get(std::distance(old_types.begin(), old_super)));
+      auto new_redef = std::find_if(
+          *cur_data + 1, holder.end(), [&](auto it) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+            return it.GetMirrorClass() == old_type.Get();
+          });
+      art::ObjPtr<art::mirror::Class> new_type;
+      if (new_redef == holder.end()) {
+        // We aren't also redefining this subclass. Just allocate a new class and continue.
+        dch.Assign(old_type->GetDexCache());
+        new_type =
+            AllocateNewClassObject(old_type, superclass, dch, old_type->GetDexClassDefIndex());
+      } else {
+        // This subclass is also being redefined. We need to use its new dex-file to load the new
+        // class.
+        CHECK(new_redef.IsActuallyStructural());
+        CHECK(!new_redef.IsInitialStructural());
+        new_type = setup_single_redefinition(&new_redef, superclass);
+      }
+      if (new_type == nullptr) {
+        VLOG(plugin) << "Failed to load new version of class " << old_type->PrettyClass()
+                     << " for structural redefinition!";
+        return false;
+      }
+      new_classes_arr->Set(i, new_type);
+    }
+  }
+  cur_data->SetNewClasses(new_classes_arr.Get());
   return true;
 }
 
@@ -2024,45 +2132,34 @@
       return false;
     }
   }
-  if (std::any_of(
-          redefinitions_.begin(),
-          redefinitions_.end(),
-          std::function<bool(ClassRedefinition&)>(&ClassRedefinition::IsStructuralRedefinition))) {
-    return CheckClassHierarchy();
-  }
   return true;
 }
 
-bool Redefiner::CheckClassHierarchy() {
-  return std::all_of(
-      redefinitions_.begin(),
-      redefinitions_.end(),
-      [&](ClassRedefinition& r) REQUIRES_SHARED(art::Locks::mutator_lock_) {
-        return std::none_of(
-            redefinitions_.begin(),
-            redefinitions_.end(),
-            [&](ClassRedefinition& r2) REQUIRES_SHARED(art::Locks::mutator_lock_) {
-              bool related = &r2 != &r &&
-                             r2.GetMirrorClass()->IsAssignableFrom(r.GetMirrorClass()) &&
-                             r2.IsStructuralRedefinition();
-              if (related) {
-                std::ostringstream oss;
-                oss << "Structurally redefining " << r2.GetMirrorClass()->PrettyClass()
-                    << " which is a superclass of " << r.GetMirrorClass()->PrettyClass()
-                    << ". This is not currently supported";
-                r2.RecordFailure(ERR(INTERNAL), oss.str());
-              }
-              return related;
-            });
-      });
-}
-
 void Redefiner::RestoreObsoleteMethodMapsIfUnneeded(RedefinitionDataHolder& holder) {
   for (RedefinitionDataIter data = holder.begin(); data != holder.end(); ++data) {
     data.GetRedefinition().RestoreObsoleteMethodMapsIfUnneeded(&data);
   }
 }
 
+void Redefiner::MarkStructuralChanges(RedefinitionDataHolder& holder) {
+  for (RedefinitionDataIter data = holder.begin(); data != holder.end(); ++data) {
+    if (data.IsActuallyStructural()) {
+      // A superclass was structural and it marked all subclasses already. No need to do anything.
+      CHECK(!data.IsInitialStructural());
+    } else if (data.GetRedefinition().IsStructuralRedefinition()) {
+      data.SetActuallyStructural();
+      data.SetInitialStructural();
+      // Go over all potential subtypes and mark any that are actually subclasses as structural.
+      for (RedefinitionDataIter sub_data = data + 1; sub_data != holder.end(); ++sub_data) {
+        if (sub_data.GetRedefinition().GetMirrorClass()->IsSubClass(
+                data.GetRedefinition().GetMirrorClass())) {
+          sub_data.SetActuallyStructural();
+        }
+      }
+    }
+  }
+}
+
 bool Redefiner::EnsureAllClassAllocationsFinished(RedefinitionDataHolder& holder) {
   for (RedefinitionDataIter data = holder.begin(); data != holder.end(); ++data) {
     if (!data.GetRedefinition().EnsureClassAllocationsFinished(&data)) {
@@ -2082,10 +2179,20 @@
   return true;
 }
 
-bool Redefiner::FinishAllRemainingAllocations(RedefinitionDataHolder& holder) {
+bool Redefiner::FinishAllNewClassAllocations(RedefinitionDataHolder& holder) {
   for (RedefinitionDataIter data = holder.begin(); data != holder.end(); ++data) {
     // Allocate the data this redefinition requires.
-    if (!data.GetRedefinition().FinishRemainingAllocations(&data)) {
+    if (!data.GetRedefinition().FinishNewClassAllocations(holder, &data)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+bool Redefiner::FinishAllRemainingCommonAllocations(RedefinitionDataHolder& holder) {
+  for (RedefinitionDataIter data = holder.begin(); data != holder.end(); ++data) {
+    // Allocate the data this redefinition requires.
+    if (!data.GetRedefinition().FinishRemainingCommonAllocations(&data)) {
       return false;
     }
   }
@@ -2298,8 +2405,15 @@
 
 jvmtiError Redefiner::Run() {
   art::StackHandleScope<1> hs(self_);
-  // Allocate an array to hold onto all java temporary objects associated with this redefinition.
-  // We will let this be collected after the end of this function.
+  // Sort the redefinitions_ array topologically by class. This makes later steps easier since we
+  // know that every class precedes all of its supertypes.
+  std::sort(redefinitions_.begin(),
+            redefinitions_.end(),
+            [&](auto& l, auto& r) REQUIRES_SHARED(art::Locks::mutator_lock_) {
+              return CompareClasses(l.GetMirrorClass(), r.GetMirrorClass());
+            });
+  // Allocate an array to hold onto all java temporary objects associated with this
+  // redefinition. We will let this be collected after the end of this function.
   RedefinitionDataHolder holder(&hs, runtime_, self_, &redefinitions_);
   if (holder.IsNull()) {
     self_->AssertPendingOOMException();
@@ -2309,18 +2423,24 @@
   }
 
   // First we just allocate the ClassExt and its fields that we need. These can be updated
-  // atomically without any issues (since we allocate the map arrays as empty) so we don't bother
-  // doing a try loop. The other allocations we need to ensure that nothing has changed in the time
-  // between allocating them and pausing all threads before we can update them so we need to do a
-  // try loop.
-  if (!CheckAllRedefinitionAreValid() ||
-      !EnsureAllClassAllocationsFinished(holder) ||
-      !FinishAllRemainingAllocations(holder) ||
+  // atomically without any issues (since we allocate the map arrays as empty).
+  if (!CheckAllRedefinitionAreValid()) {
+    return result_;
+  }
+  // Mark structural changes.
+  MarkStructuralChanges(holder);
+  // Now we pause class loading. If we are doing a structural redefinition we will need to get an
+  // accurate picture of the classes loaded and having loads in the middle would make that
+  // impossible. This only pauses class-loading if we actually have at least one structural
+  // redefinition.
+  ScopedSuspendClassLoading suspend_class_load(self_, runtime_, holder);
+  if (!EnsureAllClassAllocationsFinished(holder) ||
+      !FinishAllRemainingCommonAllocations(holder) ||
+      !FinishAllNewClassAllocations(holder) ||
       !CheckAllClassesAreVerified(holder)) {
     return result_;
   }
 
-  ScopedSuspendClassLoading suspend_class_load(self_, runtime_, holder);
   ScopedSuspendAllocations suspend_alloc(runtime_, holder);
   if (!CollectAndCreateNewInstances(holder)) {
     return result_;
@@ -2592,7 +2712,8 @@
 }
 
 void Redefiner::ClassRedefinition::UpdateClassStructurally(const RedefinitionDataIter& holder) {
-  DCHECK(IsStructuralRedefinition());
+  DCHECK(holder.IsActuallyStructural());
+  DCHECK(holder.IsInitialStructural());
   // LETS GO. We've got all new class structures so no need to do all the updating of the stacks.
   // Instead we need to update everything else.
   // Just replace the class and be done with it.
@@ -2847,9 +2968,10 @@
 
 // Performs final updates to class for redefinition.
 void Redefiner::ClassRedefinition::UpdateClass(const RedefinitionDataIter& holder) {
-  if (IsStructuralRedefinition()) {
+  CHECK(holder.IsInitialized());
+  if (holder.IsInitialStructural()) {
     UpdateClassStructurally(holder);
-  } else {
+  } else if (!holder.IsActuallyStructural()) {
     UpdateClassInPlace(holder);
   }
   UpdateClassCommon(holder);
@@ -2877,7 +2999,7 @@
 // obsolete methods).
 void Redefiner::ClassRedefinition::RestoreObsoleteMethodMapsIfUnneeded(
     const RedefinitionDataIter* cur_data) {
-  if (IsStructuralRedefinition()) {
+  if (cur_data->IsActuallyStructural()) {
     // We didn't touch these in this case.
     return;
   }
@@ -2930,7 +3052,8 @@
     RecordFailure(ERR(OUT_OF_MEMORY), "Could not allocate ClassExt");
     return false;
   }
-  if (!IsStructuralRedefinition()) {
+  if (!cur_data->IsActuallyStructural()) {
+    CHECK(!IsStructuralRedefinition());
     // First save the old values of the 2 arrays that make up the obsolete methods maps. Then
     // allocate the 2 arrays that make up the obsolete methods map. Since the contents of the arrays
     // are only modified when all threads (other than the modifying one) are suspended we don't need
diff --git a/openjdkjvmti/ti_redefine.h b/openjdkjvmti/ti_redefine.h
index 36bc9d3..e419e57 100644
--- a/openjdkjvmti/ti_redefine.h
+++ b/openjdkjvmti/ti_redefine.h
@@ -125,6 +125,17 @@
     // NO_THREAD_SAFETY_ANALYSIS so we can unlock the class in the destructor.
     ~ClassRedefinition() NO_THREAD_SAFETY_ANALYSIS;
 
+    // Move assignment so we can sort these in a vector.
+    ClassRedefinition& operator=(ClassRedefinition&& other) {
+      driver_ = other.driver_;
+      klass_ = other.klass_;
+      dex_file_ = std::move(other.dex_file_);
+      class_sig_ = std::move(other.class_sig_);
+      original_dex_file_ = other.original_dex_file_;
+      other.driver_ = nullptr;
+      return *this;
+    }
+
     // Move constructor so we can put these into a vector.
     ClassRedefinition(ClassRedefinition&& other)
         : driver_(other.driver_),
@@ -135,6 +146,10 @@
       other.driver_ = nullptr;
     }
 
+    // No copy!
+    ClassRedefinition(ClassRedefinition&) = delete;
+    ClassRedefinition& operator=(ClassRedefinition&) = delete;
+
     art::ObjPtr<art::mirror::Class> GetMirrorClass() REQUIRES_SHARED(art::Locks::mutator_lock_);
     art::ObjPtr<art::mirror::ClassLoader> GetClassLoader()
         REQUIRES_SHARED(art::Locks::mutator_lock_);
@@ -154,9 +169,12 @@
       driver_->RecordFailure(e, class_sig_, err);
     }
 
-    bool FinishRemainingAllocations(/*out*/RedefinitionDataIter* cur_data)
+    bool FinishRemainingCommonAllocations(/*out*/RedefinitionDataIter* cur_data)
         REQUIRES_SHARED(art::Locks::mutator_lock_);
 
+    bool FinishNewClassAllocations(RedefinitionDataHolder& holder,
+                                   /*out*/RedefinitionDataIter* cur_data)
+        REQUIRES_SHARED(art::Locks::mutator_lock_);
     bool CollectAndCreateNewInstances(/*out*/RedefinitionDataIter* cur_data)
         REQUIRES_SHARED(art::Locks::mutator_lock_);
 
@@ -323,12 +341,15 @@
   jvmtiError Run() REQUIRES_SHARED(art::Locks::mutator_lock_);
 
   bool CheckAllRedefinitionAreValid() REQUIRES_SHARED(art::Locks::mutator_lock_);
-  bool CheckClassHierarchy() REQUIRES_SHARED(art::Locks::mutator_lock_);
   bool CheckAllClassesAreVerified(RedefinitionDataHolder& holder)
       REQUIRES_SHARED(art::Locks::mutator_lock_);
+  void MarkStructuralChanges(RedefinitionDataHolder& holder)
+      REQUIRES_SHARED(art::Locks::mutator_lock_);
   bool EnsureAllClassAllocationsFinished(RedefinitionDataHolder& holder)
       REQUIRES_SHARED(art::Locks::mutator_lock_);
-  bool FinishAllRemainingAllocations(RedefinitionDataHolder& holder)
+  bool FinishAllRemainingCommonAllocations(RedefinitionDataHolder& holder)
+      REQUIRES_SHARED(art::Locks::mutator_lock_);
+  bool FinishAllNewClassAllocations(RedefinitionDataHolder& holder)
       REQUIRES_SHARED(art::Locks::mutator_lock_);
   bool CollectAndCreateNewInstances(RedefinitionDataHolder& holder)
       REQUIRES_SHARED(art::Locks::mutator_lock_);
diff --git a/test/2003-double-virtual-structural/expected.txt b/test/2003-double-virtual-structural/expected.txt
new file mode 100644
index 0000000..3ace4f3
--- /dev/null
+++ b/test/2003-double-virtual-structural/expected.txt
@@ -0,0 +1,6 @@
+Hi(SubTransform called 1 times)
+Hi(SubTransform called 2 times)
+Hi(SubTransform called 3 times)
+Hello(SubTransform called 4 times, Transform called 1 times)
+Hello(SubTransform called 5 times, Transform called 2 times)
+Hello(SubTransform called 6 times, Transform called 3 times)
diff --git a/test/2003-double-virtual-structural/info.txt b/test/2003-double-virtual-structural/info.txt
new file mode 100644
index 0000000..9910b99
--- /dev/null
+++ b/test/2003-double-virtual-structural/info.txt
@@ -0,0 +1,4 @@
+Tests basic functions in the jvmti plugin.
+
+Tests that using the structural redefinition can add new virtual methods and fields that are
+accessed by a subtype undergoing non-structural redefinition simultaneously.
diff --git a/test/2003-double-virtual-structural/run b/test/2003-double-virtual-structural/run
new file mode 100755
index 0000000..b59f97c
--- /dev/null
+++ b/test/2003-double-virtual-structural/run
@@ -0,0 +1,17 @@
+#!/bin/bash
+#
+# Copyright 2019 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+./default-run "$@" --jvmti --runtime-option -Xopaque-jni-ids:true
diff --git a/test/2003-double-virtual-structural/src/Main.java b/test/2003-double-virtual-structural/src/Main.java
new file mode 100644
index 0000000..ab0145a
--- /dev/null
+++ b/test/2003-double-virtual-structural/src/Main.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+  public static void main(String[] args) throws Exception {
+    art.Test2003.run();
+  }
+}
diff --git a/test/2003-double-virtual-structural/src/art/Redefinition.java b/test/2003-double-virtual-structural/src/art/Redefinition.java
new file mode 120000
index 0000000..81eaf31
--- /dev/null
+++ b/test/2003-double-virtual-structural/src/art/Redefinition.java
@@ -0,0 +1 @@
+../../../jvmti-common/Redefinition.java
\ No newline at end of file
diff --git a/test/2003-double-virtual-structural/src/art/Test2003.java b/test/2003-double-virtual-structural/src/art/Test2003.java
new file mode 100644
index 0000000..e8a10e0
--- /dev/null
+++ b/test/2003-double-virtual-structural/src/art/Test2003.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package art;
+
+import java.util.Base64;
+public class Test2003 {
+
+  public static class Transform {
+    public String getGreeting() {
+      return "Hi";
+    }
+  }
+
+  public static class SubTransform extends Transform {
+    private int count = 0;
+    public void sayHi() {
+      System.out.println(getGreeting() + "(SubTransform called " + (++count) + " times)");
+    }
+  }
+  /**
+   * base64 encoded class/dex file for
+   * public static class SubTransform extends Transform {
+   *   private int count = 0;
+   *   public void sayHi() {
+   *     System.out.println(getGreeting() + "(SubTransform called " + (++count) + " times, Transform called " + getCount() + " times)");
+   *   }
+   * }
+   */
+  private static final byte[] SUBTRANSFORM_DEX_BYTES = Base64.getDecoder().decode(
+"ZGV4CjAzNQCh/FHVi1J2bdQclTBNUHHeAbrR2Sy2cWXoBQAAcAAAAHhWNBIAAAAAAAAAACQFAAAh" +
+"AAAAcAAAAAsAAAD0AAAABgAAACABAAACAAAAaAEAAAoAAAB4AQAAAQAAAMgBAAAABAAA6AEAAJ4C" +
+"AACnAgAAwgIAANkCAADhAgAA5AIAAOcCAADrAgAA7wIAAAwDAAAmAwAANgMAAFoDAAB6AwAAkQMA" +
+"AKUDAADAAwAA1AMAAOIDAADxAwAA9AMAAPgDAAAFBAAADQQAABQEAAAeBAAAKwQAADEEAAA2BAAA" +
+"PwQAAEYEAABQBAAAVwQAAAQAAAAIAAAACQAAAAoAAAALAAAADAAAAA0AAAAOAAAADwAAABAAAAAT" +
+"AAAABAAAAAAAAAAAAAAABQAAAAcAAAAAAAAABgAAAAgAAACQAgAABwAAAAgAAACYAgAAEwAAAAoA" +
+"AAAAAAAAFAAAAAoAAACYAgAAAQAAABcAAAAJAAYAGwAAAAEABAADAAAAAQAAABgAAAABAAEAGQAA" +
+"AAEABAAdAAAAAgAEAAMAAAAGAAUAHAAAAAgABAADAAAACAACABYAAAAIAAMAFgAAAAgAAQAeAAAA" +
+"AQAAAAEAAAACAAAAAAAAABIAAAAUBQAA9AQAAAAAAAACAAEAAQAAAIICAAAHAAAAcBAEAAEAEgBZ" +
+"EAAADgAAAAYAAQACAAAAhwIAADUAAABiAAEAbhACAAUADAFSUgAA2AICAVlSAABuEAEABQAKAyIE" +
+"CABwEAYABABuIAgAFAAaAQIAbiAIABQAbiAHACQAGgEBAG4gCAAUAG4gBwA0ABoBAABuIAgAFABu" +
+"EAkABAAMAW4gBQAQAA4ABQAOPAAIAA4BNA8AAAABAAAAAAAAAAEAAAAHAAcgdGltZXMpABkgdGlt" +
+"ZXMsIFRyYW5zZm9ybSBjYWxsZWQgABUoU3ViVHJhbnNmb3JtIGNhbGxlZCAABjxpbml0PgABSQAB" +
+"TAACTEkAAkxMABtMYXJ0L1Rlc3QyMDAzJFN1YlRyYW5zZm9ybTsAGExhcnQvVGVzdDIwMDMkVHJh" +
+"bnNmb3JtOwAOTGFydC9UZXN0MjAwMzsAIkxkYWx2aWsvYW5ub3RhdGlvbi9FbmNsb3NpbmdDbGFz" +
+"czsAHkxkYWx2aWsvYW5ub3RhdGlvbi9Jbm5lckNsYXNzOwAVTGphdmEvaW8vUHJpbnRTdHJlYW07" +
+"ABJMamF2YS9sYW5nL1N0cmluZzsAGUxqYXZhL2xhbmcvU3RyaW5nQnVpbGRlcjsAEkxqYXZhL2xh" +
+"bmcvU3lzdGVtOwAMU3ViVHJhbnNmb3JtAA1UZXN0MjAwMy5qYXZhAAFWAAJWTAALYWNjZXNzRmxh" +
+"Z3MABmFwcGVuZAAFY291bnQACGdldENvdW50AAtnZXRHcmVldGluZwAEbmFtZQADb3V0AAdwcmlu" +
+"dGxuAAVzYXlIaQAIdG9TdHJpbmcABXZhbHVlAIsBfn5EOHsiY29tcGlsYXRpb24tbW9kZSI6ImRl" +
+"YnVnIiwiaGFzLWNoZWNrc3VtcyI6ZmFsc2UsIm1pbi1hcGkiOjEsInNoYS0xIjoiODViZjE2Yzc1" +
+"NjUzZDQwNGE0YzNlZDQzNjA3Yzc3Yjg1YmFmMzFlZSIsInZlcnNpb24iOiIyLjAuNS1kZXYifQAC" +
+"BAEfGAMCBQIVBAkaFxEAAQEBAAIAgYAE6AMDAYgEAAAAAAIAAADlBAAA6wQAAAgFAAAAAAAAAAAA" +
+"AAAAAAAQAAAAAAAAAAEAAAAAAAAAAQAAACEAAABwAAAAAgAAAAsAAAD0AAAAAwAAAAYAAAAgAQAA" +
+"BAAAAAIAAABoAQAABQAAAAoAAAB4AQAABgAAAAEAAADIAQAAASAAAAIAAADoAQAAAyAAAAIAAACC" +
+"AgAAARAAAAIAAACQAgAAAiAAACEAAACeAgAABCAAAAIAAADlBAAAACAAAAEAAAD0BAAAAxAAAAIA" +
+"AAAEBQAABiAAAAEAAAAUBQAAABAAAAEAAAAkBQAA");
+
+  /**
+   * base64 encoded class/dex file for
+   * public static class Transform {
+   *   private int count;
+   *   public String getGreeting() {
+   *     incrCount();
+   *     return "Hello";
+   *   }
+   *   protected void incrCount() {
+   *     ++count;
+   *   }
+   *   protected int getCount() {
+   *     return count;
+   *   }
+   * }
+   */
+  private static final byte[] TRANSFORM_DEX_BYTES = Base64.getDecoder().decode(
+"ZGV4CjAzNQCAt16FlKvFzDaE6l56jUkorc7YXyrJmRpsBAAAcAAAAHhWNBIAAAAAAAAAALQDAAAV" +
+"AAAAcAAAAAgAAADEAAAAAwAAAOQAAAABAAAACAEAAAUAAAAQAQAAAQAAADgBAAAUAwAAWAEAANQB" +
+"AADcAQAA4wEAAOYBAADpAQAAAwIAABMCAAA3AgAAVwIAAGsCAAB/AgAAjgIAAJkCAACcAgAAqQIA" +
+"ALACAAC6AgAAxwIAANICAADYAgAA3wIAAAIAAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAMAAAA" +
+"AgAAAAAAAAAAAAAAAwAAAAYAAAAAAAAADAAAAAcAAAAAAAAAAQAAAA4AAAABAAIAAAAAAAEAAAAP" +
+"AAAAAQABABAAAAABAAIAEQAAAAUAAgAAAAAAAQAAAAEAAAAFAAAAAAAAAAoAAACkAwAAfAMAAAAA" +
+"AAACAAEAAAAAAMYBAAADAAAAUhAAAA8AAAACAAEAAQAAAMoBAAAGAAAAbhADAAEAGgABABEAAQAB" +
+"AAEAAADCAQAABAAAAHAQBAAAAA4AAgABAAAAAADPAQAABwAAAFIQAADYAAABWRAAAA4ACwAOABUA" +
+"DgAOAA48ABIADmkABjxpbml0PgAFSGVsbG8AAUkAAUwAGExhcnQvVGVzdDIwMDMkVHJhbnNmb3Jt" +
+"OwAOTGFydC9UZXN0MjAwMzsAIkxkYWx2aWsvYW5ub3RhdGlvbi9FbmNsb3NpbmdDbGFzczsAHkxk" +
+"YWx2aWsvYW5ub3RhdGlvbi9Jbm5lckNsYXNzOwASTGphdmEvbGFuZy9PYmplY3Q7ABJMamF2YS9s" +
+"YW5nL1N0cmluZzsADVRlc3QyMDAzLmphdmEACVRyYW5zZm9ybQABVgALYWNjZXNzRmxhZ3MABWNv" +
+"dW50AAhnZXRDb3VudAALZ2V0R3JlZXRpbmcACWluY3JDb3VudAAEbmFtZQAFdmFsdWUAiwF+fkQ4" +
+"eyJjb21waWxhdGlvbi1tb2RlIjoiZGVidWciLCJoYXMtY2hlY2tzdW1zIjpmYWxzZSwibWluLWFw" +
+"aSI6MSwic2hhLTEiOiI4NWJmMTZjNzU2NTNkNDA0YTRjM2VkNDM2MDdjNzdiODViYWYzMWVlIiwi" +
+"dmVyc2lvbiI6IjIuMC41LWRldiJ9AAIDARMYAgIEAg0ECRIXCwABAQMAAgCBgASMAwEE2AIBAfAC" +
+"AQSkAwAAAAACAAAAbQMAAHMDAACYAwAAAAAAAAAAAAAAAAAADwAAAAAAAAABAAAAAAAAAAEAAAAV" +
+"AAAAcAAAAAIAAAAIAAAAxAAAAAMAAAADAAAA5AAAAAQAAAABAAAACAEAAAUAAAAFAAAAEAEAAAYA" +
+"AAABAAAAOAEAAAEgAAAEAAAAWAEAAAMgAAAEAAAAwgEAAAIgAAAVAAAA1AEAAAQgAAACAAAAbQMA" +
+"AAAgAAABAAAAfAMAAAMQAAACAAAAlAMAAAYgAAABAAAApAMAAAAQAAABAAAAtAMAAA==");
+
+
+  public static void run() {
+    Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
+    doTest(new SubTransform());
+  }
+
+  public static void doTest(SubTransform t) {
+    t.sayHi();
+    t.sayHi();
+    t.sayHi();
+    Redefinition.doMultiStructuralClassRedefinition(
+        new Redefinition.CommonClassDefinition(SubTransform.class, null, SUBTRANSFORM_DEX_BYTES),
+        new Redefinition.CommonClassDefinition(Transform.class, null, TRANSFORM_DEX_BYTES));
+    t.sayHi();
+    t.sayHi();
+    t.sayHi();
+  }
+}
diff --git a/test/2004-double-virtual-structural-abstract/expected.txt b/test/2004-double-virtual-structural-abstract/expected.txt
new file mode 100644
index 0000000..c705270
--- /dev/null
+++ b/test/2004-double-virtual-structural-abstract/expected.txt
@@ -0,0 +1,2 @@
+Hi
+Hello Alex
diff --git a/test/2004-double-virtual-structural-abstract/info.txt b/test/2004-double-virtual-structural-abstract/info.txt
new file mode 100644
index 0000000..9910b99
--- /dev/null
+++ b/test/2004-double-virtual-structural-abstract/info.txt
@@ -0,0 +1,4 @@
+Tests basic functions in the jvmti plugin.
+
+Tests that using the structural redefinition can add new virtual methods and fields that are
+accessed by a subtype undergoing non-structural redefinition simultaneously.
diff --git a/test/2004-double-virtual-structural-abstract/run b/test/2004-double-virtual-structural-abstract/run
new file mode 100755
index 0000000..b59f97c
--- /dev/null
+++ b/test/2004-double-virtual-structural-abstract/run
@@ -0,0 +1,17 @@
+#!/bin/bash
+#
+# Copyright 2019 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+./default-run "$@" --jvmti --runtime-option -Xopaque-jni-ids:true
diff --git a/test/2004-double-virtual-structural-abstract/src/Main.java b/test/2004-double-virtual-structural-abstract/src/Main.java
new file mode 100644
index 0000000..592a7ba
--- /dev/null
+++ b/test/2004-double-virtual-structural-abstract/src/Main.java
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+public class Main {
+  public static void main(String[] args) throws Exception {
+    art.Test2004.run();
+  }
+}
diff --git a/test/2004-double-virtual-structural-abstract/src/art/Redefinition.java b/test/2004-double-virtual-structural-abstract/src/art/Redefinition.java
new file mode 120000
index 0000000..81eaf31
--- /dev/null
+++ b/test/2004-double-virtual-structural-abstract/src/art/Redefinition.java
@@ -0,0 +1 @@
+../../../jvmti-common/Redefinition.java
\ No newline at end of file
diff --git a/test/2004-double-virtual-structural-abstract/src/art/Test2004.java b/test/2004-double-virtual-structural-abstract/src/art/Test2004.java
new file mode 100644
index 0000000..d4a8c03
--- /dev/null
+++ b/test/2004-double-virtual-structural-abstract/src/art/Test2004.java
@@ -0,0 +1,114 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package art;
+
+import java.util.Base64;
+public class Test2004 {
+
+  public static abstract class Transform {
+    public String getGreeting() {
+      return "Hi";
+    }
+  }
+
+  public static class SubTransform extends Transform {
+    public void sayHi() {
+      System.out.println(getGreeting());
+    }
+  }
+  /**
+   * base64 encoded class/dex file for
+   * public static class SubTransform extends Transform {
+   *   private int count = 0;
+   *   public void sayHi() {
+   *     System.out.println(getGreeting());
+   *   }
+   *   public string getName() {
+   *     return "Alex";
+   *   }
+   * }
+   */
+  private static final byte[] SUBTRANSFORM_DEX_BYTES = Base64.getDecoder().decode(
+"ZGV4CjAzNQA5zD9gOMLav7UxQjoS9LNQj2bnqGOL4VrcBAAAcAAAAHhWNBIAAAAAAAAAABgEAAAa" +
+"AAAAcAAAAAoAAADYAAAAAwAAAAABAAACAAAAJAEAAAYAAAA0AQAAAQAAAGQBAABYAwAAhAEAAPYB" +
+"AAD+AQAABAIAAAcCAAAKAgAAJwIAAEECAABRAgAAdQIAAJUCAACsAgAAwAIAANQCAADiAgAA8QIA" +
+"APQCAAD4AgAABQMAAAwDAAAZAwAAIgMAACgDAAAtAwAANgMAAD0DAABEAwAAAgAAAAQAAAAFAAAA" +
+"BgAAAAcAAAAIAAAACQAAAAoAAAALAAAADgAAAAMAAAAHAAAAAAAAAA4AAAAJAAAAAAAAAA8AAAAJ" +
+"AAAA8AEAAAEAAAARAAAACAAGABUAAAABAAEAAAAAAAEAAAASAAAAAQAAABMAAAABAAEAFwAAAAIA" +
+"AQAAAAAABgACABYAAAABAAAAAQAAAAIAAAAAAAAADQAAAAgEAADhAwAAAAAAAAIAAQAAAAAA5QEA" +
+"AAMAAAAaAAEAEQAAAAIAAQABAAAA4AEAAAcAAABwEAQAAQASAFkQAAAOAAAAAwABAAIAAADpAQAA" +
+"CgAAAGIAAQBuEAEAAgAMAW4gBQAQAA4ACgAOPAAQAA4ADQAOlgAAAAEAAAAHAAY8aW5pdD4ABEFs" +
+"ZXgAAUkAAUwAG0xhcnQvVGVzdDIwMDQkU3ViVHJhbnNmb3JtOwAYTGFydC9UZXN0MjAwNCRUcmFu" +
+"c2Zvcm07AA5MYXJ0L1Rlc3QyMDA0OwAiTGRhbHZpay9hbm5vdGF0aW9uL0VuY2xvc2luZ0NsYXNz" +
+"OwAeTGRhbHZpay9hbm5vdGF0aW9uL0lubmVyQ2xhc3M7ABVMamF2YS9pby9QcmludFN0cmVhbTsA" +
+"EkxqYXZhL2xhbmcvU3RyaW5nOwASTGphdmEvbGFuZy9TeXN0ZW07AAxTdWJUcmFuc2Zvcm0ADVRl" +
+"c3QyMDA0LmphdmEAAVYAAlZMAAthY2Nlc3NGbGFncwAFY291bnQAC2dldEdyZWV0aW5nAAdnZXRO" +
+"YW1lAARuYW1lAANvdXQAB3ByaW50bG4ABXNheUhpAAV2YWx1ZQCLAX5+RDh7ImNvbXBpbGF0aW9u" +
+"LW1vZGUiOiJkZWJ1ZyIsImhhcy1jaGVja3N1bXMiOmZhbHNlLCJtaW4tYXBpIjoxLCJzaGEtMSI6" +
+"Ijg1YmYxNmM3NTY1M2Q0MDRhNGMzZWQ0MzYwN2M3N2I4NWJhZjMxZWUiLCJ2ZXJzaW9uIjoiMi4w" +
+"LjUtZGV2In0AAgQBGBgDAgUCEAQJFBcMAAEBAgACAIGABJwDAgGEAwEBvAMAAAAAAAAAAgAAANID" +
+"AADYAwAA/AMAAAAAAAAAAAAAAAAAABAAAAAAAAAAAQAAAAAAAAABAAAAGgAAAHAAAAACAAAACgAA" +
+"ANgAAAADAAAAAwAAAAABAAAEAAAAAgAAACQBAAAFAAAABgAAADQBAAAGAAAAAQAAAGQBAAABIAAA" +
+"AwAAAIQBAAADIAAAAwAAAOABAAABEAAAAQAAAPABAAACIAAAGgAAAPYBAAAEIAAAAgAAANIDAAAA" +
+"IAAAAQAAAOEDAAADEAAAAgAAAPgDAAAGIAAAAQAAAAgEAAAAEAAAAQAAABgEAAA=");
+
+  /**
+   * base64 encoded class/dex file for
+   * public static abstract class Transform {
+   *   public String getGreeting() {
+   *     return "Hello " + getName();
+   *   }
+   *   public abstract string getName();
+   * }
+   */
+  private static final byte[] TRANSFORM_DEX_BYTES = Base64.getDecoder().decode(
+"ZGV4CjAzNQDtwEbrWZHwf9ALLXnPJ2zRU6kQs/yHTCJ4BAAAcAAAAHhWNBIAAAAAAAAAAMADAAAW" +
+"AAAAcAAAAAgAAADIAAAAAwAAAOgAAAAAAAAAAAAAAAcAAAAMAQAAAQAAAEQBAAAUAwAAZAEAAMYB" +
+"AADOAQAA1gEAANkBAADdAQAA9wEAAAcCAAArAgAASwIAAF8CAABzAgAAjgIAAJ0CAACoAgAAqwIA" +
+"ALgCAADAAgAAzQIAANYCAADcAgAA5gIAAO0CAAAEAAAABQAAAAYAAAAHAAAACAAAAAkAAAAKAAAA" +
+"DQAAAAIAAAAFAAAAAAAAAAMAAAAGAAAAwAEAAA0AAAAHAAAAAAAAAAAAAgAAAAAAAAAAABAAAAAA" +
+"AAAAEQAAAAQAAgAAAAAABgACAAAAAAAGAAEADwAAAAYAAAATAAAAAAAAAAEEAAAEAAAAAAAAAAsA" +
+"AACwAwAAiwMAAAAAAAAEAAEAAgAAALwBAAAWAAAAbhACAAMADAAiAQYAcBAEAAEAGgIBAG4gBQAh" +
+"AG4gBQABAG4QBgABAAwAEQABAAEAAQAAALgBAAAEAAAAcBADAAAADgAEAA4ABgAOAAEAAAAFAAY8" +
+"aW5pdD4ABkhlbGxvIAABTAACTEwAGExhcnQvVGVzdDIwMDQkVHJhbnNmb3JtOwAOTGFydC9UZXN0" +
+"MjAwNDsAIkxkYWx2aWsvYW5ub3RhdGlvbi9FbmNsb3NpbmdDbGFzczsAHkxkYWx2aWsvYW5ub3Rh" +
+"dGlvbi9Jbm5lckNsYXNzOwASTGphdmEvbGFuZy9PYmplY3Q7ABJMamF2YS9sYW5nL1N0cmluZzsA" +
+"GUxqYXZhL2xhbmcvU3RyaW5nQnVpbGRlcjsADVRlc3QyMDA0LmphdmEACVRyYW5zZm9ybQABVgAL" +
+"YWNjZXNzRmxhZ3MABmFwcGVuZAALZ2V0R3JlZXRpbmcAB2dldE5hbWUABG5hbWUACHRvU3RyaW5n" +
+"AAV2YWx1ZQCLAX5+RDh7ImNvbXBpbGF0aW9uLW1vZGUiOiJkZWJ1ZyIsImhhcy1jaGVja3N1bXMi" +
+"OmZhbHNlLCJtaW4tYXBpIjoxLCJzaGEtMSI6Ijg1YmYxNmM3NTY1M2Q0MDRhNGMzZWQ0MzYwN2M3" +
+"N2I4NWJhZjMxZWUiLCJ2ZXJzaW9uIjoiMi4wLjUtZGV2In0AAgIBFBgBAgMCDiQJBBIXDAAAAQIA" +
+"gYAEoAMBAeQCAYEIAAAAAAAAAAACAAAAewMAAIEDAACkAwAAAAAAAAAAAAAAAAAADwAAAAAAAAAB" +
+"AAAAAAAAAAEAAAAWAAAAcAAAAAIAAAAIAAAAyAAAAAMAAAADAAAA6AAAAAUAAAAHAAAADAEAAAYA" +
+"AAABAAAARAEAAAEgAAACAAAAZAEAAAMgAAACAAAAuAEAAAEQAAABAAAAwAEAAAIgAAAWAAAAxgEA" +
+"AAQgAAACAAAAewMAAAAgAAABAAAAiwMAAAMQAAACAAAAoAMAAAYgAAABAAAAsAMAAAAQAAABAAAA" +
+"wAMAAA==");
+
+
+  public static void run() {
+    Redefinition.setTestConfiguration(Redefinition.Config.COMMON_REDEFINE);
+    doTest(new SubTransform());
+  }
+
+  public static void doTest(SubTransform t) {
+    t.sayHi();
+    Redefinition.doMultiStructuralClassRedefinition(
+        new Redefinition.CommonClassDefinition(SubTransform.class, null, SUBTRANSFORM_DEX_BYTES),
+        new Redefinition.CommonClassDefinition(Transform.class, null, TRANSFORM_DEX_BYTES));
+    t.sayHi();
+  }
+}