changeset 6505:14b656df31c2 jdk9-b17

Merge
author lana
date Thu, 05 Jun 2014 19:39:08 -0700
parents d7a8e8a4965c 4a0965f52d4d
children 41be7ddc01b2 e1902bbbd93f 7fbeb8c266f4 68d348f8d4c1
files test/runtime/6929067/T.java test/runtime/6929067/Test6929067.sh test/runtime/6929067/invoke.c test/runtime/InitialThreadOverflow/DoOverflow.java test/runtime/InitialThreadOverflow/invoke.c test/runtime/InitialThreadOverflow/testme.sh
diffstat 50 files changed, 983 insertions(+), 620 deletions(-) [+]
line wrap: on
line diff
--- a/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/cpu/sparc/vm/c1_LIRGenerator_sparc.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1221,10 +1221,8 @@
   bool is_obj = (type == T_ARRAY || type == T_OBJECT);
   LIR_Opr offset = off.result();
 
-  if (data != dst) {
-    __ move(data, dst);
-    data = dst;
-  }
+  // Because we want a 2-arg form of xchg
+  __ move(data, dst);
 
   assert (!x->is_add() && (type == T_INT || (is_obj LP64_ONLY(&& UseCompressedOops))), "unexpected type");
   LIR_Address* addr;
@@ -1254,7 +1252,7 @@
     pre_barrier(ptr, LIR_OprFact::illegalOpr /* pre_val */,
                 true /* do_load */, false /* patch */, NULL);
   }
-  __ xchg(LIR_OprFact::address(addr), data, dst, tmp);
+  __ xchg(LIR_OprFact::address(addr), dst, dst, tmp);
   if (is_obj) {
     // Seems to be a precise address
     post_barrier(ptr, data);
--- a/src/cpu/sparc/vm/copy_sparc.hpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/cpu/sparc/vm/copy_sparc.hpp	Thu Jun 05 19:39:08 2014 -0700
@@ -184,7 +184,7 @@
   assert(MinObjAlignmentInBytes >= BytesPerLong, "need alternate implementation");
 
   if (value == 0 && UseBlockZeroing &&
-      (count > (BlockZeroingLowLimit >> LogHeapWordSize))) {
+      (count > (size_t)(BlockZeroingLowLimit >> LogHeapWordSize))) {
    // Call it only when block zeroing is used
    ((_zero_Fn)StubRoutines::zero_aligned_words())(tohw, count);
   } else {
--- a/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/CallSite.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/CallSite.java	Thu Jun 05 19:39:08 2014 -0700
@@ -231,6 +231,9 @@
         // identical call sites with the same method name/bci are
         // possible so we have to try them all until we find the late
         // inline call site that has a matching inline id.
+        if (calls == null) {
+            return null;
+        }
         CallSite site = sites.pop();
         for (CallSite c : calls) {
             if (c.matches(site)) {
@@ -250,6 +253,27 @@
         return null;
     }
 
+    public ArrayDeque<CallSite> findCallSite2(CallSite site) {
+        if (calls == null) {
+            return null;
+        }
+
+        for (CallSite c : calls) {
+            if (c.matches(site)) {
+                ArrayDeque<CallSite> stack = new ArrayDeque<CallSite>();
+                stack.push(c);
+                return stack;
+            } else {
+                ArrayDeque<CallSite> stack = c.findCallSite2(site);
+                if (stack != null) {
+                    stack.push(c);
+                    return stack;
+                }
+            }
+        }
+        return null;
+    }
+
     public long getInlineId() {
         return inlineId;
     }
--- a/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/Compilation.java	Thu Jun 05 19:39:08 2014 -0700
@@ -49,6 +49,12 @@
         this.id = id;
     }
 
+    void reset() {
+        call = new CallSite();
+        lateInlineCall = new CallSite();
+        phases = new ArrayList<Phase>(4);
+    }
+
     Phase getPhase(String s) {
         for (Phase p : getPhases()) {
             if (p.getName().equals(s)) {
@@ -212,10 +218,6 @@
         return phases;
     }
 
-    public void setPhases(ArrayList<Phase> phases) {
-        this.setPhases(phases);
-    }
-
     public String getFailureReason() {
         return failureReason;
     }
@@ -240,10 +242,6 @@
         return call;
     }
 
-    public void setCall(CallSite call) {
-        this.call = call;
-    }
-
     public CallSite getLateInlineCall() {
         return lateInlineCall;
     }
--- a/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/tools/LogCompilation/src/com/sun/hotspot/tools/compiler/LogParser.java	Thu Jun 05 19:39:08 2014 -0700
@@ -395,6 +395,7 @@
             compile.setEnd(Double.parseDouble(search(atts, "stamp")));
             if (Integer.parseInt(search(atts, "success")) == 0) {
                 compile.setFailureReason(failureReason);
+                failureReason = null;
             }
         } else if (qname.equals("make_not_entrant")) {
             String id = makeId(atts);
@@ -451,6 +452,12 @@
             nmethods.put(id, nm);
             events.add(nm);
         } else if (qname.equals("parse")) {
+            if (failureReason != null && scopes.size() == 0 && !lateInlining) {
+                failureReason = null;
+                compile.reset();
+                site = compile.getCall();
+            }
+
             if (methodHandleSite != null) {
                 throw new InternalError("method handle site should have been replaced");
             }
@@ -529,6 +536,18 @@
 
             site = compile.getCall().findCallSite(thisCallScopes);
             if (site == null) {
+                System.out.println("call scopes:");
+                for (CallSite c : thisCallScopes) {
+                    System.out.println(c.getMethod() + " " + c.getBci() + " " + c.getInlineId());
+                }
+                CallSite c = thisCallScopes.getLast();
+                if (c.getInlineId() != 0) {
+                    System.out.println("Looking for call site in entire tree:");
+                    ArrayDeque<CallSite> stack = compile.getCall().findCallSite2(c);
+                    for (CallSite c2 : stack) {
+                        System.out.println(c2.getMethod() + " " + c2.getBci() + " " + c2.getInlineId());
+                    }
+                }
                 System.out.println(caller.getMethod() + " bci: " + bci);
                 throw new InternalError("couldn't find call site");
             }
--- a/src/share/vm/c1/c1_LIR.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/c1/c1_LIR.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1083,7 +1083,7 @@
 
 void LIR_OpArrayCopy::emit_code(LIR_Assembler* masm) {
   masm->emit_arraycopy(this);
-  masm->emit_code_stub(stub());
+  masm->append_code_stub(stub());
 }
 
 void LIR_OpUpdateCRC32::emit_code(LIR_Assembler* masm) {
@@ -1100,20 +1100,20 @@
 
 void LIR_OpAllocObj::emit_code(LIR_Assembler* masm) {
   masm->emit_alloc_obj(this);
-  masm->emit_code_stub(stub());
+  masm->append_code_stub(stub());
 }
 
 void LIR_OpBranch::emit_code(LIR_Assembler* masm) {
   masm->emit_opBranch(this);
   if (stub()) {
-    masm->emit_code_stub(stub());
+    masm->append_code_stub(stub());
   }
 }
 
 void LIR_OpConvert::emit_code(LIR_Assembler* masm) {
   masm->emit_opConvert(this);
   if (stub() != NULL) {
-    masm->emit_code_stub(stub());
+    masm->append_code_stub(stub());
   }
 }
 
@@ -1123,13 +1123,13 @@
 
 void LIR_OpAllocArray::emit_code(LIR_Assembler* masm) {
   masm->emit_alloc_array(this);
-  masm->emit_code_stub(stub());
+  masm->append_code_stub(stub());
 }
 
 void LIR_OpTypeCheck::emit_code(LIR_Assembler* masm) {
   masm->emit_opTypeCheck(this);
   if (stub()) {
-    masm->emit_code_stub(stub());
+    masm->append_code_stub(stub());
   }
 }
 
@@ -1144,7 +1144,7 @@
 void LIR_OpLock::emit_code(LIR_Assembler* masm) {
   masm->emit_lock(this);
   if (stub()) {
-    masm->emit_code_stub(stub());
+    masm->append_code_stub(stub());
   }
 }
 
--- a/src/share/vm/c1/c1_LIR.hpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/c1/c1_LIR.hpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1127,6 +1127,7 @@
   virtual void print_instr(outputStream* out) const   = 0;
   virtual void print_on(outputStream* st) const PRODUCT_RETURN;
 
+  virtual bool is_patching() { return false; }
   virtual LIR_OpCall* as_OpCall() { return NULL; }
   virtual LIR_OpJavaCall* as_OpJavaCall() { return NULL; }
   virtual LIR_OpLabel* as_OpLabel() { return NULL; }
@@ -1387,6 +1388,7 @@
     return (LIR_MoveKind)_flags;
   }
 
+  virtual bool is_patching() { return _patch != lir_patch_none; }
   virtual void emit_code(LIR_Assembler* masm);
   virtual LIR_Op1* as_Op1() { return this; }
   virtual const char * name() const PRODUCT_RETURN0;
@@ -1619,6 +1621,7 @@
   int       profiled_bci() const                 { return _profiled_bci;      }
   bool      should_profile() const               { return _should_profile;    }
 
+  virtual bool is_patching() { return _info_for_patch != NULL; }
   virtual void emit_code(LIR_Assembler* masm);
   virtual LIR_OpTypeCheck* as_OpTypeCheck() { return this; }
   void print_instr(outputStream* out) const PRODUCT_RETURN;
--- a/src/share/vm/c1/c1_LIRAssembler.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/c1/c1_LIRAssembler.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -58,7 +58,7 @@
     _masm->nop();
   }
   patch->install(_masm, patch_code, obj, info);
-  append_patching_stub(patch);
+  append_code_stub(patch);
 
 #ifdef ASSERT
   Bytecodes::Code code = info->scope()->method()->java_code_at_bci(info->stack()->bci());
@@ -131,11 +131,6 @@
 }
 
 
-void LIR_Assembler::append_patching_stub(PatchingStub* stub) {
-  _slow_case_stubs->append(stub);
-}
-
-
 void LIR_Assembler::check_codespace() {
   CodeSection* cs = _masm->code_section();
   if (cs->remaining() < (int)(NOT_LP64(1*K)LP64_ONLY(2*K))) {
@@ -144,7 +139,7 @@
 }
 
 
-void LIR_Assembler::emit_code_stub(CodeStub* stub) {
+void LIR_Assembler::append_code_stub(CodeStub* stub) {
   _slow_case_stubs->append(stub);
 }
 
@@ -442,7 +437,7 @@
 
 void LIR_Assembler::add_debug_info_for_null_check(int pc_offset, CodeEmitInfo* cinfo) {
   ImplicitNullCheckStub* stub = new ImplicitNullCheckStub(pc_offset, cinfo);
-  emit_code_stub(stub);
+  append_code_stub(stub);
 }
 
 void LIR_Assembler::add_debug_info_for_div0_here(CodeEmitInfo* info) {
@@ -451,7 +446,7 @@
 
 void LIR_Assembler::add_debug_info_for_div0(int pc_offset, CodeEmitInfo* cinfo) {
   DivByZeroStub* stub = new DivByZeroStub(pc_offset, cinfo);
-  emit_code_stub(stub);
+  append_code_stub(stub);
 }
 
 void LIR_Assembler::emit_rtcall(LIR_OpRTCall* op) {
--- a/src/share/vm/c1/c1_LIRAssembler.hpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/c1/c1_LIRAssembler.hpp	Thu Jun 05 19:39:08 2014 -0700
@@ -144,7 +144,7 @@
   // stubs
   void emit_slow_case_stubs();
   void emit_static_call_stub();
-  void emit_code_stub(CodeStub* op);
+  void append_code_stub(CodeStub* op);
   void add_call_info_here(CodeEmitInfo* info)                              { add_call_info(code_offset(), info); }
 
   // code patterns
--- a/src/share/vm/c1/c1_LinearScan.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/c1/c1_LinearScan.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -2382,16 +2382,6 @@
   int arg_count = frame_map()->oop_map_arg_count();
   OopMap* map = new OopMap(frame_size, arg_count);
 
-  // Check if this is a patch site.
-  bool is_patch_info = false;
-  if (op->code() == lir_move) {
-    assert(!is_call_site, "move must not be a call site");
-    assert(op->as_Op1() != NULL, "move must be LIR_Op1");
-    LIR_Op1* move = (LIR_Op1*)op;
-
-    is_patch_info = move->patch_code() != lir_patch_none;
-  }
-
   // Iterate through active intervals
   for (Interval* interval = iw->active_first(fixedKind); interval != Interval::end(); interval = interval->next()) {
     int assigned_reg = interval->assigned_reg();
@@ -2406,7 +2396,7 @@
     // moves, any intervals which end at this instruction are included
     // in the oop map since we may safepoint while doing the patch
     // before we've consumed the inputs.
-    if (is_patch_info || op->id() < interval->current_to()) {
+    if (op->is_patching() || op->id() < interval->current_to()) {
 
       // caller-save registers must not be included into oop-maps at calls
       assert(!is_call_site || assigned_reg >= nof_regs || !is_caller_save(assigned_reg), "interval is in a caller-save register at a call -> register will be overwritten");
--- a/src/share/vm/classfile/classLoaderData.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/classfile/classLoaderData.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -274,6 +274,8 @@
   MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
   Klass* old_value = _klasses;
   k->set_next_link(old_value);
+  // Make sure linked class is stable, since the class list is walked without a lock
+  OrderAccess::storestore();
   // link the new item into the list
   _klasses = k;
 
--- a/src/share/vm/classfile/verifier.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/classfile/verifier.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -2036,7 +2036,7 @@
     while ((bcp + padding_offset) < aligned_bcp) {
       if(*(bcp + padding_offset) != 0) {
         verify_error(ErrorContext::bad_code(bci),
-                     "Nonzero padding byte in lookswitch or tableswitch");
+                     "Nonzero padding byte in lookupswitch or tableswitch");
         return;
       }
       padding_offset++;
--- a/src/share/vm/compiler/compilerOracle.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/compiler/compilerOracle.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -307,6 +307,9 @@
   return (check_predicate(PrintCommand, method));
 }
 
+bool CompilerOracle::should_print_methods() {
+  return lists[PrintCommand] != NULL;
+}
 
 bool CompilerOracle::should_log(methodHandle method) {
   if (!LogCompilation)            return false;
--- a/src/share/vm/compiler/compilerOracle.hpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/compiler/compilerOracle.hpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1998, 2012, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1998, 2014, 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
@@ -73,6 +73,9 @@
   // For updating the oracle file
   static void append_comment_to_file(const char* message);
   static void append_exclude_to_file(methodHandle method);
+
+  // Tells whether there are any methods to print for print_method_statistics()
+  static bool should_print_methods();
 };
 
 #endif // SHARE_VM_COMPILER_COMPILERORACLE_HPP
--- a/src/share/vm/interpreter/interpreterRuntime.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/interpreter/interpreterRuntime.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1267,8 +1267,10 @@
 // This is a support of the JVMTI PopFrame interface.
 // Make sure it is an invokestatic of a polymorphic intrinsic that has a member_name argument
 // and return it as a vm_result so that it can be reloaded in the list of invokestatic parameters.
-// The dmh argument is a reference to a DirectMethoHandle that has a member name field.
-IRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* thread, address dmh,
+// The member_name argument is a saved reference (in local#0) to the member_name.
+// For backward compatibility with some JDK versions (7, 8) it can also be a direct method handle.
+// FIXME: remove DMH case after j.l.i.InvokerBytecodeGenerator code shape is updated.
+IRT_ENTRY(void, InterpreterRuntime::member_name_arg_or_null(JavaThread* thread, address member_name,
                                                             Method* method, address bcp))
   Bytecodes::Code code = Bytecodes::code_at(method, bcp);
   if (code != Bytecodes::_invokestatic) {
@@ -1280,8 +1282,12 @@
   Symbol* mname = cpool->name_ref_at(cp_index);
 
   if (MethodHandles::has_member_arg(cname, mname)) {
-    oop member_name = java_lang_invoke_DirectMethodHandle::member((oop)dmh);
-    thread->set_vm_result(member_name);
+    oop member_name_oop = (oop) member_name;
+    if (java_lang_invoke_DirectMethodHandle::is_instance(member_name_oop)) {
+      // FIXME: remove after j.l.i.InvokerBytecodeGenerator code shape is updated.
+      member_name_oop = java_lang_invoke_DirectMethodHandle::member(member_name_oop);
+    }
+    thread->set_vm_result(member_name_oop);
   }
 IRT_END
 #endif // INCLUDE_JVMTI
--- a/src/share/vm/memory/metaspace.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/memory/metaspace.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -3095,7 +3095,7 @@
 
 void Metaspace::global_initialize() {
   // Initialize the alignment for shared spaces.
-  int max_alignment = os::vm_page_size();
+  int max_alignment = os::vm_allocation_granularity();
   size_t cds_total = 0;
 
   MetaspaceShared::set_max_alignment(max_alignment);
--- a/src/share/vm/oops/instanceKlass.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/oops/instanceKlass.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1273,6 +1273,12 @@
 
 
 void InstanceKlass::methods_do(void f(Method* method)) {
+  // Methods aren't stable until they are loaded.  This can be read outside
+  // a lock through the ClassLoaderData for profiling
+  if (!is_loaded()) {
+    return;
+  }
+
   int len = methods()->length();
   for (int index = 0; index < len; index++) {
     Method* m = methods()->at(index);
--- a/src/share/vm/opto/c2compiler.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/opto/c2compiler.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -155,6 +155,9 @@
       }
     }
 
+    // print inlining for last compilation only
+    C.dump_print_inlining();
+
     // No retry; just break the loop.
     break;
   }
--- a/src/share/vm/opto/compile.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/opto/compile.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -672,6 +672,7 @@
                   _print_inlining_list(NULL),
                   _print_inlining_stream(NULL),
                   _print_inlining_idx(0),
+                  _print_inlining_output(NULL),
                   _preserve_jvm_state(0),
                   _interpreter_frame_size(0) {
   C = this;
@@ -978,6 +979,7 @@
     _print_inlining_list(NULL),
     _print_inlining_stream(NULL),
     _print_inlining_idx(0),
+    _print_inlining_output(NULL),
     _preserve_jvm_state(0),
     _allowed_reasons(0),
     _interpreter_frame_size(0) {
@@ -2207,7 +2209,7 @@
 
  } // (End scope of igvn; run destructor if necessary for asserts.)
 
-  dump_inlining();
+  process_print_inlining();
   // A method with only infinite loops has no edges entering loops from root
   {
     NOT_PRODUCT( TracePhase t2("graphReshape", &_t_graphReshaping, TimeCompiler); )
@@ -3868,7 +3870,7 @@
   assert(!_print_inlining || _print_inlining_stream->size() == 0, "loosing data");
 }
 
-void Compile::dump_inlining() {
+void Compile::process_print_inlining() {
   bool do_print_inlining = print_inlining() || print_intrinsics();
   if (do_print_inlining || log() != NULL) {
     // Print inlining message for candidates that we couldn't inline
@@ -3885,9 +3887,21 @@
     }
   }
   if (do_print_inlining) {
+    ResourceMark rm;
+    stringStream ss;
     for (int i = 0; i < _print_inlining_list->length(); i++) {
-      tty->print("%s", _print_inlining_list->adr_at(i)->ss()->as_string());
+      ss.print("%s", _print_inlining_list->adr_at(i)->ss()->as_string());
     }
+    size_t end = ss.size();
+    _print_inlining_output = NEW_ARENA_ARRAY(comp_arena(), char, end+1);
+    strncpy(_print_inlining_output, ss.base(), end+1);
+    _print_inlining_output[end] = 0;
+  }
+}
+
+void Compile::dump_print_inlining() {
+  if (_print_inlining_output != NULL) {
+    tty->print_raw(_print_inlining_output);
   }
 }
 
--- a/src/share/vm/opto/compile.hpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/opto/compile.hpp	Thu Jun 05 19:39:08 2014 -0700
@@ -420,6 +420,7 @@
   stringStream* _print_inlining_stream;
   GrowableArray<PrintInliningBuffer>* _print_inlining_list;
   int _print_inlining_idx;
+  char* _print_inlining_output;
 
   // Only keep nodes in the expensive node list that need to be optimized
   void cleanup_expensive_nodes(PhaseIterGVN &igvn);
@@ -917,7 +918,8 @@
 
   void remove_useless_late_inlines(GrowableArray<CallGenerator*>* inlines, Unique_Node_List &useful);
 
-  void dump_inlining();
+  void process_print_inlining();
+  void dump_print_inlining();
 
   bool over_inlining_cutoff() const {
     if (!inlining_incrementally()) {
--- a/src/share/vm/prims/jvmtiEnv.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/prims/jvmtiEnv.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -307,9 +307,9 @@
       !java_lang_Class::is_primitive(mirror)) {
     Klass* k = java_lang_Class::as_Klass(mirror);
     assert(k != NULL, "class for non-primitive mirror must exist");
-    *size_ptr = k->size() * wordSize;
+    *size_ptr = (jlong)k->size() * wordSize;
   } else {
-    *size_ptr = mirror->size() * wordSize;
+    *size_ptr = (jlong)mirror->size() * wordSize;
     }
   return JVMTI_ERROR_NONE;
 } /* end GetObjectSize */
--- a/src/share/vm/prims/whitebox.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/prims/whitebox.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -33,9 +33,11 @@
 #include "prims/whitebox.hpp"
 #include "prims/wbtestmethods/parserTests.hpp"
 
+#include "runtime/thread.hpp"
 #include "runtime/arguments.hpp"
 #include "runtime/interfaceSupport.hpp"
 #include "runtime/os.hpp"
+
 #include "utilities/debug.hpp"
 #include "utilities/macros.hpp"
 #include "utilities/exceptions.hpp"
@@ -576,6 +578,15 @@
 WB_END
 
 
+WB_ENTRY(jlong, WB_GetThreadStackSize(JNIEnv* env, jobject o))
+  return (jlong) Thread::current()->stack_size();
+WB_END
+
+WB_ENTRY(jlong, WB_GetThreadRemainingStackSize(JNIEnv* env, jobject o))
+  JavaThread* t = JavaThread::current();
+  return (jlong) t->stack_available(os::current_stack_pointer()) - (jlong) StackShadowPages * os::vm_page_size();
+WB_END
+
 //Some convenience methods to deal with objects from java
 int WhiteBox::offset_for_field(const char* field_name, oop object,
     Symbol* signature_symbol) {
@@ -690,6 +701,8 @@
   {CC"getCPUFeatures",     CC"()Ljava/lang/String;",  (void*)&WB_GetCPUFeatures     },
   {CC"getNMethod",         CC"(Ljava/lang/reflect/Executable;Z)[Ljava/lang/Object;",
                                                       (void*)&WB_GetNMethod         },
+  {CC"getThreadStackSize", CC"()J",                   (void*)&WB_GetThreadStackSize },
+  {CC"getThreadRemainingStackSize", CC"()J",          (void*)&WB_GetThreadRemainingStackSize },
 };
 
 #undef CC
--- a/src/share/vm/runtime/arguments.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/runtime/arguments.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1449,7 +1449,7 @@
   return true;
 }
 
-uintx Arguments::max_heap_for_compressed_oops() {
+size_t Arguments::max_heap_for_compressed_oops() {
   // Avoid sign flip.
   assert(OopEncodingHeapMax > (uint64_t)os::vm_page_size(), "Unusual page size");
   // We need to fit both the NULL page and the heap into the memory budget, while
--- a/src/share/vm/runtime/java.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/runtime/java.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -120,7 +120,8 @@
 }
 
 void print_method_profiling_data() {
-  if (ProfileInterpreter COMPILER1_PRESENT(|| C1UpdateMethodData)) {
+  if (ProfileInterpreter COMPILER1_PRESENT(|| C1UpdateMethodData) &&
+     (PrintMethodData || CompilerOracle::should_print_methods())) {
     ResourceMark rm;
     HandleMark hm;
     collected_profiled_methods = new GrowableArray<Method*>(1024);
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/vm/runtime/sharedRuntimeMath.hpp	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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.
+ *
+ */
+
+#ifndef SHARE_VM_RUNTIME_SHAREDRUNTIMEMATH_HPP
+#define SHARE_VM_RUNTIME_SHAREDRUNTIMEMATH_HPP
+
+#include <math.h>
+
+// VM_LITTLE_ENDIAN is #defined appropriately in the Makefiles
+// [jk] this is not 100% correct because the float word order may different
+// from the byte order (e.g. on ARM FPA)
+#ifdef VM_LITTLE_ENDIAN
+# define __HI(x) *(1+(int*)&x)
+# define __LO(x) *(int*)&x
+#else
+# define __HI(x) *(int*)&x
+# define __LO(x) *(1+(int*)&x)
+#endif
+
+static double copysignA(double x, double y) {
+  __HI(x) = (__HI(x)&0x7fffffff)|(__HI(y)&0x80000000);
+  return x;
+}
+
+/*
+ * ====================================================
+ * Copyright (c) 1998 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Developed at SunSoft, a Sun Microsystems, Inc. business.
+ * Permission to use, copy, modify, and distribute this
+ * software is freely granted, provided that this notice
+ * is preserved.
+ * ====================================================
+ */
+
+/*
+ * scalbn (double x, int n)
+ * scalbn(x,n) returns x* 2**n  computed by  exponent
+ * manipulation rather than by actually performing an
+ * exponentiation or a multiplication.
+ */
+
+static const double
+two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
+twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
+hugeX  = 1.0e+300,
+tiny   = 1.0e-300;
+
+static double scalbnA (double x, int n) {
+  int  k,hx,lx;
+  hx = __HI(x);
+  lx = __LO(x);
+  k = (hx&0x7ff00000)>>20;              /* extract exponent */
+  if (k==0) {                           /* 0 or subnormal x */
+    if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */
+    x *= two54;
+    hx = __HI(x);
+    k = ((hx&0x7ff00000)>>20) - 54;
+    if (n< -50000) return tiny*x;       /*underflow*/
+  }
+  if (k==0x7ff) return x+x;             /* NaN or Inf */
+  k = k+n;
+  if (k >  0x7fe) return hugeX*copysignA(hugeX,x); /* overflow  */
+  if (k > 0)                            /* normal result */
+    {__HI(x) = (hx&0x800fffff)|(k<<20); return x;}
+  if (k <= -54) {
+    if (n > 50000)      /* in case integer overflow in n+k */
+      return hugeX*copysignA(hugeX,x);  /*overflow*/
+    else return tiny*copysignA(tiny,x); /*underflow*/
+  }
+  k += 54;                              /* subnormal result */
+  __HI(x) = (hx&0x800fffff)|(k<<20);
+  return x*twom54;
+}
+
+#endif // SHARE_VM_RUNTIME_SHAREDRUNTIMEMATH_HPP
--- a/src/share/vm/runtime/sharedRuntimeTrans.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/runtime/sharedRuntimeTrans.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2005, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2005, 2014, 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
@@ -43,78 +43,7 @@
 # pragma optimize ( "", off )
 #endif
 
-#include <math.h>
-
-// VM_LITTLE_ENDIAN is #defined appropriately in the Makefiles
-// [jk] this is not 100% correct because the float word order may different
-// from the byte order (e.g. on ARM)
-#ifdef VM_LITTLE_ENDIAN
-# define __HI(x) *(1+(int*)&x)
-# define __LO(x) *(int*)&x
-#else
-# define __HI(x) *(int*)&x
-# define __LO(x) *(1+(int*)&x)
-#endif
-
-#if !defined(AIX)
-double copysign(double x, double y) {
-  __HI(x) = (__HI(x)&0x7fffffff)|(__HI(y)&0x80000000);
-  return x;
-}
-#endif
-
-/*
- * ====================================================
- * Copyright (c) 1998 Oracle and/or its affiliates. All rights reserved.
- *
- * Developed at SunSoft, a Sun Microsystems, Inc. business.
- * Permission to use, copy, modify, and distribute this
- * software is freely granted, provided that this notice
- * is preserved.
- * ====================================================
- */
-
-/*
- * scalbn (double x, int n)
- * scalbn(x,n) returns x* 2**n  computed by  exponent
- * manipulation rather than by actually performing an
- * exponentiation or a multiplication.
- */
-
-static const double
-two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
-  twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
-  hugeX   = 1.0e+300,
-  tiny   = 1.0e-300;
-
-#if !defined(AIX)
-double scalbn (double x, int n) {
-  int  k,hx,lx;
-  hx = __HI(x);
-  lx = __LO(x);
-  k = (hx&0x7ff00000)>>20;              /* extract exponent */
-  if (k==0) {                           /* 0 or subnormal x */
-    if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */
-    x *= two54;
-    hx = __HI(x);
-    k = ((hx&0x7ff00000)>>20) - 54;
-    if (n< -50000) return tiny*x;       /*underflow*/
-  }
-  if (k==0x7ff) return x+x;             /* NaN or Inf */
-  k = k+n;
-  if (k >  0x7fe) return hugeX*copysign(hugeX,x); /* overflow  */
-  if (k > 0)                            /* normal result */
-    {__HI(x) = (hx&0x800fffff)|(k<<20); return x;}
-  if (k <= -54) {
-    if (n > 50000)      /* in case integer overflow in n+k */
-      return hugeX*copysign(hugeX,x);   /*overflow*/
-    else return tiny*copysign(tiny,x);  /*underflow*/
-  }
-  k += 54;                              /* subnormal result */
-  __HI(x) = (hx&0x800fffff)|(k<<20);
-  return x*twom54;
-}
-#endif
+#include "runtime/sharedRuntimeMath.hpp"
 
 /* __ieee754_log(x)
  * Return the logarithm of x
@@ -719,7 +648,7 @@
   z  = one-(r-z);
   j  = __HI(z);
   j += (n<<20);
-  if((j>>20)<=0) z = scalbn(z,n);       /* subnormal output */
+  if((j>>20)<=0) z = scalbnA(z,n);       /* subnormal output */
   else __HI(z) += (n<<20);
   return s*z;
 }
--- a/src/share/vm/runtime/sharedRuntimeTrig.cpp	Wed Jun 04 20:20:09 2014 -0700
+++ b/src/share/vm/runtime/sharedRuntimeTrig.cpp	Thu Jun 05 19:39:08 2014 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2001, 2010, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2001, 2014, 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
@@ -63,63 +63,7 @@
 #define SAFEBUF
 #endif
 
-#include <math.h>
-
-// VM_LITTLE_ENDIAN is #defined appropriately in the Makefiles
-// [jk] this is not 100% correct because the float word order may different
-// from the byte order (e.g. on ARM)
-#ifdef VM_LITTLE_ENDIAN
-# define __HI(x) *(1+(int*)&x)
-# define __LO(x) *(int*)&x
-#else
-# define __HI(x) *(int*)&x
-# define __LO(x) *(1+(int*)&x)
-#endif
-
-static double copysignA(double x, double y) {
-  __HI(x) = (__HI(x)&0x7fffffff)|(__HI(y)&0x80000000);
-  return x;
-}
-
-/*
- * scalbn (double x, int n)
- * scalbn(x,n) returns x* 2**n  computed by  exponent
- * manipulation rather than by actually performing an
- * exponentiation or a multiplication.
- */
-
-static const double
-two54   =  1.80143985094819840000e+16, /* 0x43500000, 0x00000000 */
-twom54  =  5.55111512312578270212e-17, /* 0x3C900000, 0x00000000 */
-hugeX  = 1.0e+300,
-tiny   = 1.0e-300;
-
-static double scalbnA (double x, int n) {
-  int  k,hx,lx;
-  hx = __HI(x);
-  lx = __LO(x);
-  k = (hx&0x7ff00000)>>20;              /* extract exponent */
-  if (k==0) {                           /* 0 or subnormal x */
-    if ((lx|(hx&0x7fffffff))==0) return x; /* +-0 */
-    x *= two54;
-    hx = __HI(x);
-    k = ((hx&0x7ff00000)>>20) - 54;
-    if (n< -50000) return tiny*x;       /*underflow*/
-  }
-  if (k==0x7ff) return x+x;             /* NaN or Inf */
-  k = k+n;
-  if (k >  0x7fe) return hugeX*copysignA(hugeX,x); /* overflow  */
-  if (k > 0)                            /* normal result */
-    {__HI(x) = (hx&0x800fffff)|(k<<20); return x;}
-  if (k <= -54) {
-    if (n > 50000)      /* in case integer overflow in n+k */
-      return hugeX*copysignA(hugeX,x);  /*overflow*/
-    else return tiny*copysignA(tiny,x); /*underflow*/
-  }
-  k += 54;                              /* subnormal result */
-  __HI(x) = (hx&0x800fffff)|(k<<20);
-  return x*twom54;
-}
+#include "runtime/sharedRuntimeMath.hpp"
 
 /*
  * __kernel_rem_pio2(x,y,e0,nx,prec,ipio2)
--- a/test/TEST.groups	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/TEST.groups	Thu Jun 05 19:39:08 2014 -0700
@@ -83,6 +83,7 @@
   runtime/RedefineObject/TestRedefineObject.java \
   runtime/XCheckJniJsig/XCheckJSig.java \
   serviceability/attach/AttachWithStalePidFile.java \
+  serviceability/jvmti/8036666/GetObjectLockCount.java \
   serviceability/sa/jmap-hprof/JMapHProfLargeHeapTest.java \
   serviceability/dcmd/DynLibDcmdTest.java
 
@@ -134,9 +135,12 @@
   gc/parallelScavenge/TestDynShrinkHeap.java \
   runtime/InternalApi/ThreadCpuTimesDeadlock.java \
   serviceability/threads/TestFalseDeadLock.java \
+  serviceability/jvmti/GetObjectSizeOverflow.java \
+  serviceability/jvmti/TestRedefineWithUnresolvedClass.java \
   compiler/tiered/NonTieredLevelsTest.java \
   compiler/tiered/TieredLevelsTest.java \
-  compiler/intrinsics/bmi/verifycode
+  compiler/intrinsics/bmi/verifycode \
+  runtime/whitebox/WBStackSize.java
 
 # Compact 2 adds full VM tests
 compact2 = \
--- a/test/compiler/5091921/Test7005594.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/5091921/Test7005594.java	Thu Jun 05 19:39:08 2014 -0700
@@ -25,7 +25,6 @@
 /**
  * @test
  * @bug 7005594
- * @ignore 7117034
  * @summary Array overflow not handled correctly with loop optimzations
  *
  * @run shell Test7005594.sh
--- a/test/compiler/5091921/Test7005594.sh	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/5091921/Test7005594.sh	Thu Jun 05 19:39:08 2014 -0700
@@ -78,7 +78,7 @@
 
 ${COMPILEJAVA}/bin/javac ${TESTJAVACOPTS} -d . Test7005594.java
 
-${TESTJAVA}/bin/java ${TESTVMOPTS} -Xms1600m -XX:+IgnoreUnrecognizedVMOptions -XX:-ZapUnusedHeapArea -Xcomp -XX:CompileOnly=Test7005594.test Test7005594 > test.out 2>&1
+${TESTJAVA}/bin/java ${TESTVMOPTS} -Xmx1600m -Xms1600m -XX:+IgnoreUnrecognizedVMOptions -XX:-ZapUnusedHeapArea -Xcomp -XX:CompileOnly=Test7005594.test Test7005594 > test.out 2>&1
 
 result=$?
 
@@ -97,7 +97,7 @@
 fi
 
 # The test should pass when no enough space for object heap
-grep "Could not reserve enough space for object heap" test.out
+grep "Could not reserve enough space for .*object heap" test.out
 if [ $? = 0 ]
 then
   echo "Passed"
--- a/test/compiler/arguments/BMICommandLineOptionTestBase.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/arguments/BMICommandLineOptionTestBase.java	Thu Jun 05 19:39:08 2014 -0700
@@ -25,6 +25,12 @@
 
 /**
  * Base class for all X86 bit manipulation related command line options.
+ *
+ * Note that this test intended to verify that VM could be launched with
+ * specific options and that values of these options processed correctly.
+ * In order to do that test launch a new VM with tested options, the same
+ * flavor-specific flag as one that was used for parent VM (-client, -server,
+ * -minimal, -graal) and '-version'.
  */
 public abstract class BMICommandLineOptionTestBase
               extends CPUSpecificCommandLineOptionTest {
@@ -58,10 +64,11 @@
                                         String supportedCPUFeatures[],
                                         String unsupportedCPUFeatures[]) {
         super(".*", supportedCPUFeatures, unsupportedCPUFeatures);
-            this.optionName = optionName;
-            this.warningMessage = warningMessage;
-            this.errorMessage = CommandLineOptionTest.
-                UNRECOGNIZED_OPTION_ERROR_FORMAT.format(optionName);
+        this.optionName = optionName;
+        this.warningMessage = warningMessage;
+        this.errorMessage = String.format(
+                CommandLineOptionTest.UNRECOGNIZED_OPTION_ERROR_FORMAT,
+                optionName);
     }
 
 }
--- a/test/compiler/arguments/BMISupportedCPUTest.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/arguments/BMISupportedCPUTest.java	Thu Jun 05 19:39:08 2014 -0700
@@ -28,6 +28,12 @@
  * Test on bit manipulation related command line options,
  * that should be executed on CPU that supports all required
  * features.
+ *
+ * Note that this test intended to verify that VM could be launched with
+ * specific options and that values of these options processed correctly.
+ * In order to do that test launch a new VM with tested options, the same
+ * flavor-specific flag as one that was used for parent VM (-client, -server,
+ * -minimal, -graal) and '-version'.
  */
 public class BMISupportedCPUTest extends BMICommandLineOptionTestBase {
 
@@ -49,24 +55,38 @@
 
     @Override
     public void runTestCases() throws Throwable {
-        // verify that VM will succesfully start up whithout warnings
-        CommandLineOptionTest.
-            verifyJVMStartup("-XX:+" + optionName,
-                             null, new String[] { warningMessage },
-                             ExitCode.OK);
+        /*
+          Verify that VM will successfully start up without warnings.
+          VM will be launched with following flags:
+          -XX:+<tested option> -version
+        */
+        CommandLineOptionTest.verifySameJVMStartup(null,
+                new String[] { warningMessage }, ExitCode.OK,
+                CommandLineOptionTest.prepareBooleanFlag(optionName, true));
 
-        // verify that VM will succesfully start up whithout warnings
-        CommandLineOptionTest.
-            verifyJVMStartup("-XX:-" + optionName,
-                             null, new String[] { warningMessage },
-                             ExitCode.OK);
+        /*
+          Verify that VM will successfully start up without warnings.
+          VM will be launched with following flags:
+          -XX:-<tested option> -version
+        */
+        CommandLineOptionTest.verifySameJVMStartup(null,
+                new String[] { warningMessage }, ExitCode.OK,
+                CommandLineOptionTest.prepareBooleanFlag(optionName, false));
 
-        // verify that on appropriate CPU option in on by default
-        CommandLineOptionTest.verifyOptionValue(optionName, "true");
+        /*
+          Verify that on appropriate CPU option in on by default.
+          VM will be launched with following flags:
+          -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true");
 
-        // verify that option could be explicitly turned off
-        CommandLineOptionTest.verifyOptionValue(optionName, "false",
-                                                "-XX:-" + optionName);
+        /*
+          Verify that option could be explicitly turned off.
+          VM will be launched with following flags:
+          -XX:-<tested option> -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+                CommandLineOptionTest.prepareBooleanFlag(optionName, false));
     }
 }
 
--- a/test/compiler/arguments/BMIUnsupportedCPUTest.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/arguments/BMIUnsupportedCPUTest.java	Thu Jun 05 19:39:08 2014 -0700
@@ -28,6 +28,12 @@
  * Test on bit manipulation related command line options,
  * that should be executed on CPU that does not support
  * required features.
+ *
+ * Note that this test intended to verify that VM could be launched with
+ * specific options and that values of these options processed correctly.
+ * In order to do that test launch a new VM with tested options, the same
+ * flavor-specific flag as one that was used for parent VM (-client, -server,
+ * -minimal, -graal) and '-version'.
  */
 public class BMIUnsupportedCPUTest extends BMICommandLineOptionTestBase {
 
@@ -64,28 +70,38 @@
      */
     public void unsupportedX86CPUTestCases() throws Throwable {
 
-        // verify that VM will succesfully start up, but output will
-        // contain a warning
-        CommandLineOptionTest.
-            verifyJVMStartup("-XX:+" + optionName,
-                             new String[] { warningMessage },
-                             new String[] { errorMessage },
-                             ExitCode.OK);
+        /*
+          Verify that VM will successfully start up, but output will contain a
+          warning. VM will be launched with following options:
+          -XX:+<tested option> -version
+        */
+        CommandLineOptionTest.verifySameJVMStartup(
+                new String[] { warningMessage }, new String[] { errorMessage },
+                ExitCode.OK, CommandLineOptionTest.prepareBooleanFlag(
+                        optionName, true));
 
-        // verify that VM will succesfully startup without any warnings
-        CommandLineOptionTest.
-            verifyJVMStartup("-XX:-" + optionName,
-                             null,
-                             new String[] { warningMessage, errorMessage },
-                             ExitCode.OK);
+        /*
+          Verify that VM will successfully startup without any warnings.
+          VM will be launched with following options:
+          -XX:-<tested option> -version
+        */
+        CommandLineOptionTest.verifySameJVMStartup(null,
+                new String[] { warningMessage, errorMessage }, ExitCode.OK,
+                CommandLineOptionTest.prepareBooleanFlag(optionName, false));
 
-        // verify that on unsupported CPUs option is off by default
-        CommandLineOptionTest.verifyOptionValue(optionName, "false");
+        /*
+          Verify that on unsupported CPUs option is off by default.
+          VM will be launched with following options: -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false");
 
-        // verify that on unsupported CPUs option will be off even if
-        // it was explicitly turned on by uset
-        CommandLineOptionTest.verifyOptionValue(optionName, "false",
-                                                     "-XX:+" + optionName);
+        /*
+          Verify that on unsupported CPUs option will be off even if
+          it was explicitly turned on by user. VM will be launched with
+          following options: -XX:+<tested option> -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+                CommandLineOptionTest.prepareBooleanFlag(optionName, true));
 
     }
 
@@ -97,18 +113,17 @@
      */
     public void unsupportedNonX86CPUTestCases() throws Throwable {
 
-        // verify that VM known nothing about tested option
-        CommandLineOptionTest.
-            verifyJVMStartup("-XX:+" + optionName,
-                             new String[] { errorMessage },
-                             null,
-                             ExitCode.FAIL);
+        /*
+          Verify that VM known nothing about tested option. VM will be launched
+          with following options: -XX:[+-]<tested option> -version
+        */
+        CommandLineOptionTest.verifySameJVMStartup(
+                new String[] { errorMessage }, null, ExitCode.FAIL,
+                CommandLineOptionTest.prepareBooleanFlag(optionName, true));
 
-        CommandLineOptionTest.
-            verifyJVMStartup("-XX:-" + optionName,
-                             new String[] { errorMessage },
-                             null,
-                             ExitCode.FAIL);
+        CommandLineOptionTest.verifySameJVMStartup(
+                new String[] { errorMessage }, null, ExitCode.FAIL,
+                CommandLineOptionTest.prepareBooleanFlag(optionName, false));
     }
 }
 
--- a/test/compiler/arguments/TestUseCountTrailingZerosInstructionOnSupportedCPU.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/arguments/TestUseCountTrailingZerosInstructionOnSupportedCPU.java	Thu Jun 05 19:39:08 2014 -0700
@@ -40,7 +40,8 @@
 import com.oracle.java.testlibrary.cli.*;
 
 public class TestUseCountTrailingZerosInstructionOnSupportedCPU
-     extends BMISupportedCPUTest {
+        extends BMISupportedCPUTest {
+    private static final String DISABLE_BMI = "-XX:-UseBMI1Instructions";
 
     public TestUseCountTrailingZerosInstructionOnSupportedCPU() {
         super("UseCountTrailingZerosInstruction", TZCNT_WARNING, "bmi1");
@@ -51,18 +52,23 @@
 
         super.runTestCases();
 
-        // verify that option will be disabled if all BMI1 instuctions
-        // are explicitly disabled
-        CommandLineOptionTest.
-            verifyOptionValue("UseCountTrailingZerosInstruction", "false",
-                              "-XX:-UseBMI1Instructions");
+        /*
+          Verify that option will be disabled if all BMI1 instructions
+          are explicitly disabled. VM will be launched with following options:
+          -XX:-UseBMI1Instructions -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+                TestUseCountTrailingZerosInstructionOnSupportedCPU.DISABLE_BMI);
 
-        // verify that option could be turned on even if other BMI1
-        // instructions were turned off
-        CommandLineOptionTest.
-            verifyOptionValue("UseCountTrailingZerosInstruction", "true",
-                              "-XX:-UseBMI1Instructions",
-                              "-XX:+UseCountTrailingZerosInstruction");
+        /*
+          Verify that option could be turned on even if other BMI1
+          instructions were turned off. VM will be launched with following
+          options: -XX:-UseBMI1Instructions
+          -XX:+UseCountTrailingZerosInstruction -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "true",
+                TestUseCountTrailingZerosInstructionOnSupportedCPU.DISABLE_BMI,
+                CommandLineOptionTest.prepareBooleanFlag(optionName, true));
     }
 
     public static void main(String args[]) throws Throwable {
--- a/test/compiler/arguments/TestUseCountTrailingZerosInstructionOnUnsupportedCPU.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/arguments/TestUseCountTrailingZerosInstructionOnUnsupportedCPU.java	Thu Jun 05 19:39:08 2014 -0700
@@ -25,7 +25,7 @@
  * @test
  * @bug 8031321
  * @summary Verify processing of UseCountTrailingZerosInstruction option
- *          on CPU without TZCNT instuction (BMI1 feature) support.
+ *          on CPU without TZCNT instruction (BMI1 feature) support.
  * @library /testlibrary /testlibrary/whitebox
  * @build TestUseCountTrailingZerosInstructionOnUnsupportedCPU
  *        BMIUnsupportedCPUTest
@@ -40,7 +40,8 @@
 import com.oracle.java.testlibrary.cli.*;
 
 public class TestUseCountTrailingZerosInstructionOnUnsupportedCPU
-     extends BMIUnsupportedCPUTest {
+        extends BMIUnsupportedCPUTest {
+    private static final String ENABLE_BMI = "-XX:+UseBMI1Instructions";
 
     public TestUseCountTrailingZerosInstructionOnUnsupportedCPU() {
         super("UseCountTrailingZerosInstruction", TZCNT_WARNING, "bmi1");
@@ -51,16 +52,24 @@
 
         super.unsupportedX86CPUTestCases();
 
-        // verify that option will not be turned on during
-        // UseBMI1Instuctions processing
-        CommandLineOptionTest.
-            verifyOptionValue("UseCountTrailingZerosInstruction", "false",
-                              "-XX:+UseBMI1Instructions");
+        /*
+          Verify that option will not be turned on during UseBMI1Instructions
+          processing. VM will be launched with following options:
+          -XX:+UseBMI1Instructions -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+                TestUseCountTrailingZerosInstructionOnUnsupportedCPU.
+                        ENABLE_BMI);
 
-        CommandLineOptionTest.
-            verifyOptionValue("UseCountTrailingZerosInstruction", "false",
-                              "-XX:+UseCountTrailingZerosInstruction",
-                              "-XX:+UseBMI1Instructions");
+        /*
+          VM will be launched with following options:
+          -XX:+UseCountTrailingZerosInstruction -XX:+UseBMI1Instructions
+          -version
+        */
+        CommandLineOptionTest.verifyOptionValueForSameVM(optionName, "false",
+                CommandLineOptionTest.prepareBooleanFlag(optionName, true),
+                TestUseCountTrailingZerosInstructionOnUnsupportedCPU.
+                        ENABLE_BMI);
     }
 
     public static void main(String args[]) throws Throwable {
--- a/test/compiler/uncommontrap/TestSpecTrapClassUnloading.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/compiler/uncommontrap/TestSpecTrapClassUnloading.java	Thu Jun 05 19:39:08 2014 -0700
@@ -25,7 +25,7 @@
  * @test
  * @bug 8031752
  * @summary speculative traps need to be cleaned up at GC
- * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-UseOnStackReplacement -XX:-BackgroundCompilation -XX:+UseTypeSpeculation -XX:TypeProfileLevel=222 -XX:CompileCommand=exclude,java.lang.reflect.Method::invoke -XX:CompileCommand=exclude,sun.reflect.DelegatingMethodAccessorImpl::invoke -Xmx1M TestSpecTrapClassUnloading
+ * @run main/othervm -XX:+IgnoreUnrecognizedVMOptions -XX:-TieredCompilation -XX:-UseOnStackReplacement -XX:-BackgroundCompilation -XX:+UseTypeSpeculation -XX:TypeProfileLevel=222 -XX:CompileCommand=exclude,java.lang.reflect.Method::invoke -XX:CompileCommand=exclude,sun.reflect.DelegatingMethodAccessorImpl::invoke -Xmx512M TestSpecTrapClassUnloading
  *
  */
 
@@ -45,7 +45,7 @@
         MemoryChunk other;
         long[] array;
         MemoryChunk(MemoryChunk other) {
-            other = other;
+            this.other = other;
             array = new long[1024 * 1024 * 1024];
         }
     }
--- a/test/gc/parallelScavenge/TestDynShrinkHeap.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/gc/parallelScavenge/TestDynShrinkHeap.java	Thu Jun 05 19:39:08 2014 -0700
@@ -26,7 +26,7 @@
  * @bug 8016479
  * @summary Verify that the heap shrinks after full GC according to the current values of the Min/MaxHeapFreeRatio flags
  * @library /testlibrary
- * @run main/othervm -XX:+UseAdaptiveSizePolicyWithSystemGC -XX:+UseParallelGC -XX:MinHeapFreeRatio=0 -XX:MaxHeapFreeRatio=100 -verbose:gc TestDynShrinkHeap
+ * @run main/othervm -XX:+UseAdaptiveSizePolicyWithSystemGC -XX:+UseParallelGC -XX:MinHeapFreeRatio=0 -XX:MaxHeapFreeRatio=100 -Xmx1g -verbose:gc TestDynShrinkHeap
  */
 import com.oracle.java.testlibrary.DynamicVMOption;
 import java.lang.management.ManagementFactory;
@@ -41,7 +41,7 @@
     public static final String MAX_FREE_RATIO_FLAG_NAME = "MaxHeapFreeRatio";
 
     private static ArrayList<byte[]> list = new ArrayList<>(0);
-    private static final int M = 1024 * 1024; // to make heap more manageable by test code
+    private static final int LEN = 512 * 1024 + 1;
 
     public TestDynShrinkHeap() {
     }
@@ -69,12 +69,12 @@
     }
 
     private void eat() {
-        for (int i = 0; i < M; i++) {
+        for (int i = 0; i < LEN; i++) {
             list.add(new byte[1024]);
         }
-        MemoryUsagePrinter.printMemoryUsage("allocated " + M + " arrays");
+        MemoryUsagePrinter.printMemoryUsage("allocated " + LEN + " arrays");
 
-        list.subList(0, M / 2).clear();
+        list.subList(0, LEN / 2).clear();
         System.gc();
         MemoryUsagePrinter.printMemoryUsage("array halved");
     }
--- a/test/runtime/6929067/T.java	Wed Jun 04 20:20:09 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,12 +0,0 @@
-public class T
-{
-  public static boolean foo(boolean bar)
-  {
-    return bar;
-  }
-
-  public static void printIt()
-  {
-    System.out.println("Hello");
-  }
-}
--- a/test/runtime/6929067/Test6929067.sh	Wed Jun 04 20:20:09 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,56 +0,0 @@
-#!/bin/sh
-
-##
-## @test Test6929067.sh
-## @bug 6929067
-## @bug 8021296
-## @bug 8025519
-## @summary Stack guard pages should be removed when thread is detached
-## @run shell Test6929067.sh
-##
-
-if [ "${TESTSRC}" = "" ]
-then
-  TESTSRC=${PWD}
-  echo "TESTSRC not set.  Using "${TESTSRC}" as default"
-fi
-echo "TESTSRC=${TESTSRC}"
-## Adding common setup Variables for running shell tests.
-. ${TESTSRC}/../../test_env.sh
-
-if [ "${VM_OS}" != "linux" ]
-then
-  echo "Test only valid for Linux"
-  exit 0
-fi
-
-gcc_cmd=`which gcc`
-if [ "x$gcc_cmd" = "x" ]; then
-  echo "WARNING: gcc not found. Cannot execute test." 2>&1
-  exit 0;
-fi
-
-CFLAGS=-m${VM_BITS}
-
-LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/${VM_CPU}/${VM_TYPE}:/usr/lib:$LD_LIBRARY_PATH
-export LD_LIBRARY_PATH
-
-cp ${TESTSRC}/*.java ${THIS_DIR}
-${COMPILEJAVA}/bin/javac *.java
-
-echo "Architecture: ${VM_CPU}"
-echo "Compilation flag: ${CFLAGS}"
-echo "VM type: ${VM_TYPE}"
-echo "LD_LIBRARY_PATH: ${LD_LIBRARY_PATH}"
-
-# Note pthread may not be found thus invoke creation will fail to be created.
-# Check to ensure you have a /usr/lib/libpthread.so if you don't please look
-# for /usr/lib/`uname -m`-linux-gnu version ensure to add that path to below compilation.
-
-$gcc_cmd -DLINUX ${CFLAGS} -o invoke \
-    -I${TESTJAVA}/include -I${TESTJAVA}/include/linux \
-    -L${TESTJAVA}/jre/lib/${VM_CPU}/${VM_TYPE} \
-     ${TESTSRC}/invoke.c -ljvm -lpthread
-
-./invoke
-exit $?
--- a/test/runtime/6929067/invoke.c	Wed Jun 04 20:20:09 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,90 +0,0 @@
-#include <assert.h>
-#include <jni.h>
-#include <alloca.h>
-
-#include <pthread.h>
-
-union env_union
-{
-  void *void_env;
-  JNIEnv *jni_env;
-};
-
-union env_union tmp;
-JNIEnv* env;
-JavaVM* jvm;
-JavaVMInitArgs vm_args;
-JavaVMOption options[1];
-jclass class_id;
-jmethodID method_id;
-jint result;
-
-long product(unsigned long n, unsigned long m) {
-    if (m == 1) {
-      return n;
-    } else {
-      int *p = alloca(sizeof (int));
-      *p = n;
-      return product (n, m-1) + *p;
-    }
-}
-
-void *
-floobydust (void *p)
-{
-  (*jvm)->AttachCurrentThread(jvm, &tmp.void_env, NULL);
-  env = tmp.jni_env;
-
-  class_id = (*env)->FindClass (env, "T");
-  assert (class_id);
-
-  method_id = (*env)->GetStaticMethodID (env, class_id, "printIt", "()V");
-  assert (method_id);
-
-  (*env)->CallStaticVoidMethod (env, class_id, method_id, NULL);
-
-  (*jvm)->DetachCurrentThread(jvm);
-
-  printf("%ld\n", product(5000,5000));
-
-  (*jvm)->AttachCurrentThread(jvm, &tmp.void_env, NULL);
-  env = tmp.jni_env;
-
-  class_id = (*env)->FindClass (env, "T");
-  assert (class_id);
-
-  method_id = (*env)->GetStaticMethodID (env, class_id, "printIt", "()V");
-  assert (method_id);
-
-  (*env)->CallStaticVoidMethod (env, class_id, method_id, NULL);
-
-  (*jvm)->DetachCurrentThread(jvm);
-
-  printf("%ld\n", product(5000,5000));
-
-  return NULL;
-}
-
-int
-main (int argc, const char** argv)
-{
-  options[0].optionString = "-Xss320k";
-
-  vm_args.version = JNI_VERSION_1_2;
-  vm_args.ignoreUnrecognized = JNI_TRUE;
-  vm_args.options = options;
-  vm_args.nOptions = 1;
-
-  result = JNI_CreateJavaVM (&jvm, &tmp.void_env, &vm_args);
-  assert (result >= 0);
-
-  env = tmp.jni_env;
-
-  floobydust (NULL);
-
-  pthread_t thr;
-  pthread_create (&thr, NULL, floobydust, NULL);
-  pthread_join (thr, NULL);
-
-  return 0;
-}
--- a/test/runtime/InitialThreadOverflow/DoOverflow.java	Wed Jun 04 20:20:09 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright (c) 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
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * 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.
- */
-
-public class DoOverflow {
-
-    static int count;
-
-    public void overflow() {
-        count+=1;
-        overflow();
-    }
-
-    public static void printIt() {
-        System.out.println("Going to overflow stack");
-        try {
-            new DoOverflow().overflow();
-        } catch(java.lang.StackOverflowError e) {
-            System.out.println("Overflow OK " + count);
-        }
-    }
-}
--- a/test/runtime/InitialThreadOverflow/invoke.c	Wed Jun 04 20:20:09 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,72 +0,0 @@
-/*
- * Copyright (c) 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
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * 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.
- */
-
-#include <assert.h>
-#include <jni.h>
-
-#include <pthread.h>
-
-JavaVM* jvm;
-
-void *
-floobydust (void *p) {
-  JNIEnv *env;
-  jclass class_id;
-  jmethodID method_id;
-
-  (*jvm)->AttachCurrentThread(jvm, (void**)&env, NULL);
-
-  class_id = (*env)->FindClass (env, "DoOverflow");
-  assert (class_id);
-
-  method_id = (*env)->GetStaticMethodID(env, class_id, "printIt", "()V");
-  assert (method_id);
-
-  (*env)->CallStaticVoidMethod(env, class_id, method_id, NULL);
-
-  (*jvm)->DetachCurrentThread(jvm);
-}
-
-int
-main (int argc, const char** argv) {
-  JavaVMOption options[1];
-  options[0].optionString = (char*) "-Xss320k";
-
-  JavaVMInitArgs vm_args;
-  vm_args.version = JNI_VERSION_1_2;
-  vm_args.ignoreUnrecognized = JNI_TRUE;
-  vm_args.options = options;
-  vm_args.nOptions = 1;
-
-  JNIEnv* env;
-  jint result = JNI_CreateJavaVM(&jvm, (void**)&env, &vm_args);
-  assert(result >= 0);
-
-  pthread_t thr;
-  pthread_create(&thr, NULL, floobydust, NULL);
-  pthread_join(thr, NULL);
-
-  floobydust(NULL);
-
-  return 0;
-}
--- a/test/runtime/InitialThreadOverflow/testme.sh	Wed Jun 04 20:20:09 2014 -0700
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,77 +0,0 @@
-#!/bin/sh
-
-# Copyright (c) 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
-# under the terms of the GNU General Public License version 2 only, as
-# published by the Free Software Foundation.
-#
-# This code is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-# version 2 for more details (a copy is included in the LICENSE file that
-# accompanied this code).
-#
-# You should have received a copy of the GNU General Public License version
-# 2 along with this work; if not, write to the Free Software Foundation,
-# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-# 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.
-
-# @test testme.sh
-# @bug 8009062
-# @summary Poor performance of JNI AttachCurrentThread after fix for 7017193
-# @compile DoOverflow.java
-# @run shell testme.sh
-
-set -x
-if [ "${TESTSRC}" = "" ]
-then
-  TESTSRC=${PWD}
-  echo "TESTSRC not set.  Using "${TESTSRC}" as default"
-fi
-echo "TESTSRC=${TESTSRC}"
-## Adding common setup Variables for running shell tests.
-. ${TESTSRC}/../../test_env.sh
-
-if [ "${VM_OS}" != "linux" ]
-then
-  echo "Test only valid for Linux"
-  exit 0
-fi
-
-gcc_cmd=`which gcc`
-if [ "x$gcc_cmd" = "x" ]; then
-    echo "WARNING: gcc not found. Cannot execute test." 2>&1
-    exit 0;
-fi
-
-CFLAGS="-m${VM_BITS}"
-
-LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/${VM_CPU}/${VM_TYPE}:/usr/lib:$LD_LIBRARY_PATH
-export LD_LIBRARY_PATH
-
-cp ${TESTSRC}/invoke.c .
-
-# Copy the result of our @compile action:
-cp ${TESTCLASSES}/DoOverflow.class .
-
-echo "Architecture: ${VM_CPU}"
-echo "Compilation flag: ${CFLAGS}"
-echo "VM type: ${VM_TYPE}"
-echo "LD_LIBRARY_PATH: ${LD_LIBRARY_PATH}"
-
-# Note pthread may not be found thus invoke creation will fail to be created.
-# Check to ensure you have a /usr/lib/libpthread.so if you don't please look
-# for /usr/lib/`uname -m`-linux-gnu version ensure to add that path to below compilation.
-
-$gcc_cmd -DLINUX ${CFLAGS} -o invoke \
-    -I${TESTJAVA}/include -I${TESTJAVA}/include/linux \
-    -L${TESTJAVA}/jre/lib/${VM_CPU}/${VM_TYPE} \
-    -ljvm -lpthread invoke.c
-
-./invoke
-exit $?
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/runtime/StackGuardPages/DoOverflow.java	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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.
+ */
+
+public class DoOverflow {
+
+    static int count;
+
+    public void overflow() {
+        count+=1;
+        overflow();
+    }
+
+    public static void printAlive() {
+      System.out.println("Java thread is alive.");
+    }
+
+    public static void printIt() {
+        System.out.println("Going to overflow stack");
+        try {
+            new DoOverflow().overflow();
+        } catch(java.lang.StackOverflowError e) {
+            System.out.println("Test PASSED. Got StackOverflowError at " + count + " iteration");
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/runtime/StackGuardPages/invoke.c	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,266 @@
+/*
+ * Copyright (c) 2010, 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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.
+ *
+ */
+
+/* This code tests the fact that we actually remove stack guard page when calling
+ * JavaThread::exit() i.e. when detaching from current thread.
+ * We overflow the stack and check that we get access error because of a guard page.
+ * Than we detach from vm thread and overflow stack once again. This time we shouldn't
+ * get access error because stack guard page is removed
+ *
+ * Notice: due a complicated interaction of signal handlers, the test may crash.
+ * It's OK - don't file a bug.
+ */
+
+#include <assert.h>
+#include <jni.h>
+#include <alloca.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <stdlib.h>
+#include <sys/ucontext.h>
+#include <setjmp.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <errno.h>
+
+#include <pthread.h>
+
+JavaVM* _jvm;
+
+static jmp_buf  context;
+
+static int _last_si_code = -1;
+static int _failures = 0;
+static int _rec_count = 0;
+static int _kp_rec_count = 0;
+
+pid_t gettid() {
+  return (pid_t) syscall(SYS_gettid);
+}
+
+static void handler(int sig, siginfo_t *si, void *unused) {
+  _last_si_code = si->si_code;
+  printf("Got SIGSEGV(%d) at address: 0x%lx\n",si->si_code, (long) si->si_addr);
+  longjmp(context, 1);
+}
+
+void set_signal_handler() {
+  static char altstack[SIGSTKSZ];
+
+  stack_t ss = {
+    .ss_size = SIGSTKSZ,
+    .ss_flags = 0,
+    .ss_sp = altstack
+  };
+
+  struct sigaction sa = {
+    .sa_sigaction = handler,
+    .sa_flags = SA_ONSTACK | SA_SIGINFO | SA_RESETHAND
+  };
+
+  _last_si_code = -1;
+
+  sigaltstack(&ss, 0);
+  sigemptyset(&sa.sa_mask);
+  if (sigaction(SIGSEGV, &sa, NULL) == -1) {
+    fprintf(stderr, "Test ERROR. Can't set sigaction (%d)\n", errno);
+    exit(7);
+  }
+}
+
+void *run_java_overflow (void *p) {
+  JNIEnv *env;
+  jclass class_id;
+  jmethodID method_id;
+  int res;
+
+  res = (*_jvm)->AttachCurrentThread(_jvm, (void**)&env, NULL);
+  if (res != JNI_OK) {
+    fprintf(stderr, "Test ERROR. Can't attach to current thread\n");
+    exit(7);
+  }
+
+  class_id = (*env)->FindClass (env, "DoOverflow");
+  if (class_id == NULL) {
+    fprintf(stderr, "Test ERROR. Can't load class DoOverflow\n");
+    exit(7);
+  }
+
+  method_id = (*env)->GetStaticMethodID(env, class_id, "printIt", "()V");
+  if (method_id == NULL) {
+    fprintf(stderr, "Test ERROR. Can't find method DoOverflow.printIt\n");
+    exit(7);
+  }
+
+  (*env)->CallStaticVoidMethod(env, class_id, method_id, NULL);
+
+  res = (*_jvm)->DetachCurrentThread(_jvm);
+  if (res != JNI_OK) {
+    fprintf(stderr, "Test ERROR. Can't call detach from current thread\n");
+    exit(7);
+  }
+}
+
+void do_overflow(){
+  int *p = alloca(sizeof(int));
+  if (_kp_rec_count == 0 || _rec_count < _kp_rec_count) {
+      _rec_count ++;
+      do_overflow();
+  }
+}
+
+void *run_native_overflow(void *p) {
+  // Test that stack guard page is correctly set for initial and non initial thread
+  // and correctly removed for the initial thread
+  JNIEnv *env;
+  jclass class_id;
+  jmethodID method_id;
+  int res;
+
+  printf("run_native_overflow %ld\n", (long) gettid());
+
+  res = (*_jvm)->AttachCurrentThread(_jvm, (void **)&env, NULL);
+  if (res != JNI_OK) {
+    fprintf(stderr, "Test ERROR. Can't attach to current thread\n");
+    exit(7);
+  }
+
+  class_id = (*env)->FindClass (env, "DoOverflow");
+  if (class_id == NULL) {
+    fprintf(stderr, "Test ERROR. Can't load class DoOverflow\n");
+    exit(7);
+  }
+
+  method_id = (*env)->GetStaticMethodID (env, class_id, "printAlive", "()V");
+  if (method_id == NULL) {
+    fprintf(stderr, "Test ERROR. Can't find method DoOverflow.printAlive\n");
+    exit(7);
+  }
+
+  (*env)->CallStaticVoidMethod (env, class_id, method_id, NULL);
+
+  set_signal_handler();
+  if (! setjmp(context)) {
+    do_overflow();
+  }
+
+  if (_last_si_code == SEGV_ACCERR) {
+    printf("Test PASSED. Got access violation accessing guard page at %d\n", _rec_count);
+  }
+
+  res = (*_jvm)->DetachCurrentThread(_jvm);
+  if (res != JNI_OK) {
+    fprintf(stderr, "Test ERROR. Can't call detach from current thread\n");
+    exit(7);
+  }
+
+  if (getpid() != gettid()) {
+    // For non-initial thread we don't unmap the region but call os::uncommit_memory and keep PROT_NONE
+    // so if host has enough swap space we will get the same SEGV with code SEGV_ACCERR(2) trying
+    // to access it as if the guard page is present.
+    // We have no way to check this, so bail out, marking test as succeeded
+    printf("Test PASSED. Not initial thread\n");
+    return NULL;
+  }
+
+  // Limit depth of recursion for second run. It can't exceed one for first run.
+  _kp_rec_count = _rec_count;
+  _rec_count = 0;
+
+  set_signal_handler();
+  if (! setjmp(context)) {
+    do_overflow();
+  }
+
+  if (_last_si_code == SEGV_ACCERR) {
+      ++ _failures;
+      fprintf(stderr,"Test FAILED. Stack guard page is still there at %d\n", _rec_count);
+  } else if (_last_si_code == -1) {
+      printf("Test PASSED. No stack guard page is present. Maximum recursion level reached at %d\n", _rec_count);
+  }
+  else{
+      printf("Test PASSED. No stack guard page is present. SIGSEGV(%d) at %d\n", _last_si_code, _rec_count);
+  }
+
+  return NULL;
+}
+
+void usage() {
+  fprintf(stderr, "Usage: invoke test_java_overflow\n");
+  fprintf(stderr, "       invoke test_native_overflow\n");
+  exit(7);
+}
+
+
+int main (int argc, const char** argv) {
+  JavaVMInitArgs vm_args;
+  JavaVMOption options[2];
+  JNIEnv* env;
+
+  printf("Test started with pid: %ld\n", (long) getpid());
+
+  options[0].optionString = "-Xint";
+  options[1].optionString = "-Xss320k";
+
+  vm_args.version = JNI_VERSION_1_2;
+  vm_args.ignoreUnrecognized = JNI_TRUE;
+  vm_args.options = options;
+  vm_args.nOptions = 2;
+
+  if (JNI_CreateJavaVM (&_jvm, (void **)&env, &vm_args) < 0 ) {
+    fprintf(stderr, "Test ERROR. Can't create JavaVM\n");
+    exit(7);
+  }
+
+  pthread_t thr;
+
+  if (argc > 1 && strcmp(argv[1], "test_java_overflow") == 0) {
+    printf("\nTesting JAVA_OVERFLOW\n");
+
+    printf("Testing stack guard page behaviour for other thread\n");
+    pthread_create (&thr, NULL, run_java_overflow, NULL);
+    pthread_join (thr, NULL);
+
+    printf("Testing stack guard page behaviour for initial thread\n");
+    run_java_overflow(NULL);
+    // This test crash on error
+    exit(0);
+  }
+
+  if (argc > 1 && strcmp(argv[1], "test_native_overflow") == 0) {
+    printf("\nTesting NATIVE_OVERFLOW\n");
+
+    printf("Testing stack guard page behaviour for other thread\n");
+    pthread_create (&thr, NULL, run_native_overflow, NULL);
+    pthread_join (thr, NULL);
+
+    printf("Testing stack guard page behaviour for initial thread\n");
+    run_native_overflow(NULL);
+
+    exit((_failures > 0) ? 1 : 0);
+  }
+
+  fprintf(stderr, "Test ERROR. Unknown parameter %s\n", ((argc > 1) ? argv[1] : "none"));
+  usage();
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/runtime/StackGuardPages/testme.sh	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,60 @@
+#!/bin/sh
+
+#
+# @test testme.sh
+# @summary Stack guard pages should be installed correctly and removed when thread is detached
+# @run shell testme.sh
+#
+
+if [ "${TESTSRC}" = "" ]
+then
+  TESTSRC=${PWD}
+  echo "TESTSRC not set.  Using "${TESTSRC}" as default"
+fi
+echo "TESTSRC=${TESTSRC}"
+## Adding common setup Variables for running shell tests.
+. ${TESTSRC}/../../test_env.sh
+
+if [ "${VM_OS}" != "linux" ]
+then
+  echo "Test only valid for Linux"
+  exit 0
+fi
+
+gcc_cmd=`which gcc`
+if [ "x$gcc_cmd" = "x" ]; then
+  echo "WARNING: gcc not found. Cannot execute test." 2>&1
+  exit 0;
+fi
+
+CFLAGS=-m${VM_BITS}
+
+LD_LIBRARY_PATH=.:${TESTJAVA}/jre/lib/${VM_CPU}/${VM_TYPE}:${TESTJAVA}/lib/${VM_CPU}/${VM_TYPE}:/usr/lib:$LD_LIBRARY_PATH
+export LD_LIBRARY_PATH
+
+echo "Architecture: ${VM_CPU}"
+echo "Compilation flag: ${CFLAGS}"
+echo "VM type: ${VM_TYPE}"
+echo "LD_LIBRARY_PATH: ${LD_LIBRARY_PATH}"
+
+# Note pthread may not be found thus invoke creation will fail to be created.
+# Check to ensure you have a /usr/lib/libpthread.so if you don't please look
+# for /usr/lib/`uname -m`-linux-gnu version ensure to add that path to below compilation.
+
+cp ${TESTSRC}/DoOverflow.java .
+${COMPILEJAVA}/bin/javac DoOverflow.java
+
+$gcc_cmd -DLINUX -g3 ${CFLAGS} -o invoke \
+    -I${TESTJAVA}/include -I${TESTJAVA}/include/linux \
+    -L${TESTJAVA}/jre/lib/${VM_CPU}/${VM_TYPE} \
+    -L${TESTJAVA}/lib/${VM_CPU}/${VM_TYPE} \
+     ${TESTSRC}/invoke.c -ljvm -lpthread
+
+if [ $? -ne 0 ] ; then
+    echo "Compile failed, Ignoring failed compilation and forcing the test to pass"
+    exit 0
+fi
+
+./invoke test_java_overflow
+./invoke test_native_overflow
+exit $?
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/runtime/whitebox/WBStackSize.java	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,121 @@
+/*
+ * Copyright (c) 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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.
+ */
+
+/*
+ * @test WBStackSize
+ * @summary verify that whitebox functions getThreadFullStackSize() and getThreadRemainingStackSize are working
+ * @library /testlibrary /testlibrary/whitebox
+ * @build WBStackSize
+ * @run main ClassFileInstaller sun.hotspot.WhiteBox
+ * @run main/othervm -Xbootclasspath/a:. -XX:+UnlockDiagnosticVMOptions -XX:+WhiteBoxAPI -Xss512k WBStackSize
+ */
+
+/*
+ * The test may product a false failure if too big StackYellowPages/StackRedPages/ShackShadowPages
+ * VM options are specified. The proper test would retrieve the page size from VM and account for these options
+ * instead of check below:
+ *     Math.abs(actualStackSize - configStackSize) > configStackSize * 0.1
+ *
+ * Please file a test bug, if this is a problem.
+ */
+
+import com.sun.management.HotSpotDiagnosticMXBean;
+import sun.hotspot.WhiteBox;
+
+public class WBStackSize {
+
+    static final long K = 1024;
+
+    static final long MIN_STACK_SIZE = 8 * K;
+    static final long MAX_STACK_SIZE_ALLOCATED_IN_MAIN = 200 * K; // current value is about 130k on 64-bit platforms
+
+    static final WhiteBox wb = WhiteBox.getWhiteBox();
+
+    static long stackSizeOnOverflow = -1;
+
+    static int eatAllStack() {
+        return eatAllStack() * 2;
+    }
+
+    static void testStackOverflow() {
+
+        stackSizeOnOverflow = wb.getThreadRemainingStackSize();
+
+        if (stackSizeOnOverflow > MIN_STACK_SIZE) {
+
+            try {
+                testStackOverflow();
+            } catch (StackOverflowError e) {
+                // We caught SOE too early. The error will be reported in main()
+            }
+
+        } else {
+
+            try {
+                eatAllStack();
+                throw new RuntimeException("Haven't caught StackOverflowError at all");
+            } catch (StackOverflowError e) {
+                // OK: we caught the anticipated error
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        HotSpotDiagnosticMXBean bean = sun.management.ManagementFactoryHelper.getDiagnosticMXBean();
+        long configStackSize = Long.valueOf(bean.getVMOption("ThreadStackSize").getValue()) * K;
+
+        System.out.println("ThreadStackSize VM option: " + configStackSize);
+
+        long actualStackSize = wb.getThreadStackSize();
+        System.out.println("Full stack size: " + actualStackSize);
+
+        if (Math.abs(actualStackSize - configStackSize) > configStackSize * 0.1) {
+            throw new RuntimeException("getThreadFullStackSize value [" + actualStackSize
+                                     + "] should be within 90%..110% of the value returned by HotSpotDiagnosticMXBean");
+        }
+
+        long remainingStackSize = wb.getThreadRemainingStackSize();
+        System.out.println("Remaining stack size in main(): " + remainingStackSize);
+
+        // Up to 200k can be already allocated by VM
+        if (remainingStackSize > configStackSize
+                || (configStackSize > MAX_STACK_SIZE_ALLOCATED_IN_MAIN
+                && remainingStackSize < configStackSize - MAX_STACK_SIZE_ALLOCATED_IN_MAIN)) {
+
+            throw new RuntimeException("getThreadRemainingStackSize value [" + remainingStackSize
+                                     + "] should be at least ThreadStackSize value [" + configStackSize + "] minus ["
+                                     + MAX_STACK_SIZE_ALLOCATED_IN_MAIN + "]");
+        }
+
+        testStackOverflow();
+
+        if (stackSizeOnOverflow > MIN_STACK_SIZE) {
+            throw new RuntimeException("Caught StackOverflowError too early: when there were "
+                                     + stackSizeOnOverflow + " bytes in stack");
+        } else if (stackSizeOnOverflow < 0) {
+            throw new RuntimeException("Internal test error: stackRemainingSize < 0");
+        } else {
+            System.out.println("Caught StackOverflowError as expected");
+        }
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/serviceability/jvmti/GetObjectSizeOverflow.java	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,64 @@
+/*
+ * Copyright (c) 2014 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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.
+ */
+import java.io.PrintWriter;
+import com.oracle.java.testlibrary.*;
+
+/*
+ * Test to verify GetObjectSize does not overflow on a 600M element int[]
+ *
+ * @test
+ * @bug 8027230
+ * @library /testlibrary
+ * @build GetObjectSizeOverflowAgent
+ * @run main ClassFileInstaller GetObjectSizeOverflowAgent
+ * @run main GetObjectSizeOverflow
+ */
+public class GetObjectSizeOverflow {
+    public static void main(String[] args) throws Exception  {
+
+        if (!Platform.is64bit()) {
+            System.out.println("Test needs a 4GB heap and can only be run as a 64bit process, skipping.");
+            return;
+        }
+
+        PrintWriter pw = new PrintWriter("MANIFEST.MF");
+        pw.println("Premain-Class: GetObjectSizeOverflowAgent");
+        pw.close();
+
+        ProcessBuilder pb = new ProcessBuilder();
+        pb.command(new String[] { JDKToolFinder.getJDKTool("jar"), "cmf", "MANIFEST.MF", "agent.jar", "GetObjectSizeOverflowAgent.class"});
+        pb.start().waitFor();
+
+        ProcessBuilder pt = ProcessTools.createJavaProcessBuilder(true, "-Xmx4000m", "-javaagent:agent.jar",  "GetObjectSizeOverflowAgent");
+        OutputAnalyzer output = new OutputAnalyzer(pt.start());
+
+        if (output.getStdout().contains("Could not reserve enough space") || output.getStderr().contains("java.lang.OutOfMemoryError")) {
+            System.out.println("stdout: " + output.getStdout());
+            System.out.println("stderr: " + output.getStderr());
+            System.out.println("Test could not reserve or allocate enough space, skipping");
+            return;
+        }
+
+        output.stdoutShouldContain("GetObjectSizeOverflow passed");
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/serviceability/jvmti/GetObjectSizeOverflowAgent.java	Thu Jun 05 19:39:08 2014 -0700
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2014, 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
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * 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.
+ */
+import java.lang.instrument.*;
+
+public class GetObjectSizeOverflowAgent {
+
+    static Instrumentation instrumentation;
+
+    public static void premain(String agentArgs, Instrumentation instrumentation) {
+        GetObjectSizeOverflowAgent.instrumentation = instrumentation;
+    }
+
+    public static void main(String[] args) throws Exception {
+        int[] a = new int[600_000_000];
+        long size = instrumentation.getObjectSize(a);
+
+        if (size < 2_400_000_000L) {
+            throw new RuntimeException("Invalid size of array, expected >= 2400000000, got " + size);
+        }
+
+        System.out.println("GetObjectSizeOverflow passed");
+    }
+}
--- a/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java	Wed Jun 04 20:20:09 2014 -0700
+++ b/test/testlibrary/whitebox/sun/hotspot/WhiteBox.java	Thu Jun 05 19:39:08 2014 -0700
@@ -150,6 +150,8 @@
   public native int stressVirtualSpaceResize(long reservedSpaceSize, long magnitude, long iterations);
   public native void runMemoryUnitTests();
   public native void readFromNoaccessArea();
+  public native long getThreadStackSize();
+  public native long getThreadRemainingStackSize();
 
   // CPU features
   public native String getCPUFeatures();