--- a/.hgtags	Thu Aug 13 15:50:52 2015 -0700
+++ b/.hgtags	Mon Aug 17 11:18:31 2015 -0700
@@ -319,3 +319,4 @@
 7c577fda1855d03c04546694d514678f596508c9 jdk9-b74
 f55df5cfe11c97e4b58998b76f5bd00a73cde12d jdk9-b75
 eeea9adfd1e3d075ef82148c00a4847a1aab4d26 jdk9-b76
+c25e882cee9622ec75c4e9d60633539a2f0a8809 jdk9-b77

--- a/.hgtags-top-repo	Thu Aug 13 15:50:52 2015 -0700
+++ b/.hgtags-top-repo	Mon Aug 17 11:18:31 2015 -0700
@@ -319,3 +319,4 @@
 57f3134853ecdd4a3ee2d4d26f22ba981d653d79 jdk9-b74
 8fd6eeb878606e39c908f12535f34ebbfd225a4a jdk9-b75
 d82072b699b880a1f647a5e2d7c0f86cec958941 jdk9-b76
+7972dc8f2a47f0c4cd8f02fa5662af41f028aa14 jdk9-b77

--- a/corba/.hgtags	Thu Aug 13 15:50:52 2015 -0700
+++ b/corba/.hgtags	Mon Aug 17 11:18:31 2015 -0700
@@ -319,3 +319,4 @@
 622fe934e351e89107edf3c667d6b57f543f58f1 jdk9-b74
 960b56805abd8460598897481820bd6a75f979e7 jdk9-b75
 d8126bc88fa5cd1ae4e44d86a4b1280ca1c9e2aa jdk9-b76
+8bb2441c0fec8b28f7bf11a0ca3ec1642e7ef457 jdk9-b77

--- a/hotspot/.hgtags	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/.hgtags	Mon Aug 17 11:18:31 2015 -0700
@@ -479,3 +479,4 @@
 fff6b54e9770ac4c12c2fb4cab5aa7672affa4bd jdk9-b74
 2f354281e9915275693c4e519a959b8a6f22d3a3 jdk9-b75
 0bc8d1656d6f2b1fdfe803c1305a108bb9939f35 jdk9-b76
+e66c3813789debfc06f206afde1bf7a84cb08451 jdk9-b77

--- a/hotspot/src/cpu/aarch64/vm/aarch64.ad	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/aarch64.ad	Mon Aug 17 11:18:31 2015 -0700
@@ -2389,9 +2389,11 @@
   // Note that the code buffer's insts_mark is always relative to insts.
   // That's why we must use the macroassembler to generate a handler.
   MacroAssembler _masm(&cbuf);
-  address base =
-  __ start_a_stub(size_exception_handler());
-  if (base == NULL)  return 0;  // CodeBuffer::expand failed
+  address base = __ start_a_stub(size_exception_handler());
+  if (base == NULL) {
+    ciEnv::current()->record_failure("CodeCache is full");
+    return 0;  // CodeBuffer::expand failed
+  }
   int offset = __ offset();
   __ far_jump(RuntimeAddress(OptoRuntime::exception_blob()->entry_point()));
   assert(__ offset() - offset <= (int) size_exception_handler(), "overflow");
@@ -2405,9 +2407,11 @@
   // Note that the code buffer's insts_mark is always relative to insts.
   // That's why we must use the macroassembler to generate a handler.
   MacroAssembler _masm(&cbuf);
-  address base =
-  __ start_a_stub(size_deopt_handler());
-  if (base == NULL)  return 0;  // CodeBuffer::expand failed
+  address base = __ start_a_stub(size_deopt_handler());
+  if (base == NULL) {
+    ciEnv::current()->record_failure("CodeCache is full");
+    return 0;  // CodeBuffer::expand failed
+  }
   int offset = __ offset();
 
   __ adr(lr, __ pc());
@@ -3657,24 +3661,37 @@
     MacroAssembler _masm(&cbuf);
 
     address addr = (address)$meth$$method;
+    address call;
     if (!_method) {
       // A call to a runtime wrapper, e.g. new, new_typeArray_Java, uncommon_trap.
-      __ trampoline_call(Address(addr, relocInfo::runtime_call_type), &cbuf);
+      call = __ trampoline_call(Address(addr, relocInfo::runtime_call_type), &cbuf);
     } else if (_optimized_virtual) {
-      __ trampoline_call(Address(addr, relocInfo::opt_virtual_call_type), &cbuf);
+      call = __ trampoline_call(Address(addr, relocInfo::opt_virtual_call_type), &cbuf);
     } else {
-      __ trampoline_call(Address(addr, relocInfo::static_call_type), &cbuf);
+      call = __ trampoline_call(Address(addr, relocInfo::static_call_type), &cbuf);
+    }
+    if (call == NULL) {
+      ciEnv::current()->record_failure("CodeCache is full"); 
+      return;
     }
 
     if (_method) {
       // Emit stub for static call
-      CompiledStaticCall::emit_to_interp_stub(cbuf);
+      address stub = CompiledStaticCall::emit_to_interp_stub(cbuf);
+      if (stub == NULL) {
+        ciEnv::current()->record_failure("CodeCache is full"); 
+        return;
+      }
     }
   %}
 
   enc_class aarch64_enc_java_dynamic_call(method meth) %{
     MacroAssembler _masm(&cbuf);
-    __ ic_call((address)$meth$$method);
+    address call = __ ic_call((address)$meth$$method);
+    if (call == NULL) {
+      ciEnv::current()->record_failure("CodeCache is full"); 
+      return;
+    }
   %}
 
   enc_class aarch64_enc_call_epilog() %{
@@ -3695,7 +3712,11 @@
     address entry = (address)$meth$$method;
     CodeBlob *cb = CodeCache::find_blob(entry);
     if (cb) {
-      __ trampoline_call(Address(entry, relocInfo::runtime_call_type));
+      address call = __ trampoline_call(Address(entry, relocInfo::runtime_call_type));
+      if (call == NULL) {
+        ciEnv::current()->record_failure("CodeCache is full"); 
+        return;
+      }
     } else {
       int gpcnt;
       int fpcnt;

--- a/hotspot/src/cpu/aarch64/vm/c1_CodeStubs_aarch64.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/c1_CodeStubs_aarch64.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -327,9 +327,16 @@
   ce->align_call(lir_static_call);
 
   ce->emit_static_call_stub();
+  if (ce->compilation()->bailed_out()) {
+    return; // CodeCache is full
+  }
   Address resolve(SharedRuntime::get_resolve_static_call_stub(),
                   relocInfo::static_call_type);
-  __ trampoline_call(resolve);
+  address call = __ trampoline_call(resolve);
+  if (call == NULL) {
+    ce->bailout("trampoline stub overflow");
+    return;
+  }
   ce->add_call_info_here(info());
 
 #ifndef PRODUCT

--- a/hotspot/src/cpu/aarch64/vm/c1_LIRAssembler_aarch64.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/c1_LIRAssembler_aarch64.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1996,13 +1996,21 @@
 
 
 void LIR_Assembler::call(LIR_OpJavaCall* op, relocInfo::relocType rtype) {
-  __ trampoline_call(Address(op->addr(), rtype));
+  address call = __ trampoline_call(Address(op->addr(), rtype));
+  if (call == NULL) {
+    bailout("trampoline stub overflow");
+    return;
+  }
   add_call_info(code_offset(), op->info());
 }
 
 
 void LIR_Assembler::ic_call(LIR_OpJavaCall* op) {
-  __ ic_call(op->addr());
+  address call = __ ic_call(op->addr());
+  if (call == NULL) {
+    bailout("trampoline stub overflow");
+    return;
+  }
   add_call_info(code_offset(), op->info());
 }
 

--- a/hotspot/src/cpu/aarch64/vm/c1_LIRAssembler_aarch64.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/c1_LIRAssembler_aarch64.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -26,6 +26,9 @@
 #ifndef CPU_X86_VM_C1_LIRASSEMBLER_X86_HPP
 #define CPU_X86_VM_C1_LIRASSEMBLER_X86_HPP
 
+// ArrayCopyStub needs access to bailout
+friend class ArrayCopyStub;
+
  private:
 
   int array_element_size(BasicType type) const;

--- a/hotspot/src/cpu/aarch64/vm/compiledIC_aarch64.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/compiledIC_aarch64.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -51,7 +51,7 @@
 // ----------------------------------------------------------------------------
 
 #define __ _masm.
-void CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
+address CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
   // Stub is fixed up when the corresponding call is converted from
   // calling compiled code to calling interpreted code.
   // mov rmethod, 0
@@ -63,10 +63,11 @@
   // That's why we must use the macroassembler to generate a stub.
   MacroAssembler _masm(&cbuf);
 
-  address base = __ start_a_stub(to_interp_stub_size()*2);
-
+  address base = __ start_a_stub(to_interp_stub_size());
   int offset = __ offset();
-  if (base == NULL)  return;  // CodeBuffer::expand failed
+  if (base == NULL) {
+    return NULL;  // CodeBuffer::expand failed
+  }
   // static stub relocation stores the instruction address of the call
   __ relocate(static_stub_Relocation::spec(mark));
   // static stub relocation also tags the Method* in the code-stream.
@@ -76,6 +77,7 @@
 
   assert((__ offset() - offset) <= (int)to_interp_stub_size(), "stub too big");
   __ end_a_stub();
+  return base;
 }
 #undef __
 

--- a/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -664,7 +664,7 @@
 // Maybe emit a call via a trampoline.  If the code cache is small
 // trampolines won't be emitted.
 
-void MacroAssembler::trampoline_call(Address entry, CodeBuffer *cbuf) {
+address MacroAssembler::trampoline_call(Address entry, CodeBuffer *cbuf) {
   assert(entry.rspec().type() == relocInfo::runtime_call_type
          || entry.rspec().type() == relocInfo::opt_virtual_call_type
          || entry.rspec().type() == relocInfo::static_call_type
@@ -672,7 +672,10 @@
 
   unsigned int start_offset = offset();
   if (far_branches() && !Compile::current()->in_scratch_emit_size()) {
-    emit_trampoline_stub(offset(), entry.target());
+    address stub = emit_trampoline_stub(start_offset, entry.target());
+    if (stub == NULL) {
+      return NULL; // CodeCache is full
+    }
   }
 
   if (cbuf) cbuf->set_insts_mark();
@@ -682,6 +685,8 @@
   } else {
     bl(pc());
   }
+  // just need to return a non-null address
+  return pc();
 }
 
 
@@ -696,13 +701,11 @@
 //   load the call target from the constant pool
 //   branch (LR still points to the call site above)
 
-void MacroAssembler::emit_trampoline_stub(int insts_call_instruction_offset,
+address MacroAssembler::emit_trampoline_stub(int insts_call_instruction_offset,
                                              address dest) {
   address stub = start_a_stub(Compile::MAX_stubs_size/2);
   if (stub == NULL) {
-    start_a_stub(Compile::MAX_stubs_size/2);
-    Compile::current()->env()->record_out_of_memory_failure();
-    return;
+    return NULL;  // CodeBuffer::expand failed
   }
 
   // Create a trampoline stub relocation which relates this trampoline stub
@@ -729,15 +732,16 @@
   assert(is_NativeCallTrampolineStub_at(stub_start_addr), "doesn't look like a trampoline");
 
   end_a_stub();
+  return stub;
 }
 
-void MacroAssembler::ic_call(address entry) {
+address MacroAssembler::ic_call(address entry) {
   RelocationHolder rh = virtual_call_Relocation::spec(pc());
   // address const_ptr = long_constant((jlong)Universe::non_oop_word());
   // unsigned long offset;
   // ldr_constant(rscratch2, const_ptr);
   movptr(rscratch2, (uintptr_t)Universe::non_oop_word());
-  trampoline_call(Address(entry, rh));
+  return trampoline_call(Address(entry, rh));
 }
 
 // Implementation of call_VM versions

--- a/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/aarch64/vm/macroAssembler_aarch64.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -539,7 +539,7 @@
 
   static int patch_oop(address insn_addr, address o);
 
-  void emit_trampoline_stub(int insts_call_instruction_offset, address target);
+  address emit_trampoline_stub(int insts_call_instruction_offset, address target);
 
   // The following 4 methods return the offset of the appropriate move instruction
 
@@ -942,7 +942,7 @@
 
   // Calls
 
-  void trampoline_call(Address entry, CodeBuffer *cbuf = NULL);
+  address trampoline_call(Address entry, CodeBuffer *cbuf = NULL);
 
   static bool far_branches() {
     return ReservedCodeCacheSize > branch_range;
@@ -962,7 +962,7 @@
   }
 
   // Emit the CompiledIC call idiom
-  void ic_call(address entry);
+  address ic_call(address entry);
 
 public:
 

--- a/hotspot/src/cpu/ppc/vm/compiledIC_ppc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/ppc/vm/compiledIC_ppc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -94,7 +94,7 @@
 
 const int IC_pos_in_java_to_interp_stub = 8;
 #define __ _masm.
-void CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
+address CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
 #ifdef COMPILER2
   // Get the mark within main instrs section which is set to the address of the call.
   address call_addr = cbuf.insts_mark();
@@ -106,8 +106,7 @@
   // Start the stub.
   address stub = __ start_a_stub(CompiledStaticCall::to_interp_stub_size());
   if (stub == NULL) {
-    Compile::current()->env()->record_out_of_memory_failure();
-    return;
+    return NULL; // CodeCache is full
   }
 
   // For java_to_interp stubs we use R11_scratch1 as scratch register
@@ -149,6 +148,7 @@
 
  // End the stub.
   __ end_a_stub();
+  return stub;
 #else
   ShouldNotReachHere();
 #endif

--- a/hotspot/src/cpu/ppc/vm/interp_masm_ppc_64.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/ppc/vm/interp_masm_ppc_64.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -2187,7 +2187,7 @@
 }
 
 void InterpreterMacroAssembler::increment_invocation_counter(Register Rcounters, Register iv_be_count, Register Rtmp_r0) {
-  assert(UseCompiler, "incrementing must be useful");
+  assert(UseCompiler || LogTouchedMethods, "incrementing must be useful");
   Register invocation_count = iv_be_count;
   Register backedge_count   = Rtmp_r0;
   int delta = InvocationCounter::count_increment;

--- a/hotspot/src/cpu/ppc/vm/ppc.ad	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/ppc/vm/ppc.ad	Mon Aug 17 11:18:31 2015 -0700
@@ -1082,7 +1082,7 @@
   // Start the stub.
   address stub = __ start_a_stub(Compile::MAX_stubs_size/2);
   if (stub == NULL) {
-    Compile::current()->env()->record_out_of_memory_failure();
+    ciEnv::current()->record_failure("CodeCache is full");
     return;
   }
 
@@ -1160,7 +1160,7 @@
 
     // Emit the trampoline stub which will be related to the branch-and-link below.
     CallStubImpl::emit_trampoline_stub(_masm, entry_point_toc_offset, offsets.insts_call_instruction_offset);
-    if (Compile::current()->env()->failing()) { return offsets; } // Code cache may be full.
+    if (ciEnv::current()->failing()) { return offsets; } // Code cache may be full.
     __ relocate(rtype);
   }
 
@@ -3397,7 +3397,7 @@
 
         // Emit the trampoline stub which will be related to the branch-and-link below.
         CallStubImpl::emit_trampoline_stub(_masm, entry_point_toc_offset, start_offset);
-        if (Compile::current()->env()->failing()) { return; } // Code cache may be full.
+        if (ciEnv::current()->failing()) { return; } // Code cache may be full.
         __ relocate(_optimized_virtual ?
                     relocInfo::opt_virtual_call_type : relocInfo::static_call_type);
       }
@@ -3410,7 +3410,11 @@
       __ bl(__ pc());  // Emits a relocation.
 
       // The stub for call to interpreter.
-      CompiledStaticCall::emit_to_interp_stub(cbuf);
+      address stub = CompiledStaticCall::emit_to_interp_stub(cbuf);
+      if (stub == NULL) {
+        ciEnv::current()->record_failure("CodeCache is full"); 
+        return;
+      }
     }
   %}
 
@@ -3455,7 +3459,11 @@
 
     assert(_method, "execute next statement conditionally");
     // The stub for call to interpreter.
-    CompiledStaticCall::emit_to_interp_stub(cbuf);
+    address stub = CompiledStaticCall::emit_to_interp_stub(cbuf);
+    if (stub == NULL) {
+      ciEnv::current()->record_failure("CodeCache is full"); 
+      return;
+    }
 
     // Restore original sp.
     __ ld(R11_scratch1, 0, R1_SP); // Load caller sp.

--- a/hotspot/src/cpu/sparc/vm/c1_CodeStubs_sparc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/sparc/vm/c1_CodeStubs_sparc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -432,6 +432,9 @@
   __ mov(length()->as_register(),  O4);
 
   ce->emit_static_call_stub();
+  if (ce->compilation()->bailed_out()) {
+    return; // CodeCache is full
+  }
 
   __ call(SharedRuntime::get_resolve_static_call_stub(), relocInfo::static_call_type);
   __ delayed()->nop();

--- a/hotspot/src/cpu/sparc/vm/compiledIC_sparc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/sparc/vm/compiledIC_sparc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -53,7 +53,7 @@
 // ----------------------------------------------------------------------------
 
 #define __ _masm.
-void CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
+address CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
 #ifdef COMPILER2
   // Stub is fixed up when the corresponding call is converted from calling
   // compiled code to calling interpreted code.
@@ -64,9 +64,10 @@
 
   MacroAssembler _masm(&cbuf);
 
-  address base =
-  __ start_a_stub(to_interp_stub_size()*2);
-  if (base == NULL) return;  // CodeBuffer::expand failed.
+  address base = __ start_a_stub(to_interp_stub_size());
+  if (base == NULL) {
+    return NULL;  // CodeBuffer::expand failed.
+  }
 
   // Static stub relocation stores the instruction address of the call.
   __ relocate(static_stub_Relocation::spec(mark));
@@ -81,6 +82,7 @@
 
   // Update current stubs pointer and restore code_end.
   __ end_a_stub();
+  return base;
 #else
   ShouldNotReachHere();
 #endif

--- a/hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/sparc/vm/interp_masm_sparc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -2314,7 +2314,7 @@
 }
 
 void InterpreterMacroAssembler::increment_invocation_counter( Register Rcounters, Register Rtmp, Register Rtmp2 ) {
-  assert(UseCompiler, "incrementing must be useful");
+  assert(UseCompiler || LogTouchedMethods, "incrementing must be useful");
   assert_different_registers(Rcounters, Rtmp, Rtmp2);
 
   Address inv_counter(Rcounters, MethodCounters::invocation_counter_offset() +

--- a/hotspot/src/cpu/sparc/vm/sparc.ad	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/sparc/vm/sparc.ad	Mon Aug 17 11:18:31 2015 -0700
@@ -1773,9 +1773,11 @@
   AddressLiteral exception_blob(OptoRuntime::exception_blob()->entry_point());
   MacroAssembler _masm(&cbuf);
 
-  address base =
-  __ start_a_stub(size_exception_handler());
-  if (base == NULL)  return 0;  // CodeBuffer::expand failed
+  address base = __ start_a_stub(size_exception_handler());
+  if (base == NULL) {
+    ciEnv::current()->record_failure("CodeCache is full");
+    return 0;  // CodeBuffer::expand failed
+  }
 
   int offset = __ offset();
 
@@ -1796,9 +1798,11 @@
   AddressLiteral deopt_blob(SharedRuntime::deopt_blob()->unpack());
   MacroAssembler _masm(&cbuf);
 
-  address base =
-  __ start_a_stub(size_deopt_handler());
-  if (base == NULL)  return 0;  // CodeBuffer::expand failed
+  address base = __ start_a_stub(size_deopt_handler());
+  if (base == NULL) {
+    ciEnv::current()->record_failure("CodeCache is full");
+    return 0;  // CodeBuffer::expand failed
+  }
 
   int offset = __ offset();
   __ save_frame(0);
@@ -2599,7 +2603,12 @@
       emit_call_reloc(cbuf, $meth$$method, relocInfo::static_call_type);
     }
     if (_method) {  // Emit stub for static call.
-      CompiledStaticCall::emit_to_interp_stub(cbuf);
+      address stub = CompiledStaticCall::emit_to_interp_stub(cbuf);
+      // Stub does not fit into scratch buffer if TraceJumps is enabled
+      if (stub == NULL && !(TraceJumps && Compile::current()->in_scratch_emit_size())) {
+        ciEnv::current()->record_failure("CodeCache is full");
+        return;
+      } 
     }
   %}
 

--- a/hotspot/src/cpu/x86/vm/c1_CodeStubs_x86.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/x86/vm/c1_CodeStubs_x86.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -503,6 +503,9 @@
   ce->align_call(lir_static_call);
 
   ce->emit_static_call_stub();
+  if (ce->compilation()->bailed_out()) {
+    return; // CodeCache is full
+  }
   AddressLiteral resolve(SharedRuntime::get_resolve_static_call_stub(),
                          relocInfo::static_call_type);
   __ call(resolve);

--- a/hotspot/src/cpu/x86/vm/compiledIC_x86.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/x86/vm/compiledIC_x86.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -50,7 +50,7 @@
 // ----------------------------------------------------------------------------
 
 #define __ _masm.
-void CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
+address CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
   // Stub is fixed up when the corresponding call is converted from
   // calling compiled code to calling interpreted code.
   // movq rbx, 0
@@ -62,9 +62,10 @@
   // That's why we must use the macroassembler to generate a stub.
   MacroAssembler _masm(&cbuf);
 
-  address base =
-  __ start_a_stub(to_interp_stub_size()*2);
-  if (base == NULL) return;  // CodeBuffer::expand failed.
+  address base = __ start_a_stub(to_interp_stub_size());
+  if (base == NULL) {
+    return NULL;  // CodeBuffer::expand failed.
+  }
   // Static stub relocation stores the instruction address of the call.
   __ relocate(static_stub_Relocation::spec(mark), Assembler::imm_operand);
   // Static stub relocation also tags the Method* in the code-stream.
@@ -74,6 +75,7 @@
 
   // Update current stubs pointer and restore insts_end.
   __ end_a_stub();
+  return base;
 }
 #undef __
 

--- a/hotspot/src/cpu/x86/vm/x86.ad	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/x86/vm/x86.ad	Mon Aug 17 11:18:31 2015 -0700
@@ -1594,7 +1594,10 @@
   // That's why we must use the macroassembler to generate a handler.
   MacroAssembler _masm(&cbuf);
   address base = __ start_a_stub(size_exception_handler());
-  if (base == NULL)  return 0;  // CodeBuffer::expand failed
+  if (base == NULL) {
+    ciEnv::current()->record_failure("CodeCache is full");
+    return 0;  // CodeBuffer::expand failed
+  }
   int offset = __ offset();
   __ jump(RuntimeAddress(OptoRuntime::exception_blob()->entry_point()));
   assert(__ offset() - offset <= (int) size_exception_handler(), "overflow");
@@ -1609,7 +1612,10 @@
   // That's why we must use the macroassembler to generate a handler.
   MacroAssembler _masm(&cbuf);
   address base = __ start_a_stub(size_deopt_handler());
-  if (base == NULL)  return 0;  // CodeBuffer::expand failed
+  if (base == NULL) {
+    ciEnv::current()->record_failure("CodeCache is full");
+    return 0;  // CodeBuffer::expand failed
+  }
   int offset = __ offset();
 
 #ifdef _LP64

--- a/hotspot/src/cpu/x86/vm/x86_32.ad	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/x86/vm/x86_32.ad	Mon Aug 17 11:18:31 2015 -0700
@@ -1907,7 +1907,11 @@
                      static_call_Relocation::spec(), RELOC_IMM32 );
     }
     if (_method) {  // Emit stub for static call.
-      CompiledStaticCall::emit_to_interp_stub(cbuf);
+      address stub = CompiledStaticCall::emit_to_interp_stub(cbuf);
+      if (stub == NULL) {
+        ciEnv::current()->record_failure("CodeCache is full");
+        return;
+      } 
     }
   %}
 

--- a/hotspot/src/cpu/x86/vm/x86_64.ad	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/x86/vm/x86_64.ad	Mon Aug 17 11:18:31 2015 -0700
@@ -2137,7 +2137,11 @@
     }
     if (_method) {
       // Emit stub for static call.
-      CompiledStaticCall::emit_to_interp_stub(cbuf);
+      address stub = CompiledStaticCall::emit_to_interp_stub(cbuf);
+      if (stub == NULL) {
+        ciEnv::current()->record_failure("CodeCache is full");
+        return;
+      } 
     }
   %}
 

--- a/hotspot/src/cpu/zero/vm/compiledIC_zero.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/cpu/zero/vm/compiledIC_zero.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -60,8 +60,9 @@
 
 // ----------------------------------------------------------------------------
 
-void CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
+address CompiledStaticCall::emit_to_interp_stub(CodeBuffer &cbuf) {
   ShouldNotReachHere(); // Only needed for COMPILER2.
+  return NULL;
 }
 
 int CompiledStaticCall::to_interp_stub_size() {

--- a/hotspot/src/os/aix/vm/os_aix.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os/aix/vm/os_aix.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -971,34 +971,32 @@
   guarantee(pthread_attr_setsuspendstate_np(&attr, PTHREAD_CREATE_SUSPENDED_NP) == 0, "???");
 
   // calculate stack size if it's not specified by caller
-  if (os::Aix::supports_variable_stack_size()) {
-    if (stack_size == 0) {
-      stack_size = os::Aix::default_stack_size(thr_type);
-
-      switch (thr_type) {
-      case os::java_thread:
-        // Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.
-        assert(JavaThread::stack_size_at_create() > 0, "this should be set");
-        stack_size = JavaThread::stack_size_at_create();
+  if (stack_size == 0) {
+    stack_size = os::Aix::default_stack_size(thr_type);
+
+    switch (thr_type) {
+    case os::java_thread:
+      // Java threads use ThreadStackSize whose default value can be changed with the flag -Xss.
+      assert(JavaThread::stack_size_at_create() > 0, "this should be set");
+      stack_size = JavaThread::stack_size_at_create();
+      break;
+    case os::compiler_thread:
+      if (CompilerThreadStackSize > 0) {
+        stack_size = (size_t)(CompilerThreadStackSize * K);
         break;
-      case os::compiler_thread:
-        if (CompilerThreadStackSize > 0) {
-          stack_size = (size_t)(CompilerThreadStackSize * K);
-          break;
-        } // else fall through:
-          // use VMThreadStackSize if CompilerThreadStackSize is not defined
-      case os::vm_thread:
-      case os::pgc_thread:
-      case os::cgc_thread:
-      case os::watcher_thread:
-        if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
-        break;
-      }
+      } // else fall through:
+        // use VMThreadStackSize if CompilerThreadStackSize is not defined
+    case os::vm_thread:
+    case os::pgc_thread:
+    case os::cgc_thread:
+    case os::watcher_thread:
+      if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
+      break;
     }
-
-    stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);
-    pthread_attr_setstacksize(&attr, stack_size);
-  } //else let thread_create() pick the default value (96 K on AIX)
+  }
+
+  stack_size = MAX2(stack_size, os::Aix::min_stack_allowed);
+  pthread_attr_setstacksize(&attr, stack_size);
 
   pthread_t tid;
   int ret = pthread_create(&tid, &attr, (void* (*)(void*)) java_start, thread);

--- a/hotspot/src/os/aix/vm/os_aix.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os/aix/vm/os_aix.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -131,8 +131,6 @@
   static void initialize_libo4();
   static void initialize_libperfstat();
 
-  static bool supports_variable_stack_size();
-
  public:
   static void init_thread_fpu_state();
   static pthread_t main_thread(void)                                { return _main_thread; }

--- a/hotspot/src/os/bsd/vm/os_bsd.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -739,40 +739,35 @@
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
-  // stack size
-  if (os::Bsd::supports_variable_stack_size()) {
-    // calculate stack size if it's not specified by caller
-    if (stack_size == 0) {
-      stack_size = os::Bsd::default_stack_size(thr_type);
-
-      switch (thr_type) {
-      case os::java_thread:
-        // Java threads use ThreadStackSize which default value can be
-        // changed with the flag -Xss
-        assert(JavaThread::stack_size_at_create() > 0, "this should be set");
-        stack_size = JavaThread::stack_size_at_create();
+  // calculate stack size if it's not specified by caller
+  if (stack_size == 0) {
+    stack_size = os::Bsd::default_stack_size(thr_type);
+
+    switch (thr_type) {
+    case os::java_thread:
+      // Java threads use ThreadStackSize which default value can be
+      // changed with the flag -Xss
+      assert(JavaThread::stack_size_at_create() > 0, "this should be set");
+      stack_size = JavaThread::stack_size_at_create();
+      break;
+    case os::compiler_thread:
+      if (CompilerThreadStackSize > 0) {
+        stack_size = (size_t)(CompilerThreadStackSize * K);
         break;
-      case os::compiler_thread:
-        if (CompilerThreadStackSize > 0) {
-          stack_size = (size_t)(CompilerThreadStackSize * K);
-          break;
-        } // else fall through:
-          // use VMThreadStackSize if CompilerThreadStackSize is not defined
-      case os::vm_thread:
-      case os::pgc_thread:
-      case os::cgc_thread:
-      case os::watcher_thread:
-        if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
-        break;
-      }
+      } // else fall through:
+        // use VMThreadStackSize if CompilerThreadStackSize is not defined
+    case os::vm_thread:
+    case os::pgc_thread:
+    case os::cgc_thread:
+    case os::watcher_thread:
+      if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
+      break;
     }
-
-    stack_size = MAX2(stack_size, os::Bsd::min_stack_allowed);
-    pthread_attr_setstacksize(&attr, stack_size);
-  } else {
-    // let pthread_create() pick the default value.
   }
 
+  stack_size = MAX2(stack_size, os::Bsd::min_stack_allowed);
+  pthread_attr_setstacksize(&attr, stack_size);
+
   ThreadState state;
 
   {

--- a/hotspot/src/os/bsd/vm/os_bsd.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os/bsd/vm/os_bsd.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2015, 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
@@ -75,8 +75,6 @@
   static julong physical_memory() { return _physical_memory; }
   static void initialize_system_info();
 
-  static bool supports_variable_stack_size();
-
   static void rebuild_cpu_to_node_map();
   static GrowableArray<int>* cpu_to_node()    { return _cpu_to_node; }
 

--- a/hotspot/src/os/linux/vm/os_linux.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os/linux/vm/os_linux.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -653,8 +653,7 @@
   OSThread* osthread = thread->osthread();
   Monitor* sync = osthread->startThread_lock();
 
-  // thread_id is kernel thread id (similar to Solaris LWP id)
-  osthread->set_thread_id(os::Linux::gettid());
+  osthread->set_thread_id(os::current_thread_id());
 
   if (UseNUMA) {
     int lgrp_id = os::numa_get_group_id();
@@ -712,38 +711,34 @@
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
 
   // stack size
-  if (os::Linux::supports_variable_stack_size()) {
-    // calculate stack size if it's not specified by caller
-    if (stack_size == 0) {
-      stack_size = os::Linux::default_stack_size(thr_type);
-
-      switch (thr_type) {
-      case os::java_thread:
-        // Java threads use ThreadStackSize which default value can be
-        // changed with the flag -Xss
-        assert(JavaThread::stack_size_at_create() > 0, "this should be set");
-        stack_size = JavaThread::stack_size_at_create();
+  // calculate stack size if it's not specified by caller
+  if (stack_size == 0) {
+    stack_size = os::Linux::default_stack_size(thr_type);
+
+    switch (thr_type) {
+    case os::java_thread:
+      // Java threads use ThreadStackSize which default value can be
+      // changed with the flag -Xss
+      assert(JavaThread::stack_size_at_create() > 0, "this should be set");
+      stack_size = JavaThread::stack_size_at_create();
+      break;
+    case os::compiler_thread:
+      if (CompilerThreadStackSize > 0) {
+        stack_size = (size_t)(CompilerThreadStackSize * K);
         break;
-      case os::compiler_thread:
-        if (CompilerThreadStackSize > 0) {
-          stack_size = (size_t)(CompilerThreadStackSize * K);
-          break;
-        } // else fall through:
-          // use VMThreadStackSize if CompilerThreadStackSize is not defined
-      case os::vm_thread:
-      case os::pgc_thread:
-      case os::cgc_thread:
-      case os::watcher_thread:
-        if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
-        break;
-      }
+      } // else fall through:
+        // use VMThreadStackSize if CompilerThreadStackSize is not defined
+    case os::vm_thread:
+    case os::pgc_thread:
+    case os::cgc_thread:
+    case os::watcher_thread:
+      if (VMThreadStackSize > 0) stack_size = (size_t)(VMThreadStackSize * K);
+      break;
     }
-
-    stack_size = MAX2(stack_size, os::Linux::min_stack_allowed);
-    pthread_attr_setstacksize(&attr, stack_size);
-  } else {
-    // let pthread_create() pick the default value.
-  }
+  }
+
+  stack_size = MAX2(stack_size, os::Linux::min_stack_allowed);
+  pthread_attr_setstacksize(&attr, stack_size);
 
   // glibc guard page
   pthread_attr_setguardsize(&attr, os::Linux::default_guard_size(thr_type));
@@ -1424,7 +1419,8 @@
   return n;
 }
 
-intx os::current_thread_id() { return (intx)pthread_self(); }
+// thread_id is kernel thread id (similar to Solaris LWP id)
+intx os::current_thread_id() { return os::Linux::gettid(); }
 int os::current_process_id() {
   return ::getpid();
 }

--- a/hotspot/src/os/linux/vm/os_linux.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os/linux/vm/os_linux.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -83,8 +83,6 @@
   static void set_glibc_version(const char *s)      { _glibc_version = s; }
   static void set_libpthread_version(const char *s) { _libpthread_version = s; }
 
-  static bool supports_variable_stack_size();
-
   static void rebuild_cpu_to_node_map();
   static GrowableArray<int>* cpu_to_node()    { return _cpu_to_node; }
 

--- a/hotspot/src/os_cpu/aix_ppc/vm/os_aix_ppc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/aix_ppc/vm/os_aix_ppc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1997, 2015, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2012, 2014 SAP AG. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -489,10 +489,6 @@
 
 size_t os::Aix::min_stack_allowed = 128*K;
 
-// Aix is always in floating stack mode. The stack size for a new
-// thread can be set via pthread_attr_setstacksize().
-bool os::Aix::supports_variable_stack_size() { return true; }
-
 // return default stack size for thr_type
 size_t os::Aix::default_stack_size(os::ThreadType thr_type) {
   // default stack size (compiler thread needs larger stack)

--- a/hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/bsd_x86/vm/os_bsd_x86.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2014, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2015, 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
@@ -780,9 +780,6 @@
 
 #ifdef AMD64
 size_t os::Bsd::min_stack_allowed  = 64 * K;
-
-// amd64: pthread on amd64 is always in floating stack mode
-bool os::Bsd::supports_variable_stack_size() {  return true; }
 #else
 size_t os::Bsd::min_stack_allowed  =  (48 DEBUG_ONLY(+4))*K;
 
@@ -790,7 +787,6 @@
 #define GET_GS() ({int gs; __asm__ volatile("movw %%gs, %w0":"=q"(gs)); gs&0xffff;})
 #endif
 
-bool os::Bsd::supports_variable_stack_size() { return true; }
 #endif // AMD64
 
 // return default stack size for thr_type

--- a/hotspot/src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/bsd_zero/vm/os_bsd_zero.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2007, 2008, 2009, 2010 Red Hat, Inc.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -290,10 +290,6 @@
 
 size_t os::Bsd::min_stack_allowed = 64 * K;
 
-bool os::Bsd::supports_variable_stack_size() {
-  return true;
-}
-
 size_t os::Bsd::default_stack_size(os::ThreadType thr_type) {
 #ifdef _LP64
   size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);

--- a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2011, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2015, Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2014, Red Hat Inc. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -496,9 +496,6 @@
 
 size_t os::Linux::min_stack_allowed  = 64 * K;
 
-// aarch64: pthread on aarch64 is always in floating stack mode
-bool os::Linux::supports_variable_stack_size() {  return true; }
-
 // return default stack size for thr_type
 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
   // default stack size (compiler thread needs larger stack)

--- a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -467,8 +467,6 @@
 
 size_t os::Linux::min_stack_allowed = 128*K;
 
-bool os::Linux::supports_variable_stack_size() { return true; }
-
 // return default stack size for thr_type
 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
   // default stack size (compiler thread needs larger stack)

--- a/hotspot/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/linux_sparc/vm/os_linux_sparc.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 1999, 2015, 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
@@ -733,9 +733,6 @@
 
 size_t os::Linux::min_stack_allowed  = 128 * K;
 
-// pthread on Ubuntu is always in floating stack mode
-bool os::Linux::supports_variable_stack_size() {  return true; }
-
 // return default stack size for thr_type
 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
   // default stack size (compiler thread needs larger stack)

--- a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -623,11 +623,6 @@
 size_t os::Linux::min_stack_allowed  =  (48 DEBUG_ONLY(+4))*K;
 #endif // AMD64
 
-// Test if pthread library can support variable thread stack size.
-bool os::Linux::supports_variable_stack_size() {
-  return true;
-}
-
 // return default stack size for thr_type
 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
   // default stack size (compiler thread needs larger stack)

--- a/hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/os_cpu/linux_zero/vm/os_linux_zero.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
+ * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved.
  * Copyright 2007, 2008, 2009, 2010 Red Hat, Inc.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
@@ -305,10 +305,6 @@
 
 size_t os::Linux::min_stack_allowed = 64 * K;
 
-bool os::Linux::supports_variable_stack_size() {
-  return true;
-}
-
 size_t os::Linux::default_stack_size(os::ThreadType thr_type) {
 #ifdef _LP64
   size_t s = (thr_type == os::compiler_thread ? 4 * M : 1 * M);

--- a/hotspot/src/share/vm/c1/c1_Compiler.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/c1/c1_Compiler.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -239,25 +239,6 @@
   return true;
 }
 
-bool Compiler::is_intrinsic_disabled_by_flag(methodHandle method) {
-  vmIntrinsics::ID id = method->intrinsic_id();
-  assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
-
-  if (vmIntrinsics::is_disabled_by_flags(id)) {
-    return true;
-  }
-
-  if (!InlineNatives && id != vmIntrinsics::_Reference_get) {
-    return true;
-  }
-
-  if (!InlineClassNatives && id == vmIntrinsics::_getClass) {
-    return true;
-  }
-
-  return false;
-}
-
 void Compiler::compile_method(ciEnv* env, ciMethod* method, int entry_bci) {
   BufferBlob* buffer_blob = CompilerThread::current()->get_buffer_blob();
   assert(buffer_blob != NULL, "Must exist");
@@ -275,7 +256,3 @@
 void Compiler::print_timers() {
   Compilation::print_timers();
 }
-
-bool Compiler::is_intrinsic_available(methodHandle method, methodHandle compilation_context) {
-  return is_intrinsic_supported(method) && !is_intrinsic_disabled_by_flag(method);
-}

--- a/hotspot/src/share/vm/c1/c1_Compiler.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/c1/c1_Compiler.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -55,18 +55,9 @@
   // Print compilation timers and statistics
   virtual void print_timers();
 
-  // Check the availability of an intrinsic for 'method' given a compilation context.
-  // The compilation context is needed to support per-method usage of the
-  // DisableIntrinsic flag. However, as C1 ignores the DisableIntrinsic flag, it
-  // ignores the compilation context.
-  virtual bool is_intrinsic_available(methodHandle method, methodHandle compilation_context);
-
   // Check if the C1 compiler supports an intrinsic for 'method'.
   virtual bool is_intrinsic_supported(methodHandle method);
 
-  // Processing of command-line flags specific to the C1 compiler.
-  virtual bool is_intrinsic_disabled_by_flag(methodHandle method);
-
   // Size of the code buffer
   static int code_buffer_size();
 };

--- a/hotspot/src/share/vm/c1/c1_GraphBuilder.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/c1/c1_GraphBuilder.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -3491,8 +3491,16 @@
 bool GraphBuilder::try_inline_intrinsics(ciMethod* callee) {
   // For calling is_intrinsic_available we need to transition to
   // the '_thread_in_vm' state because is_intrinsic_available()
-  // does not accesses critical VM-internal data.
-  if (!_compilation->compiler()->is_intrinsic_available(callee->get_Method(), NULL)) {
+  // accesses critical VM-internal data.
+  bool is_available = false;
+  {
+    VM_ENTRY_MARK;
+    methodHandle mh(THREAD, callee->get_Method());
+    methodHandle ct(THREAD, method()->get_Method());
+    is_available = _compilation->compiler()->is_intrinsic_available(mh, ct);
+  }
+
+  if (!is_available) {
     if (!InlineNatives) {
       // Return false and also set message that the inlining of
       // intrinsics has been disabled in general.

--- a/hotspot/src/share/vm/c1/c1_LIRAssembler.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/c1/c1_LIRAssembler.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -443,6 +443,7 @@
 
   // emit the static call stub stuff out of line
   emit_static_call_stub();
+  CHECK_BAILOUT();
 
   switch (op->code()) {
   case lir_static_call:

--- a/hotspot/src/share/vm/classfile/imageDecompressor.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/classfile/imageDecompressor.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -22,8 +22,8 @@
  *
  */
 
+#include "precompiled.hpp"
 #include "runtime/thread.inline.hpp"
-#include "precompiled.hpp"
 #include "classfile/imageDecompressor.hpp"
 #include "runtime/thread.hpp"
 #include "utilities/bytes.hpp"

--- a/hotspot/src/share/vm/classfile/imageDecompressor.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/classfile/imageDecompressor.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -26,7 +26,6 @@
 #define SHARE_VM_CLASSFILE_IMAGEDECOMPRESSOR_HPP
 
 #include "runtime/thread.inline.hpp"
-#include "precompiled.hpp"
 #include "classfile/classLoader.hpp"
 #include "classfile/imageFile.hpp"
 #include "classfile/symbolTable.hpp"

--- a/hotspot/src/share/vm/classfile/vmSymbols.cpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/classfile/vmSymbols.cpp	Mon Aug 17 11:18:31 2015 -0700
@@ -417,8 +417,59 @@
   }
 }
 
-bool vmIntrinsics::is_disabled_by_flags(vmIntrinsics::ID id) {
+bool vmIntrinsics::is_disabled_by_flags(methodHandle method, methodHandle compilation_context) {
+  vmIntrinsics::ID id = method->intrinsic_id();
   assert(id != vmIntrinsics::_none, "must be a VM intrinsic");
+
+  // Check if the intrinsic corresponding to 'method' has been disabled on
+  // the command line by using the DisableIntrinsic flag (either globally
+  // or on a per-method level, see src/share/vm/compiler/abstractCompiler.hpp
+  // for details).
+  // Usually, the compilation context is the caller of the method 'method'.
+  // The only case when for a non-recursive method 'method' the compilation context
+  // is not the caller of the 'method' (but it is the method itself) is
+  // java.lang.ref.Referene::get.
+  // For java.lang.ref.Reference::get, the intrinsic version is used
+  // instead of the compiled version so that the value in the referent
+  // field can be registered by the G1 pre-barrier code. The intrinsified
+  // version of Reference::get also adds a memory barrier to prevent
+  // commoning reads from the referent field across safepoint since GC
+  // can change the referent field's value. See Compile::Compile()
+  // in src/share/vm/opto/compile.cpp or
+  // GraphBuilder::GraphBuilder() in src/share/vm/c1/c1_GraphBuilder.cpp
+  // for more details.
+  ccstr disable_intr = NULL;
+  if ((DisableIntrinsic[0] != '\0' && strstr(DisableIntrinsic, vmIntrinsics::name_at(id)) != NULL) ||
+      (!compilation_context.is_null() &&
+       CompilerOracle::has_option_value(compilation_context, "DisableIntrinsic", disable_intr) &&
+       strstr(disable_intr, vmIntrinsics::name_at(id)) != NULL)
+  ) {
+    return true;
+  }
+
+  // -XX:-InlineNatives disables nearly all intrinsics except the ones listed in
+  // the following switch statement.
+  if (!InlineNatives) {
+    switch (id) {
+    case vmIntrinsics::_indexOf:
+    case vmIntrinsics::_compareTo:
+    case vmIntrinsics::_equals:
+    case vmIntrinsics::_equalsC:
+    case vmIntrinsics::_getAndAddInt:
+    case vmIntrinsics::_getAndAddLong:
+    case vmIntrinsics::_getAndSetInt:
+    case vmIntrinsics::_getAndSetLong:
+    case vmIntrinsics::_getAndSetObject:
+    case vmIntrinsics::_loadFence:
+    case vmIntrinsics::_storeFence:
+    case vmIntrinsics::_fullFence:
+    case vmIntrinsics::_Reference_get:
+      break;
+    default:
+      return true;
+    }
+  }
+
   switch (id) {
   case vmIntrinsics::_isInstance:
   case vmIntrinsics::_isAssignableFrom:
@@ -430,6 +481,7 @@
   case vmIntrinsics::_Class_cast:
   case vmIntrinsics::_getLength:
   case vmIntrinsics::_newArray:
+  case vmIntrinsics::_getClass:
     if (!InlineClassNatives) return true;
     break;
   case vmIntrinsics::_currentThread:
@@ -522,6 +574,12 @@
   case vmIntrinsics::_getAndSetInt:
   case vmIntrinsics::_getAndSetLong:
   case vmIntrinsics::_getAndSetObject:
+  case vmIntrinsics::_loadFence:
+  case vmIntrinsics::_storeFence:
+  case vmIntrinsics::_fullFence:
+  case vmIntrinsics::_compareAndSwapObject:
+  case vmIntrinsics::_compareAndSwapLong:
+  case vmIntrinsics::_compareAndSwapInt:
     if (!InlineUnsafeOps) return true;
     break;
   case vmIntrinsics::_getShortUnaligned:
@@ -584,8 +642,8 @@
     if (!InlineObjectCopy || !InlineArrayCopy) return true;
     break;
   case vmIntrinsics::_compareTo:
-     if (!SpecialStringCompareTo) return true;
-     break;
+    if (!SpecialStringCompareTo) return true;
+    break;
   case vmIntrinsics::_indexOf:
     if (!SpecialStringIndexOf) return true;
     break;
@@ -602,8 +660,8 @@
     if (!InlineReflectionGetCallerClass) return true;
     break;
   case vmIntrinsics::_multiplyToLen:
-      if (!UseMultiplyToLenIntrinsic) return true;
-      break;
+    if (!UseMultiplyToLenIntrinsic) return true;
+    break;
   case vmIntrinsics::_squareToLen:
     if (!UseSquareToLenIntrinsic) return true;
     break;

--- a/hotspot/src/share/vm/classfile/vmSymbols.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/classfile/vmSymbols.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -568,6 +568,11 @@
   template(java_lang_management_ThreadInfo_constructor_signature, "(Ljava/lang/Thread;ILjava/lang/Object;Ljava/lang/Thread;JJJJ[Ljava/lang/StackTraceElement;)V") \
   template(java_lang_management_ThreadInfo_with_locks_constructor_signature, "(Ljava/lang/Thread;ILjava/lang/Object;Ljava/lang/Thread;JJJJ[Ljava/lang/StackTraceElement;[Ljava/lang/Object;[I[Ljava/lang/Object;)V") \
   template(long_long_long_long_void_signature,         "(JJJJ)V")                                                 \
+  template(finalizer_histogram_klass,                  "java/lang/ref/FinalizerHistogram")                        \
+  template(void_finalizer_histogram_entry_array_signature,  "()[Ljava/lang/ref/FinalizerHistogram$Entry;")                        \
+  template(get_finalizer_histogram_name,               "getFinalizerHistogram")                                   \
+  template(finalizer_histogram_entry_name_field,       "className")                                               \
+  template(finalizer_histogram_entry_count_field,      "instanceCount")                                           \
                                                                                                                   \
   template(java_lang_management_MemoryPoolMXBean,      "java/lang/management/MemoryPoolMXBean")                   \
   template(java_lang_management_MemoryManagerMXBean,   "java/lang/management/MemoryManagerMXBean")                \
@@ -1384,10 +1389,9 @@
   // 'method' requires predicated logic.
   static int predicates_needed(vmIntrinsics::ID id);
 
-  // Returns true if an intrinsic is disabled by command-line flags and
-  // false otherwise. Implements functionality common to the C1
-  // and the C2 compiler.
-  static bool is_disabled_by_flags(vmIntrinsics::ID id);
+  // Returns true if a compiler intrinsic is disabled by command-line flags
+  // and false otherwise.
+  static bool is_disabled_by_flags(methodHandle method, methodHandle compilation_context);
 };
 
 #endif // SHARE_VM_CLASSFILE_VMSYMBOLS_HPP

--- a/hotspot/src/share/vm/code/compiledIC.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/code/compiledIC.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -306,7 +306,7 @@
   friend CompiledStaticCall* compiledStaticCall_at(Relocation* call_site);
 
   // Code
-  static void emit_to_interp_stub(CodeBuffer &cbuf);
+  static address emit_to_interp_stub(CodeBuffer &cbuf);
   static int to_interp_stub_size();
   static int reloc_to_interp_stub();
 

--- a/hotspot/src/share/vm/compiler/abstractCompiler.hpp	Thu Aug 13 15:50:52 2015 -0700
+++ b/hotspot/src/share/vm/compiler/abstractCompiler.hpp	Mon Aug 17 11:18:31 2015 -0700
@@ -75,8 +75,8 @@
   //
   // The second parameter, 'compilation_context', is needed to implement functionality
   // related to the DisableIntrinsic command-line flag. The DisableIntrinsic flag can
-  // be used to prohibit the C2 compiler (but not the C1 compiler) to use an intrinsic.
-  // There are three ways to disable an intrinsic using the DisableIntrinsic flag:
+  // be used to prohibit the compilers to use an intrinsic. There are three ways to
+  // disable an intrinsic using the DisableIntrinsic flag:
   //
   // (1) -XX:DisableIntrinsic=_hashCode,_getClass
   //     Disables intrinsification of _hashCode and _getClass globally
@@ -96,7 +96,8 @@
   // compilation context is aClass::aMethod and java.lang.ref.Reference::get,
   // respectively.
   virtual bool is_intrinsic_available(methodHandle method, methodHandle compilation_context) {
-    return false;
+    return is_intrinsic_supported(method) &&
+           !vmIntrinsics::is_disabled_by_flags(method, compilation_context);
   }
 
   // Determines if an intrinsic is supported by the compiler, that is,
@@ -111,13 +112,6 @@
     return false;
   }
 
-  // Implements compiler-specific processing of command-line flags.
-  // Processing of command-line flags common to all compilers is implemented
-  // in vmIntrinsicss::is_disabled_by_flag.
-  virtual bool is_intrinsic_disabled_by_flag(methodHandle method) {
-    return false;
-  }
-
   // Compiler type queries.
   bool is_c1()                                   { return _type == c1; }
   bool is_c2()                                   { return _type == c2; }