diff --git a/agent/make/jsdbproc64.sh b/agent/make/jsdbproc64.sh
index 9f8007e3db9a68578383493f57510690060cd542..ac7d9c3b6ba43b5d7f06611d5e9d2cd3d6ee26a6 100644
--- a/agent/make/jsdbproc64.sh
+++ b/agent/make/jsdbproc64.sh
@@ -1,7 +1,7 @@
-#!/bin/sh
+#!/bin/sh
 
 #
-# Copyright (c) 2004, Oracle and/or its affiliates. All rights reserved.
+# Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
 # DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 #
 # This code is free software; you can redistribute it and/or modify it
@@ -21,10 +21,10 @@
 # Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 # or visit www.oracle.com if you need additional information or have any
 # questions.
-#  
 #
+#
+
+
+. `dirname $0`/saenv64.sh
 
-
-. `dirname $0`/saenv64.sh
-
-$SA_JAVA_CMD sun.jvm.hotspot.tools.JSDB $*
+$SA_JAVA_CMD sun.jvm.hotspot.tools.soql.JSDB $*
diff --git a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1HeapRegionTable.java b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1HeapRegionTable.java
index 11657ce31da504716b7b371741c4142016530c18..cfbea40435c0ce1bb7375e6e376f570dbf566fdf 100644
--- a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1HeapRegionTable.java
+++ b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/G1HeapRegionTable.java
@@ -103,14 +103,14 @@ public class G1HeapRegionTable extends VMObject {
         @Override
         public void remove()     { /* not supported */    }
 
-        HeapRegionIterator(Address addr) {
+        HeapRegionIterator(long committedLength) {
             index = 0;
-            length = length();
+            length = committedLength;
         }
     }
 
-    public Iterator<HeapRegion> heapRegionIterator() {
-        return new HeapRegionIterator(addr);
+    public Iterator<HeapRegion> heapRegionIterator(long committedLength) {
+        return new HeapRegionIterator(committedLength);
     }
 
     public G1HeapRegionTable(Address addr) {
diff --git a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java
index f8b47abeddc78528ba4b394f268bfff24f9da1e7..190bf56a17f79553f0622ddbc20c15d09eb5eced 100644
--- a/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java
+++ b/agent/src/share/classes/sun/jvm/hotspot/gc_implementation/g1/HeapRegionSeq.java
@@ -42,6 +42,8 @@ import sun.jvm.hotspot.types.TypeDataBase;
 public class HeapRegionSeq extends VMObject {
     // G1HeapRegionTable _regions
     static private long regionsFieldOffset;
+    // uint _committed_length
+    static private CIntegerField committedLengthField;
 
     static {
         VM.registerVMInitializedObserver(new Observer() {
@@ -55,6 +57,7 @@ public class HeapRegionSeq extends VMObject {
         Type type = db.lookupType("HeapRegionSeq");
 
         regionsFieldOffset = type.getField("_regions").getOffset();
+        committedLengthField = type.getCIntegerField("_committed_length");
     }
 
     private G1HeapRegionTable regions() {
@@ -67,8 +70,12 @@ public class HeapRegionSeq extends VMObject {
         return regions().length();
     }
 
+    public long committedLength() {
+        return committedLengthField.getValue(addr);
+    }
+
     public Iterator<HeapRegion> heapRegionIterator() {
-        return regions().heapRegionIterator();
+        return regions().heapRegionIterator(committedLength());
     }
 
     public HeapRegionSeq(Address addr) {
diff --git a/make/hotspot_version b/make/hotspot_version
index f2c98d1cb19f6e52c018f42ed7d32f684b22dc66..94de662e7b49a45f5325f1605f2e36a3620f705c 100644
--- a/make/hotspot_version
+++ b/make/hotspot_version
@@ -35,7 +35,7 @@ HOTSPOT_VM_COPYRIGHT=Copyright 2013
 
 HS_MAJOR_VER=25
 HS_MINOR_VER=0
-HS_BUILD_NUMBER=61
+HS_BUILD_NUMBER=62
 
 JDK_MAJOR_VER=1
 JDK_MINOR_VER=8
diff --git a/src/cpu/sparc/vm/vm_version_sparc.cpp b/src/cpu/sparc/vm/vm_version_sparc.cpp
index 392b7f5d927be2c2edfeafbc355f510cc144bfe6..84aff34fafde73789729ff55315fc4626bc92c3e 100644
--- a/src/cpu/sparc/vm/vm_version_sparc.cpp
+++ b/src/cpu/sparc/vm/vm_version_sparc.cpp
@@ -89,6 +89,27 @@ void VM_Version::initialize() {
   _supports_cx8 = has_v9();
   _supports_atomic_getset4 = true; // swap instruction
 
+  // There are Fujitsu Sparc64 CPUs which support blk_init as well so
+  // we have to take this check out of the 'is_niagara()' block below.
+  if (has_blk_init()) {
+    // When using CMS or G1, we cannot use memset() in BOT updates
+    // because the sun4v/CMT version in libc_psr uses BIS which
+    // exposes "phantom zeros" to concurrent readers. See 6948537.
+    if (FLAG_IS_DEFAULT(UseMemSetInBOT) && (UseConcMarkSweepGC || UseG1GC)) {
+      FLAG_SET_DEFAULT(UseMemSetInBOT, false);
+    }
+    // Issue a stern warning if the user has explicitly set
+    // UseMemSetInBOT (it is known to cause issues), but allow
+    // use for experimentation and debugging.
+    if (UseConcMarkSweepGC || UseG1GC) {
+      if (UseMemSetInBOT) {
+        assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error");
+        warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability"
+                " on sun4v; please understand that you are using at your own risk!");
+      }
+    }
+  }
+
   if (is_niagara()) {
     // Indirect branch is the same cost as direct
     if (FLAG_IS_DEFAULT(UseInlineCaches)) {
@@ -98,12 +119,6 @@ void VM_Version::initialize() {
     if (FLAG_IS_DEFAULT(OptoLoopAlignment)) {
       FLAG_SET_DEFAULT(OptoLoopAlignment, 4);
     }
-    // When using CMS or G1, we cannot use memset() in BOT updates
-    // because the sun4v/CMT version in libc_psr uses BIS which
-    // exposes "phantom zeros" to concurrent readers. See 6948537.
-    if (FLAG_IS_DEFAULT(UseMemSetInBOT) && (UseConcMarkSweepGC || UseG1GC)) {
-      FLAG_SET_DEFAULT(UseMemSetInBOT, false);
-    }
 #ifdef _LP64
     // 32-bit oops don't make sense for the 64-bit VM on sparc
     // since the 32-bit VM has the same registers and smaller objects.
diff --git a/src/cpu/sparc/vm/vm_version_sparc.hpp b/src/cpu/sparc/vm/vm_version_sparc.hpp
index f4cc8bf56b39c9a5f0679e842dc97a3edf1e11b9..c8faa7836b68a3f9765545adc3d6be1ca2dc4c0a 100644
--- a/src/cpu/sparc/vm/vm_version_sparc.hpp
+++ b/src/cpu/sparc/vm/vm_version_sparc.hpp
@@ -94,7 +94,13 @@ protected:
   static bool is_M_family(int features) { return (features & M_family_m) != 0; }
   static bool is_T_family(int features) { return (features & T_family_m) != 0; }
   static bool is_niagara() { return is_T_family(_features); }
-  DEBUG_ONLY( static bool is_niagara(int features)  { return (features & sun4v_m) != 0; } )
+#ifdef ASSERT
+  static bool is_niagara(int features)  {
+    // 'sun4v_m' may be defined on both Sun/Oracle Sparc CPUs as well as
+    // on Fujitsu Sparc64 CPUs, but only Sun/Oracle Sparcs can be 'niagaras'.
+    return (features & sun4v_m) != 0 && (features & sparc64_family_m) == 0;
+  }
+#endif
 
   // Returns true if it is niagara1 (T1).
   static bool is_T1_model(int features) { return is_T_family(features) && ((features & T1_model_m) != 0); }
diff --git a/src/cpu/x86/vm/c1_Runtime1_x86.cpp b/src/cpu/x86/vm/c1_Runtime1_x86.cpp
index f2210f0d35d622eec15374a025dc1c7f66a14405..2f562bbd318b3c3f83419691fb26b2117356828a 100644
--- a/src/cpu/x86/vm/c1_Runtime1_x86.cpp
+++ b/src/cpu/x86/vm/c1_Runtime1_x86.cpp
@@ -1719,10 +1719,12 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
 
         BarrierSet* bs = Universe::heap()->barrier_set();
         CardTableModRefBS* ct = (CardTableModRefBS*)bs;
+        assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
+
         Label done;
         Label runtime;
 
-        // At this point we know new_value is non-NULL and the new_value crosses regsion.
+        // At this point we know new_value is non-NULL and the new_value crosses regions.
         // Must check to see if card is already dirty
 
         const Register thread = NOT_LP64(rax) LP64_ONLY(r15_thread);
@@ -1735,26 +1737,17 @@ OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
         __ push(rax);
         __ push(rcx);
 
-        NOT_LP64(__ get_thread(thread);)
-        ExternalAddress cardtable((address)ct->byte_map_base);
-        assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
-
+        const Register cardtable = rax;
         const Register card_addr = rcx;
-#ifdef _LP64
-        const Register tmp = rscratch1;
+
         f.load_argument(0, card_addr);
-        __ shrq(card_addr, CardTableModRefBS::card_shift);
-        __ lea(tmp, cardtable);
-        // get the address of the card
-        __ addq(card_addr, tmp);
-#else
-        const Register card_index = rcx;
-        f.load_argument(0, card_index);
-        __ shrl(card_index, CardTableModRefBS::card_shift);
+        __ shrptr(card_addr, CardTableModRefBS::card_shift);
+        // Do not use ExternalAddress to load 'byte_map_base', since 'byte_map_base' is NOT
+        // a valid address and therefore is not properly handled by the relocation code.
+        __ movptr(cardtable, (intptr_t)ct->byte_map_base);
+        __ addptr(card_addr, cardtable);
 
-        Address index(noreg, card_index, Address::times_1);
-        __ leal(card_addr, __ as_Address(ArrayAddress(cardtable, index)));
-#endif
+        NOT_LP64(__ get_thread(thread);)
 
         __ cmpb(Address(card_addr, 0), (int)G1SATBCardTableModRefBS::g1_young_card_val());
         __ jcc(Assembler::equal, done);
diff --git a/src/cpu/x86/vm/macroAssembler_x86.cpp b/src/cpu/x86/vm/macroAssembler_x86.cpp
index 5059a386371ca740615c5a14f6128ba514d1d32e..b4797bf3a39d6712c7e7bd1ab93945f5cef3fdc7 100644
--- a/src/cpu/x86/vm/macroAssembler_x86.cpp
+++ b/src/cpu/x86/vm/macroAssembler_x86.cpp
@@ -3354,6 +3354,8 @@ void MacroAssembler::g1_write_barrier_post(Register store_addr,
 
   BarrierSet* bs = Universe::heap()->barrier_set();
   CardTableModRefBS* ct = (CardTableModRefBS*)bs;
+  assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
+
   Label done;
   Label runtime;
 
@@ -3371,28 +3373,16 @@ void MacroAssembler::g1_write_barrier_post(Register store_addr,
 
   // storing region crossing non-NULL, is card already dirty?
 
-  ExternalAddress cardtable((address) ct->byte_map_base);
-  assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code");
-#ifdef _LP64
   const Register card_addr = tmp;
+  const Register cardtable = tmp2;
 
-  movq(card_addr, store_addr);
-  shrq(card_addr, CardTableModRefBS::card_shift);
-
-  lea(tmp2, cardtable);
+  movptr(card_addr, store_addr);
+  shrptr(card_addr, CardTableModRefBS::card_shift);
+  // Do not use ExternalAddress to load 'byte_map_base', since 'byte_map_base' is NOT
+  // a valid address and therefore is not properly handled by the relocation code.
+  movptr(cardtable, (intptr_t)ct->byte_map_base);
+  addptr(card_addr, cardtable);
 
-  // get the address of the card
-  addq(card_addr, tmp2);
-#else
-  const Register card_index = tmp;
-
-  movl(card_index, store_addr);
-  shrl(card_index, CardTableModRefBS::card_shift);
-
-  Address index(noreg, card_index, Address::times_1);
-  const Register card_addr = tmp;
-  lea(card_addr, as_Address(ArrayAddress(cardtable, index)));
-#endif
   cmpb(Address(card_addr, 0), (int)G1SATBCardTableModRefBS::g1_young_card_val());
   jcc(Assembler::equal, done);
 
@@ -3416,7 +3406,7 @@ void MacroAssembler::g1_write_barrier_post(Register store_addr,
   movq(Address(tmp2, 0), card_addr);
 #else
   addl(tmp2, queue_index);
-  movl(Address(tmp2, 0), card_index);
+  movl(Address(tmp2, 0), card_addr);
 #endif
   jmp(done);
 
@@ -3468,25 +3458,19 @@ void MacroAssembler::store_check_part_2(Register obj) {
 
   // The calculation for byte_map_base is as follows:
   // byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift);
-  // So this essentially converts an address to a displacement and
-  // it will never need to be relocated. On 64bit however the value may be too
-  // large for a 32bit displacement
-
+  // So this essentially converts an address to a displacement and it will
+  // never need to be relocated. On 64bit however the value may be too
+  // large for a 32bit displacement.
   intptr_t disp = (intptr_t) ct->byte_map_base;
   if (is_simm32(disp)) {
     Address cardtable(noreg, obj, Address::times_1, disp);
     movb(cardtable, 0);
   } else {
-    // By doing it as an ExternalAddress disp could be converted to a rip-relative
-    // displacement and done in a single instruction given favorable mapping and
-    // a smarter version of as_Address. Worst case it is two instructions which
-    // is no worse off then loading disp into a register and doing as a simple
-    // Address() as above.
-    // We can't do as ExternalAddress as the only style since if disp == 0 we'll
-    // assert since NULL isn't acceptable in a reloci (see 6644928). In any case
-    // in some cases we'll get a single instruction version.
-
-    ExternalAddress cardtable((address)disp);
+    // By doing it as an ExternalAddress 'disp' could be converted to a rip-relative
+    // displacement and done in a single instruction given favorable mapping and a
+    // smarter version of as_Address. However, 'ExternalAddress' generates a relocation
+    // entry and that entry is not properly handled by the relocation code.
+    AddressLiteral cardtable((address)ct->byte_map_base, relocInfo::none);
     Address index(noreg, obj, Address::times_1);
     movb(as_Address(ArrayAddress(cardtable, index)), 0);
   }
diff --git a/src/share/vm/classfile/defaultMethods.cpp b/src/share/vm/classfile/defaultMethods.cpp
index 619856d69e5a5dbb0719d0a3ee53d8a6c2b2b7eb..129eecbad3b89cd1ec11eed8296968b1de9509f1 100644
--- a/src/share/vm/classfile/defaultMethods.cpp
+++ b/src/share/vm/classfile/defaultMethods.cpp
@@ -625,13 +625,13 @@ static GrowableArray<EmptyVtableSlot*>* find_empty_vtable_slots(
   while (super != NULL) {
     for (int i = 0; i < super->methods()->length(); ++i) {
       Method* m = super->methods()->at(i);
-      if (m->is_overpass()) {
+      if (m->is_overpass() || m->is_static()) {
         // m is a method that would have been a miranda if not for the
         // default method processing that occurred on behalf of our superclass,
         // so it's a method we want to re-examine in this new context.  That is,
         // unless we have a real implementation of it in the current class.
         Method* impl = klass->lookup_method(m->name(), m->signature());
-        if (impl == NULL || impl->is_overpass()) {
+        if (impl == NULL || impl->is_overpass() || impl->is_static()) {
           if (!already_in_vtable_slots(slots, m)) {
             slots->append(new EmptyVtableSlot(m));
           }
@@ -648,7 +648,7 @@ static GrowableArray<EmptyVtableSlot*>* find_empty_vtable_slots(
         // so it's a method we want to re-examine in this new context.  That is,
         // unless we have a real implementation of it in the current class.
         Method* impl = klass->lookup_method(m->name(), m->signature());
-        if (impl == NULL || impl->is_overpass()) {
+        if (impl == NULL || impl->is_overpass() || impl->is_static()) {
           if (!already_in_vtable_slots(slots, m)) {
             slots->append(new EmptyVtableSlot(m));
           }
diff --git a/src/share/vm/gc_implementation/shared/markSweep.cpp b/src/share/vm/gc_implementation/shared/markSweep.cpp
index 7bdcd55f5874257fdb24c290ae6af390c74b0cf4..1bc3ea46a3e8b513aaac034f59cce2364c422f9c 100644
--- a/src/share/vm/gc_implementation/shared/markSweep.cpp
+++ b/src/share/vm/gc_implementation/shared/markSweep.cpp
@@ -66,29 +66,10 @@ void MarkSweep::AdjustKlassClosure::do_klass(Klass* klass) {
   klass->oops_do(&MarkSweep::adjust_pointer_closure);
 }
 
-void MarkSweep::follow_klass(Klass* klass) {
-  ClassLoaderData* cld = klass->class_loader_data();
-  // The actual processing of the klass is done when we
-  // traverse the list of Klasses in the class loader data.
-  MarkSweep::follow_class_loader(cld);
-}
-
-void MarkSweep::adjust_klass(Klass* klass) {
-  ClassLoaderData* cld = klass->class_loader_data();
-  // The actual processing of the klass is done when we
-  // traverse the list of Klasses in the class loader data.
-  MarkSweep::adjust_class_loader(cld);
-}
-
 void MarkSweep::follow_class_loader(ClassLoaderData* cld) {
   cld->oops_do(&MarkSweep::mark_and_push_closure, &MarkSweep::follow_klass_closure, true);
 }
 
-void MarkSweep::adjust_class_loader(ClassLoaderData* cld) {
-  cld->oops_do(&MarkSweep::adjust_pointer_closure, &MarkSweep::adjust_klass_closure, true);
-}
-
-
 void MarkSweep::follow_stack() {
   do {
     while (!_marking_stack.is_empty()) {
diff --git a/src/share/vm/gc_implementation/shared/markSweep.hpp b/src/share/vm/gc_implementation/shared/markSweep.hpp
index 2c08a6897f42f08560f9e037a1f794be08c7c2d7..38fc8e7058969ce00079948bf70f782527a7e62f 100644
--- a/src/share/vm/gc_implementation/shared/markSweep.hpp
+++ b/src/share/vm/gc_implementation/shared/markSweep.hpp
@@ -172,10 +172,8 @@ class MarkSweep : AllStatic {
   static void follow_stack();   // Empty marking stack.
 
   static void follow_klass(Klass* klass);
-  static void adjust_klass(Klass* klass);
 
   static void follow_class_loader(ClassLoaderData* cld);
-  static void adjust_class_loader(ClassLoaderData* cld);
 
   static void preserve_mark(oop p, markOop mark);
                                 // Save the mark word so it can be restored later
diff --git a/src/share/vm/gc_implementation/shared/markSweep.inline.hpp b/src/share/vm/gc_implementation/shared/markSweep.inline.hpp
index 8ffe0f782362ed2a7d7d63cd0a0c600bd13b7767..e70e3af1bc1d37f5578dd6249ccaeb826e52e9f4 100644
--- a/src/share/vm/gc_implementation/shared/markSweep.inline.hpp
+++ b/src/share/vm/gc_implementation/shared/markSweep.inline.hpp
@@ -44,6 +44,11 @@ inline void MarkSweep::mark_object(oop obj) {
   }
 }
 
+inline void MarkSweep::follow_klass(Klass* klass) {
+  oop op = klass->klass_holder();
+  MarkSweep::mark_and_push(&op);
+}
+
 template <class T> inline void MarkSweep::follow_root(T* p) {
   assert(!Universe::heap()->is_in_reserved(p),
          "roots shouldn't be things within the heap");
diff --git a/src/share/vm/interpreter/linkResolver.cpp b/src/share/vm/interpreter/linkResolver.cpp
index da5a1e7534b78cff73658b4d62451fe21fa681c3..573ccc1cf62df55b9534b18e8e46784862ba77a2 100644
--- a/src/share/vm/interpreter/linkResolver.cpp
+++ b/src/share/vm/interpreter/linkResolver.cpp
@@ -242,7 +242,7 @@ void LinkResolver::resolve_klass(KlassHandle& result, constantPoolHandle pool, i
 
 // Look up method in klasses, including static methods
 // Then look up local default methods
-void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS) {
+void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, bool checkpolymorphism, TRAPS) {
   Method* result_oop = klass->uncached_lookup_method(name, signature);
   if (result_oop == NULL) {
     Array<Method*>* default_methods = InstanceKlass::cast(klass())->default_methods();
@@ -251,7 +251,7 @@ void LinkResolver::lookup_method_in_klasses(methodHandle& result, KlassHandle kl
     }
   }
 
-  if (EnableInvokeDynamic && result_oop != NULL) {
+  if (checkpolymorphism && EnableInvokeDynamic && result_oop != NULL) {
     vmIntrinsics::ID iid = result_oop->intrinsic_id();
     if (MethodHandles::is_signature_polymorphic(iid)) {
       // Do not link directly to these.  The VM must produce a synthetic one using lookup_polymorphic_method.
@@ -267,8 +267,8 @@ void LinkResolver::lookup_instance_method_in_klasses(methodHandle& result, Klass
   Method* result_oop = klass->uncached_lookup_method(name, signature);
   result = methodHandle(THREAD, result_oop);
   while (!result.is_null() && result->is_static() && result->method_holder()->super() != NULL) {
-    klass = KlassHandle(THREAD, result->method_holder()->super());
-    result = methodHandle(THREAD, klass->uncached_lookup_method(name, signature));
+    KlassHandle super_klass = KlassHandle(THREAD, result->method_holder()->super());
+    result = methodHandle(THREAD, super_klass->uncached_lookup_method(name, signature));
   }
 
   if (result.is_null()) {
@@ -503,11 +503,14 @@ void LinkResolver::resolve_method_statically(methodHandle& resolved_method, Klas
   }
 
   if (code == Bytecodes::_invokeinterface) {
-    resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, CHECK);
+    resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
   } else if (code == Bytecodes::_invokevirtual) {
     resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, true, CHECK);
-  } else {
+  } else if (!resolved_klass->is_interface()) {
     resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, false, CHECK);
+  } else {
+    bool nostatics = (code == Bytecodes::_invokestatic) ? false : true;
+    resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, true, nostatics, CHECK);
   }
 }
 
@@ -528,7 +531,7 @@ void LinkResolver::resolve_method(methodHandle& resolved_method, KlassHandle res
   }
 
   // 2. lookup method in resolved klass and its super klasses
-  lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK);
+  lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, true, CHECK);
 
   if (resolved_method.is_null()) { // not found in the class hierarchy
     // 3. lookup method in all the interfaces implemented by the resolved klass
@@ -612,7 +615,8 @@ void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
                                             Symbol* method_name,
                                             Symbol* method_signature,
                                             KlassHandle current_klass,
-                                            bool check_access, TRAPS) {
+                                            bool check_access,
+                                            bool nostatics, TRAPS) {
 
  // check if klass is interface
   if (!resolved_klass->is_interface()) {
@@ -623,7 +627,8 @@ void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
   }
 
   // lookup method in this interface or its super, java.lang.Object
-  lookup_instance_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, CHECK);
+  // JDK8: also look for static methods
+  lookup_method_in_klasses(resolved_method, resolved_klass, method_name, method_signature, false, CHECK);
 
   if (resolved_method.is_null()) {
     // lookup method in all the super-interfaces
@@ -638,6 +643,16 @@ void LinkResolver::resolve_interface_method(methodHandle& resolved_method,
     }
   }
 
+  if (nostatics && resolved_method->is_static()) {
+    ResourceMark rm(THREAD);
+    char buf[200];
+    jio_snprintf(buf, sizeof(buf), "Expected instance not static method %s", Method::name_and_sig_as_C_string(resolved_klass(),
+                                                      resolved_method->name(),
+                                                      resolved_method->signature()));
+    THROW_MSG(vmSymbols::java_lang_IncompatibleClassChangeError(), buf);
+  }
+
+
   if (check_access) {
     // JDK8 adds non-public interface methods, and accessability check requirement
     assert(current_klass.not_null() , "current_klass should not be null");
@@ -864,7 +879,11 @@ void LinkResolver::linktime_resolve_static_method(methodHandle& resolved_method,
                                                   Symbol* method_name, Symbol* method_signature,
                                                   KlassHandle current_klass, bool check_access, TRAPS) {
 
-  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, false, CHECK);
+  if (!resolved_klass->is_interface()) {
+    resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, false, CHECK);
+  } else {
+    resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, false, CHECK);
+  }
   assert(resolved_method->name() != vmSymbols::class_initializer_name(), "should have been checked in verifier");
 
   // check if static
@@ -898,7 +917,11 @@ void LinkResolver::linktime_resolve_special_method(methodHandle& resolved_method
   // and the selected method is recalculated relative to the direct superclass
   // superinterface.method, which explicitly does not check shadowing
 
-  resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, false, CHECK);
+  if (!resolved_klass->is_interface()) {
+    resolve_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, false, CHECK);
+  } else {
+    resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, true, CHECK);
+  }
 
   // check if method name is <init>, that it is found in same klass as static type
   if (resolved_method->name() == vmSymbols::object_initializer_name() &&
@@ -1219,7 +1242,7 @@ void LinkResolver::resolve_interface_call(CallInfo& result, Handle recv, KlassHa
 void LinkResolver::linktime_resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name,
                                                      Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS) {
   // normal interface method resolution
-  resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, CHECK);
+  resolve_interface_method(resolved_method, resolved_klass, method_name, method_signature, current_klass, check_access, true, CHECK);
 
   assert(resolved_method->name() != vmSymbols::object_initializer_name(), "should have been checked in verifier");
   assert(resolved_method->name() != vmSymbols::class_initializer_name (), "should have been checked in verifier");
diff --git a/src/share/vm/interpreter/linkResolver.hpp b/src/share/vm/interpreter/linkResolver.hpp
index 1411d909b9cf5e969d23dc699f8d70ac3ebfee99..4b13de8789f20e783cea3dfa4c1d768239b9d373 100644
--- a/src/share/vm/interpreter/linkResolver.hpp
+++ b/src/share/vm/interpreter/linkResolver.hpp
@@ -124,7 +124,7 @@ class LinkResolver: AllStatic {
   friend class klassItable;
 
  private:
-  static void lookup_method_in_klasses          (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
+  static void lookup_method_in_klasses          (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, bool checkpolymorphism, TRAPS);
   static void lookup_instance_method_in_klasses (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
   static void lookup_method_in_interfaces       (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature, TRAPS);
   static void lookup_polymorphic_method         (methodHandle& result, KlassHandle klass, Symbol* name, Symbol* signature,
@@ -134,7 +134,7 @@ class LinkResolver: AllStatic {
 
   static void resolve_pool  (KlassHandle& resolved_klass, Symbol*& method_name, Symbol*& method_signature, KlassHandle& current_klass, constantPoolHandle pool, int index, TRAPS);
 
-  static void resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS);
+  static void resolve_interface_method(methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, bool check_access, bool nostatics, TRAPS);
   static void resolve_method          (methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, bool check_access, bool require_methodref, TRAPS);
 
   static void linktime_resolve_static_method    (methodHandle& resolved_method, KlassHandle resolved_klass, Symbol* method_name, Symbol* method_signature, KlassHandle current_klass, bool check_access, TRAPS);
diff --git a/src/share/vm/oops/instanceKlass.cpp b/src/share/vm/oops/instanceKlass.cpp
index 5077f123e38c50dd961fc05c216d0232b4da0c70..77be5307db6726edb2c4a30387aa58eb0365f230 100644
--- a/src/share/vm/oops/instanceKlass.cpp
+++ b/src/share/vm/oops/instanceKlass.cpp
@@ -1427,6 +1427,17 @@ Method* InstanceKlass::find_method(Symbol* name, Symbol* signature) const {
   return InstanceKlass::find_method(methods(), name, signature);
 }
 
+// find_instance_method looks up the name/signature in the local methods array
+// and skips over static methods
+Method* InstanceKlass::find_instance_method(
+    Array<Method*>* methods, Symbol* name, Symbol* signature) {
+  Method* meth = InstanceKlass::find_method(methods, name, signature);
+  if (meth != NULL && meth->is_static()) {
+      meth = NULL;
+  }
+  return meth;
+}
+
 // find_method looks up the name/signature in the local methods array
 Method* InstanceKlass::find_method(
     Array<Method*>* methods, Symbol* name, Symbol* signature) {
@@ -2169,7 +2180,6 @@ int InstanceKlass::oop_adjust_pointers(oop obj) {
     obj, \
     MarkSweep::adjust_pointer(p), \
     assert_is_in)
-  MarkSweep::adjust_klass(obj->klass());
   return size;
 }
 
diff --git a/src/share/vm/oops/instanceKlass.hpp b/src/share/vm/oops/instanceKlass.hpp
index c667f2c2d12dae9a9dcc78ffcf3319d83e9a4135..84cc0046a95a4627f4faa74f523b0b517c1aa82e 100644
--- a/src/share/vm/oops/instanceKlass.hpp
+++ b/src/share/vm/oops/instanceKlass.hpp
@@ -515,6 +515,7 @@ class InstanceKlass: public Klass {
   // find a local method (returns NULL if not found)
   Method* find_method(Symbol* name, Symbol* signature) const;
   static Method* find_method(Array<Method*>* methods, Symbol* name, Symbol* signature);
+  static Method* find_instance_method(Array<Method*>* methods, Symbol* name, Symbol* signature);
 
   // find a local method index in default_methods (returns -1 if not found)
   static int find_method_index(Array<Method*>* methods, Symbol* name, Symbol* signature);
diff --git a/src/share/vm/oops/instanceMirrorKlass.cpp b/src/share/vm/oops/instanceMirrorKlass.cpp
index 3eabba70a1aa82a7a352577e3e2b2b4ab196860e..825633247d1d2fa9b955973d4cc8bbe2f97bf6ff 100644
--- a/src/share/vm/oops/instanceMirrorKlass.cpp
+++ b/src/share/vm/oops/instanceMirrorKlass.cpp
@@ -155,7 +155,13 @@ void InstanceMirrorKlass::oop_follow_contents(oop obj) {
   // Follow the klass field in the mirror.
   Klass* klass = java_lang_Class::as_Klass(obj);
   if (klass != NULL) {
-    MarkSweep::follow_klass(klass);
+    // For anonymous classes we need to handle the class loader data,
+    // otherwise it won't be claimed and can be unloaded.
+    if (klass->oop_is_instance() && InstanceKlass::cast(klass)->is_anonymous()) {
+      MarkSweep::follow_class_loader(klass->class_loader_data());
+    } else {
+      MarkSweep::follow_klass(klass);
+    }
   } else {
     // If klass is NULL then this a mirror for a primitive type.
     // We don't have to follow them, since they are handled as strong
@@ -196,17 +202,6 @@ int InstanceMirrorKlass::oop_adjust_pointers(oop obj) {
   int size = oop_size(obj);
   InstanceKlass::oop_adjust_pointers(obj);
 
-  // Follow the klass field in the mirror.
-  Klass* klass = java_lang_Class::as_Klass(obj);
-  if (klass != NULL) {
-    MarkSweep::adjust_klass(klass);
-  } else {
-    // If klass is NULL then this a mirror for a primitive type.
-    // We don't have to follow them, since they are handled as strong
-    // roots in Universe::oops_do.
-    assert(java_lang_Class::is_primitive(obj), "Sanity check");
-  }
-
   InstanceMirrorKlass_OOP_ITERATE(                                                    \
     start_of_static_fields(obj), java_lang_Class::static_oop_field_count(obj),        \
     MarkSweep::adjust_pointer(p),                                                     \
diff --git a/src/share/vm/oops/klassVtable.cpp b/src/share/vm/oops/klassVtable.cpp
index 1399a41baa8dc6956b89c546eb264277c8b2d0d1..509c78853607fcf78327982c9f1feb1322f15c58 100644
--- a/src/share/vm/oops/klassVtable.cpp
+++ b/src/share/vm/oops/klassVtable.cpp
@@ -665,6 +665,11 @@ bool klassVtable::is_miranda_entry_at(int i) {
 
 // check if a method is a miranda method, given a class's methods table,
 // its default_method table  and its super
+// Miranda methods are calculated twice:
+// first: before vtable size calculation: including abstract and default
+// This is seen by default method creation
+// Second: recalculated during vtable initialization: only abstract
+// This is seen by link resolution and selection.
 // "miranda" means not static, not defined by this class.
 // private methods in interfaces do not belong in the miranda list.
 // the caller must make sure that the method belongs to an interface implemented by the class
@@ -678,7 +683,8 @@ bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods,
   }
   Symbol* name = m->name();
   Symbol* signature = m->signature();
-  if (InstanceKlass::find_method(class_methods, name, signature) == NULL) {
+
+  if (InstanceKlass::find_instance_method(class_methods, name, signature) == NULL) {
     // did not find it in the method table of the current class
     if ((default_methods == NULL) ||
         InstanceKlass::find_method(default_methods, name, signature) == NULL) {
@@ -688,6 +694,12 @@ bool klassVtable::is_miranda(Method* m, Array<Method*>* class_methods,
       }
 
       Method* mo = InstanceKlass::cast(super)->lookup_method(name, signature);
+      while (mo != NULL && mo->access_flags().is_static()
+             && mo->method_holder() != NULL
+             && mo->method_holder()->super() != NULL)
+      {
+         mo = mo->method_holder()->super()->uncached_lookup_method(name, signature);
+      }
       if (mo == NULL || mo->access_flags().is_private() ) {
         // super class hierarchy does not implement it or protection is different
         return true;
diff --git a/src/share/vm/oops/objArrayKlass.cpp b/src/share/vm/oops/objArrayKlass.cpp
index f2f34910602fce0c74092212259ef4f0c017f464..94c990a728e25eaebf3dfe48cff8d03ab15addb0 100644
--- a/src/share/vm/oops/objArrayKlass.cpp
+++ b/src/share/vm/oops/objArrayKlass.cpp
@@ -569,7 +569,6 @@ int ObjArrayKlass::oop_adjust_pointers(oop obj) {
   // Get size before changing pointers.
   // Don't call size() or oop_size() since that is a virtual call.
   int size = a->object_size();
-  MarkSweep::adjust_klass(a->klass());
   ObjArrayKlass_OOP_ITERATE(a, p, MarkSweep::adjust_pointer(p))
   return size;
 }
diff --git a/src/share/vm/opto/c2_globals.hpp b/src/share/vm/opto/c2_globals.hpp
index d1c4b2ca06677c9222412c1d9e78cdb32202b508..207daabc7b3afc15096362a506f08ce0e2e065c5 100644
--- a/src/share/vm/opto/c2_globals.hpp
+++ b/src/share/vm/opto/c2_globals.hpp
@@ -637,7 +637,7 @@
   diagnostic(bool, OptimizeExpensiveOps, true,                              \
           "Find best control for expensive operations")                     \
                                                                             \
-  product(bool, UseMathExactIntrinsics, true,                               \
+  experimental(bool, UseMathExactIntrinsics, false,                         \
           "Enables intrinsification of various java.lang.Math functions")   \
                                                                             \
   experimental(bool, ReplaceInParentMaps, false,                            \
diff --git a/src/share/vm/prims/jvmtiEnvThreadState.cpp b/src/share/vm/prims/jvmtiEnvThreadState.cpp
index 0f0eed6ad0ba519024bad3bfb176708fe61a80e5..5bdec52d9fd6ecad5ac6cdf82c9f9863a14c4bc8 100644
--- a/src/share/vm/prims/jvmtiEnvThreadState.cpp
+++ b/src/share/vm/prims/jvmtiEnvThreadState.cpp
@@ -269,11 +269,20 @@ class VM_GetCurrentLocation : public VM_Operation {
   void doit() {
     ResourceMark rmark; // _thread != Thread::current()
     RegisterMap rm(_thread, false);
-    javaVFrame* vf = _thread->last_java_vframe(&rm);
-    assert(vf != NULL, "must have last java frame");
-    Method* method = vf->method();
-    _method_id = method->jmethod_id();
-    _bci = vf->bci();
+    // There can be a race condition between a VM_Operation reaching a safepoint
+    // and the target thread exiting from Java execution.
+    // We must recheck the last Java frame still exists.
+    if (_thread->has_last_Java_frame()) {
+      javaVFrame* vf = _thread->last_java_vframe(&rm);
+      assert(vf != NULL, "must have last java frame");
+      Method* method = vf->method();
+      _method_id = method->jmethod_id();
+      _bci = vf->bci();
+    } else {
+      // Clear current location as the target thread has no Java frames anymore.
+      _method_id = (jmethodID)NULL;
+      _bci = 0;
+    }
   }
   void get_current_location(jmethodID *method_id, int *bci) {
     *method_id = _method_id;
diff --git a/src/share/vm/prims/jvmtiImpl.hpp b/src/share/vm/prims/jvmtiImpl.hpp
index fc502c7387d961cc8b57a3ae3d33367453439872..c1e4b81b66e9b0b5ee83f1052cdcc98d80703046 100644
--- a/src/share/vm/prims/jvmtiImpl.hpp
+++ b/src/share/vm/prims/jvmtiImpl.hpp
@@ -299,7 +299,7 @@ public:
   static inline bool is_breakpoint(address bcp);
 
   static void oops_do(OopClosure* f);
-  static void metadata_do(void f(Metadata*));
+  static void metadata_do(void f(Metadata*)) NOT_JVMTI_RETURN;
   static void gc_epilogue();
 };
 
diff --git a/src/share/vm/runtime/arguments.cpp b/src/share/vm/runtime/arguments.cpp
index 51fb3f7d595ead273f242c22a8dafe761e90bba6..5a8ea0dbdd8431240cb97c777c537509a2247f8c 100644
--- a/src/share/vm/runtime/arguments.cpp
+++ b/src/share/vm/runtime/arguments.cpp
@@ -2278,18 +2278,6 @@ bool Arguments::check_vm_args_consistency() {
   status = status && verify_percentage(MarkSweepDeadRatio, "MarkSweepDeadRatio");
 
   status = status && verify_min_value(MarkSweepAlwaysCompactCount, 1, "MarkSweepAlwaysCompactCount");
-#ifdef SPARC
-  if (UseConcMarkSweepGC || UseG1GC) {
-    // Issue a stern warning if the user has explicitly set
-    // UseMemSetInBOT (it is known to cause issues), but allow
-    // use for experimentation and debugging.
-    if (VM_Version::is_sun4v() && UseMemSetInBOT) {
-      assert(!FLAG_IS_DEFAULT(UseMemSetInBOT), "Error");
-      warning("Experimental flag -XX:+UseMemSetInBOT is known to cause instability"
-          " on sun4v; please understand that you are using at your own risk!");
-    }
-  }
-#endif // SPARC
 
   if (PrintNMTStatistics) {
 #if INCLUDE_NMT
diff --git a/test/TEST.groups b/test/TEST.groups
index 18fb1d9a157f17627b6432098ac6062d5a7a4328..ee67fe938c71f5a871bd4a47b8efcbb6d9f5f362 100644
--- a/test/TEST.groups
+++ b/test/TEST.groups
@@ -70,7 +70,6 @@ needs_jdk = \
   runtime/7107135/Test7107135.sh \
   runtime/7158988/FieldMonitor.java \
   runtime/7194254/Test7194254.java \
-  runtime/8026365/InvokeSpecialAnonTest.java \
   runtime/jsig/Test8017498.sh \
   runtime/Metaspace/FragmentMetaspace.java \
   runtime/NMT/BaselineWithParameter.java \
diff --git a/test/compiler/intrinsics/mathexact/AddExactICondTest.java b/test/compiler/intrinsics/mathexact/AddExactICondTest.java
index 8862160d8b40b6a1b9b494287068be25ffb4cc51..f0835cdb197bd4f0ca716f6a06b83452959a327c 100644
--- a/test/compiler/intrinsics/mathexact/AddExactICondTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactICondTest.java
@@ -26,7 +26,7 @@
  * @bug 8024924
  * @summary Test non constant addExact
  * @compile AddExactICondTest.java
- * @run main AddExactICondTest
+ * @run main AddExactICondTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactIConstantTest.java b/test/compiler/intrinsics/mathexact/AddExactIConstantTest.java
index 77000a1d958e418e1078a6fa896ad40f8d17d5bf..ed8525483b0a2658710db98e381320fcbfe14b1f 100644
--- a/test/compiler/intrinsics/mathexact/AddExactIConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactIConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8024924
  * @summary Test constant addExact
  * @compile AddExactIConstantTest.java Verify.java
- * @run main AddExactIConstantTest
+ * @run main AddExactIConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactILoadTest.java b/test/compiler/intrinsics/mathexact/AddExactILoadTest.java
index 2d96bb8b8a63ac824421586f8943eadbd59b170b..4175a8ab5ccda6c2b4e5259264a79af30875fd7b 100644
--- a/test/compiler/intrinsics/mathexact/AddExactILoadTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactILoadTest.java
@@ -26,7 +26,7 @@
  * @bug 8024924
  * @summary Test non constant addExact
  * @compile AddExactILoadTest.java Verify.java
- * @run main AddExactILoadTest
+ * @run main AddExactILoadTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactILoopDependentTest.java b/test/compiler/intrinsics/mathexact/AddExactILoopDependentTest.java
index 99aae0d7b21696d08a4c8454ed2262901a36342d..56da9f40b7e4956f9c27fb383e076b69119d3161 100644
--- a/test/compiler/intrinsics/mathexact/AddExactILoopDependentTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactILoopDependentTest.java
@@ -26,7 +26,7 @@
  * @bug 8024924
  * @summary Test non constant addExact
  * @compile AddExactILoopDependentTest.java Verify.java
- * @run main AddExactILoopDependentTest
+ * @run main AddExactILoopDependentTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactINonConstantTest.java b/test/compiler/intrinsics/mathexact/AddExactINonConstantTest.java
index b3a247585693001ef2e34ddd8199471eee3f8d72..52e208db0e4c5b69582974a2cb8a51657a9ccb80 100644
--- a/test/compiler/intrinsics/mathexact/AddExactINonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactINonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8024924
  * @summary Test non constant addExact
  * @compile AddExactINonConstantTest.java Verify.java
- * @run main AddExactINonConstantTest
+ * @run main AddExactINonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactIRepeatTest.java b/test/compiler/intrinsics/mathexact/AddExactIRepeatTest.java
index d111b66ce821c362a71e2026e91ff218d0c97f7f..7bb1deba0079fb0e3e58e389dff3fdb46b371fa6 100644
--- a/test/compiler/intrinsics/mathexact/AddExactIRepeatTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactIRepeatTest.java
@@ -26,7 +26,7 @@
  * @bug 8025657
  * @summary Test repeating addExact
  * @compile AddExactIRepeatTest.java Verify.java
- * @run main AddExactIRepeatTest
+ * @run main AddExactIRepeatTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactLConstantTest.java b/test/compiler/intrinsics/mathexact/AddExactLConstantTest.java
index dc751406192eb6bb56a428ece967240649782b79..3514ce24ab7ef1cc1509508a757abd35172f17b6 100644
--- a/test/compiler/intrinsics/mathexact/AddExactLConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactLConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant addExact
  * @compile AddExactLConstantTest.java Verify.java
- * @run main AddExactLConstantTest
+ * @run main AddExactLConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/AddExactLNonConstantTest.java b/test/compiler/intrinsics/mathexact/AddExactLNonConstantTest.java
index efd5fd7c92b31e36e8e91f55d13605f246381f0f..3e16cb94d95ac94ffd36b561db103aca2bd11bfa 100644
--- a/test/compiler/intrinsics/mathexact/AddExactLNonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/AddExactLNonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant addExact
  * @compile AddExactLNonConstantTest.java Verify.java
- * @run main AddExactLNonConstantTest
+ * @run main AddExactLNonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/CompareTest.java b/test/compiler/intrinsics/mathexact/CompareTest.java
index f6785c07c690e0db1ad7fdb27f82759e3f4296be..c77dd47c1849f1f8adea81adf3e79ce80b64a361 100644
--- a/test/compiler/intrinsics/mathexact/CompareTest.java
+++ b/test/compiler/intrinsics/mathexact/CompareTest.java
@@ -26,7 +26,7 @@
  * @bug 8026722
  * @summary Verify that the compare after addExact is a signed compare
  * @compile CompareTest.java
- * @run main CompareTest
+ * @run main CompareTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/DecExactITest.java b/test/compiler/intrinsics/mathexact/DecExactITest.java
index 7e6e1ca3bde38b98647564aef509475374a4f965..2712bed78ab2f82018b76a91efcf0cc717c76627 100644
--- a/test/compiler/intrinsics/mathexact/DecExactITest.java
+++ b/test/compiler/intrinsics/mathexact/DecExactITest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test decrementExact
  * @compile DecExactITest.java Verify.java
- * @run main DecExactITest
+ * @run main DecExactITest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/DecExactLTest.java b/test/compiler/intrinsics/mathexact/DecExactLTest.java
index 7dca00b963e31fc3de60e9555fe107ee0cc8723b..ad83dcad208138e14bd5833e84ffe8240696b43c 100644
--- a/test/compiler/intrinsics/mathexact/DecExactLTest.java
+++ b/test/compiler/intrinsics/mathexact/DecExactLTest.java
@@ -25,8 +25,8 @@
  * @test
  * @bug 8026844
  * @summary Test decrementExact
- * @compile DecExactITest.java Verify.java
- * @run main DecExactITest
+ * @compile DecExactLTest.java Verify.java
+ * @run main DecExactLTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/GVNTest.java b/test/compiler/intrinsics/mathexact/GVNTest.java
index 23fba15d4335ba872337823adeed0f7cba36ae21..864555e2b3e2229ca9e319d9fea3e1fc381fac93 100644
--- a/test/compiler/intrinsics/mathexact/GVNTest.java
+++ b/test/compiler/intrinsics/mathexact/GVNTest.java
@@ -26,7 +26,7 @@
  * @bug 8028207
  * @summary Verify that GVN doesn't mess up the two addExacts
  * @compile GVNTest.java
- * @run main GVNTest
+ * @run main GVNTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/IncExactITest.java b/test/compiler/intrinsics/mathexact/IncExactITest.java
index 9f7ddbd3211505e55fa76fd17090e10534e57db4..41ab825847aa5489c697ec5c63c448f9e538cc64 100644
--- a/test/compiler/intrinsics/mathexact/IncExactITest.java
+++ b/test/compiler/intrinsics/mathexact/IncExactITest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test incrementExact
  * @compile IncExactITest.java Verify.java
- * @run main IncExactITest
+ * @run main IncExactITest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/IncExactLTest.java b/test/compiler/intrinsics/mathexact/IncExactLTest.java
index 755d81908ce142df3ec00abeb5d6e65b9c9a10c1..6ece9792be7e48dcbced2ccbc210627c018ee688 100644
--- a/test/compiler/intrinsics/mathexact/IncExactLTest.java
+++ b/test/compiler/intrinsics/mathexact/IncExactLTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test incrementExact
  * @compile IncExactLTest.java Verify.java
- * @run main IncExactLTest
+ * @run main IncExactLTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactICondTest.java b/test/compiler/intrinsics/mathexact/MulExactICondTest.java
index 5f3e1e64568f413fb2bf838dde9bd6ebc01c98b9..e9bf6b9958e69b665475ef9f89288e809ca2286b 100644
--- a/test/compiler/intrinsics/mathexact/MulExactICondTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactICondTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test multiplyExact as condition
  * @compile MulExactICondTest.java
- * @run main MulExactICondTest
+ * @run main MulExactICondTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactIConstantTest.java b/test/compiler/intrinsics/mathexact/MulExactIConstantTest.java
index 120bef5e9b9126afe8f77e5d276f2a010a71aeb8..6bb74d1f9ebea8a9e02e8abfbce107f69b33b16b 100644
--- a/test/compiler/intrinsics/mathexact/MulExactIConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactIConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant multiplyExact
  * @compile MulExactIConstantTest.java Verify.java
- * @run main MulExactIConstantTest
+ * @run main MulExactIConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactILoadTest.java b/test/compiler/intrinsics/mathexact/MulExactILoadTest.java
index 36aa3d46230887255d5bf5f477cf7adb545de294..8878b6f1c6d8f42366132172e5d04e47c720dff9 100644
--- a/test/compiler/intrinsics/mathexact/MulExactILoadTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactILoadTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test multiplyExact
  * @compile MulExactILoadTest.java Verify.java
- * @run main MulExactILoadTest
+ * @run main MulExactILoadTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactILoopDependentTest.java b/test/compiler/intrinsics/mathexact/MulExactILoopDependentTest.java
index 5ba4ad3cfc30a791a3d91de17b143178edd213db..7c5c7e7a24089a67479e751d5a337c2b41026873 100644
--- a/test/compiler/intrinsics/mathexact/MulExactILoopDependentTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactILoopDependentTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test loop dependent multiplyExact
  * @compile MulExactILoopDependentTest.java Verify.java
- * @run main MulExactILoopDependentTest
+ * @run main MulExactILoopDependentTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 public class MulExactILoopDependentTest {
diff --git a/test/compiler/intrinsics/mathexact/MulExactINonConstantTest.java b/test/compiler/intrinsics/mathexact/MulExactINonConstantTest.java
index e108059885b8318433f637addb3c0fad7241a38a..e924311aa2537e8b1731ff90e17bc87dc5708533 100644
--- a/test/compiler/intrinsics/mathexact/MulExactINonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactINonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant multiplyExact
  * @compile MulExactINonConstantTest.java Verify.java
- * @run main MulExactINonConstantTest
+ * @run main MulExactINonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactIRepeatTest.java b/test/compiler/intrinsics/mathexact/MulExactIRepeatTest.java
index dd14ce21ed643f1da248035055b987b25f06af77..5d5a93d05d7c6be28182c431fbef34df2122cbe1 100644
--- a/test/compiler/intrinsics/mathexact/MulExactIRepeatTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactIRepeatTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test repeating multiplyExact
  * @compile MulExactIRepeatTest.java Verify.java
- * @run main MulExactIRepeatTest
+ * @run main MulExactIRepeatTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactLConstantTest.java b/test/compiler/intrinsics/mathexact/MulExactLConstantTest.java
index c687cc276f2b138636949ef024b2af373f7c2f00..9668ddfe07edef6ff259f5698a9730cc23d0c67f 100644
--- a/test/compiler/intrinsics/mathexact/MulExactLConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactLConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant mulExact
  * @compile MulExactLConstantTest.java Verify.java
- * @run main MulExactLConstantTest
+ * @run main MulExactLConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/MulExactLNonConstantTest.java b/test/compiler/intrinsics/mathexact/MulExactLNonConstantTest.java
index f9d82ed0876f0dcb6122ac58f78090c4dfc11f3c..3486588c81ef3a992805dd68ab03e7ed6cdca458 100644
--- a/test/compiler/intrinsics/mathexact/MulExactLNonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/MulExactLNonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant mulExact
  * @compile MulExactLNonConstantTest.java Verify.java
- * @run main MulExactLNonConstantTest
+ * @run main MulExactLNonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/NegExactIConstantTest.java b/test/compiler/intrinsics/mathexact/NegExactIConstantTest.java
index ba49d778762ff1c9be9de4b24c22bb27c484870e..0a5e164ba68178917c7d36c22780bb2b9a6e5305 100644
--- a/test/compiler/intrinsics/mathexact/NegExactIConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/NegExactIConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant negExact
  * @compile NegExactIConstantTest.java Verify.java
- * @run main NegExactIConstantTest
+ * @run main NegExactIConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/NegExactILoadTest.java b/test/compiler/intrinsics/mathexact/NegExactILoadTest.java
index 371f3aedb6cc301e4b9b2d12a6b62196d7126f2d..e7896835ee151e92c606888b94e3f14e678a52f6 100644
--- a/test/compiler/intrinsics/mathexact/NegExactILoadTest.java
+++ b/test/compiler/intrinsics/mathexact/NegExactILoadTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test negExact
  * @compile NegExactILoadTest.java Verify.java
- * @run main NegExactILoadTest
+ * @run main NegExactILoadTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/NegExactILoopDependentTest.java b/test/compiler/intrinsics/mathexact/NegExactILoopDependentTest.java
index 882f80b91a154306473b0c631c573eee1b8f0d36..a18b0c17eeded528350a15dbcafa68cb6f063e38 100644
--- a/test/compiler/intrinsics/mathexact/NegExactILoopDependentTest.java
+++ b/test/compiler/intrinsics/mathexact/NegExactILoopDependentTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test negExact loop dependent
  * @compile NegExactILoopDependentTest.java Verify.java
- * @run main NegExactILoopDependentTest
+ * @run main NegExactILoopDependentTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 public class NegExactILoopDependentTest {
diff --git a/test/compiler/intrinsics/mathexact/NegExactINonConstantTest.java b/test/compiler/intrinsics/mathexact/NegExactINonConstantTest.java
index 6f044f0d969a0c52f47d2f5799b095b9b60b49b3..ee87bd82748785151383bd8354d90c82776ee95a 100644
--- a/test/compiler/intrinsics/mathexact/NegExactINonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/NegExactINonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant negExact
  * @compile NegExactINonConstantTest.java Verify.java
- * @run main NegExactINonConstantTest
+ * @run main NegExactINonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/NegExactLConstantTest.java b/test/compiler/intrinsics/mathexact/NegExactLConstantTest.java
index 382cd5c5f9ec1e6fd44633fb475fab3cd30fb44c..82e02a960a998ce836cc4ac887358f65898d0926 100644
--- a/test/compiler/intrinsics/mathexact/NegExactLConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/NegExactLConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant negExact
  * @compile NegExactLConstantTest.java Verify.java
- * @run main NegExactLConstantTest
+ * @run main NegExactLConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/NegExactLNonConstantTest.java b/test/compiler/intrinsics/mathexact/NegExactLNonConstantTest.java
index 0bcad8b2b78651680b5869a8f7317974df88038e..b7b967dc28ebdff952db59fe7529ebbaa008b7e9 100644
--- a/test/compiler/intrinsics/mathexact/NegExactLNonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/NegExactLNonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant negExact
  * @compile NegExactLNonConstantTest.java Verify.java
- * @run main NegExactLNonConstantTest
+ * @run main NegExactLNonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/NestedMathExactTest.java b/test/compiler/intrinsics/mathexact/NestedMathExactTest.java
index 211dc8baff102c0d4c86c1169e83806ea1f50cfd..883fcceacaa6ab9e07ce760a6e7aec6cac410bca 100644
--- a/test/compiler/intrinsics/mathexact/NestedMathExactTest.java
+++ b/test/compiler/intrinsics/mathexact/NestedMathExactTest.java
@@ -26,7 +26,7 @@
  * @bug 8027444
  * @summary Test nested loops
  * @compile NestedMathExactTest.java
- * @run main NestedMathExactTest
+ * @run main NestedMathExactTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SplitThruPhiTest.java b/test/compiler/intrinsics/mathexact/SplitThruPhiTest.java
index b3b0c0d74171611aa47e7c820564880ee9efaf2e..67f3afab0075ed26026f6379e00647a5782c33d9 100644
--- a/test/compiler/intrinsics/mathexact/SplitThruPhiTest.java
+++ b/test/compiler/intrinsics/mathexact/SplitThruPhiTest.java
@@ -26,7 +26,7 @@
  * @bug 8028198
  * @summary Verify that split through phi does the right thing
  * @compile SplitThruPhiTest.java
- * @run main SplitThruPhiTest
+ * @run main SplitThruPhiTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactICondTest.java b/test/compiler/intrinsics/mathexact/SubExactICondTest.java
index f539bdc7cbe7fa17c07e2b13e25e2de18f1bc63c..b4dd4f7daa980dc96f335e590b368ccf8e1f4327 100644
--- a/test/compiler/intrinsics/mathexact/SubExactICondTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactICondTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test subtractExact as condition
  * @compile SubExactICondTest.java Verify.java
- * @run main SubExactICondTest
+ * @run main SubExactICondTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactIConstantTest.java b/test/compiler/intrinsics/mathexact/SubExactIConstantTest.java
index b450bd90b11cab83cac833b290e0af435abb6384..20a27cef161bd915a022efaa1baaa8eae0071728 100644
--- a/test/compiler/intrinsics/mathexact/SubExactIConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactIConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test constant subtractExact
  * @compile SubExactIConstantTest.java Verify.java
- * @run main SubExactIConstantTest
+ * @run main SubExactIConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactILoadTest.java b/test/compiler/intrinsics/mathexact/SubExactILoadTest.java
index af2ed018258d7f90a90af865511f82ccc117b17b..5be582fd03aa6151cc0e4934f9d5cd6077fbdfbf 100644
--- a/test/compiler/intrinsics/mathexact/SubExactILoadTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactILoadTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant subtractExact
  * @compile SubExactILoadTest.java Verify.java
- * @run main SubExactILoadTest
+ * @run main SubExactILoadTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactILoopDependentTest.java b/test/compiler/intrinsics/mathexact/SubExactILoopDependentTest.java
index 67ebcbca321f45696eccf01f0422ceb1283b45b0..b4e7b4a30a818619d4fe55449d3fd64df779b7c0 100644
--- a/test/compiler/intrinsics/mathexact/SubExactILoopDependentTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactILoopDependentTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant subtractExact
  * @compile SubExactILoopDependentTest.java Verify.java
- * @run main SubExactILoopDependentTest
+ * @run main SubExactILoopDependentTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactINonConstantTest.java b/test/compiler/intrinsics/mathexact/SubExactINonConstantTest.java
index b81538108922a54996e1e27aa33d3d0a9377ba9d..82dc81c3d007985e368159d2fe9015ac2623404e 100644
--- a/test/compiler/intrinsics/mathexact/SubExactINonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactINonConstantTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test non constant subtractExact
  * @compile SubExactINonConstantTest.java Verify.java
- * @run main SubExactINonConstantTest
+ * @run main SubExactINonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactIRepeatTest.java b/test/compiler/intrinsics/mathexact/SubExactIRepeatTest.java
index 3c57f6f3f76da8b1bc0e3b337ab2f4885799ef55..63e4b3d1876bfacbbed386035acd06fe1ffe577d 100644
--- a/test/compiler/intrinsics/mathexact/SubExactIRepeatTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactIRepeatTest.java
@@ -26,7 +26,7 @@
  * @bug 8026844
  * @summary Test repeating subtractExact
  * @compile SubExactIRepeatTest.java Verify.java
- * @run main SubExactIRepeatTest
+ * @run main SubExactIRepeatTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactLConstantTest.java b/test/compiler/intrinsics/mathexact/SubExactLConstantTest.java
index ec554d7662b87f8d0ca4c6f546a3ebd8fd900f98..973aa6a39601a170aa1ec5359b7d0adab3a552fa 100644
--- a/test/compiler/intrinsics/mathexact/SubExactLConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactLConstantTest.java
@@ -27,7 +27,7 @@
  * @bug 8027353
  * @summary Test constant subtractExact
  * @compile SubExactLConstantTest.java Verify.java
- * @run main SubExactLConstantTest
+ * @run main SubExactLConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/compiler/intrinsics/mathexact/SubExactLNonConstantTest.java b/test/compiler/intrinsics/mathexact/SubExactLNonConstantTest.java
index 86ecf20f366e9c6ee248b82ffd815a48b8b3b466..bc0c7331b7600bbb008b4a4dd7a39949c8772ca4 100644
--- a/test/compiler/intrinsics/mathexact/SubExactLNonConstantTest.java
+++ b/test/compiler/intrinsics/mathexact/SubExactLNonConstantTest.java
@@ -27,7 +27,7 @@
  * @bug 8027353
  * @summary Test non constant subtractExact
  * @compile SubExactLNonConstantTest.java Verify.java
- * @run main SubExactLNonConstantTest
+ * @run main SubExactLNonConstantTest -XX:+IgnoreUnrecognizedVMOptions -XX:+UnlockExperimentalVMOptions -XX:+UseMathExactIntrinsics
  *
  */
 
diff --git a/test/runtime/8024804/RegisterNatives.java b/test/runtime/8024804/RegisterNatives.java
index 8a5772a88b9ee02a61a9a9be588cd9d5b1044d81..a0c5ee1f351f6b8aad6f29ceacca8ac6ab1b6c45 100644
--- a/test/runtime/8024804/RegisterNatives.java
+++ b/test/runtime/8024804/RegisterNatives.java
@@ -22,6 +22,7 @@
  */
 
 /*
+ * @ignore 8028741
  * @test
  * @bug 8024804
  * @summary registerNatives() interface resolution should receive IAE