--- old/src/cpu/x86/vm/c1_Runtime1_x86.cpp	2017-04-18 10:46:05.998575086 -0700
+++ new/src/cpu/x86/vm/c1_Runtime1_x86.cpp	2017-04-18 10:46:05.878575555 -0700
@@ -414,7 +414,8 @@
 }
 
 static OopMap* save_live_registers(StubAssembler* sasm, int num_rt_args,
-                                   bool save_fpu_registers = true) {
+                                   bool save_fpu_registers = true,
+                                   bool do_generate_oop_map = true) {
   __ block_comment("save_live_registers");
 
   __ pusha();         // integer registers
@@ -489,7 +490,9 @@
   // FPU stack must be empty now
   __ verify_FPU(0, "save_live_registers");
 
-  return generate_oop_map(sasm, num_rt_args, save_fpu_registers);
+  return do_generate_oop_map
+      ? generate_oop_map(sasm, num_rt_args, save_fpu_registers)
+      : NULL;
 }
 
 
@@ -957,6 +960,24 @@
   return oop_maps;
 }
 
+static void heap_support_stub(StubAssembler* sasm, Register obj,
+                              Register size_in_bytes, int con_size_in_bytes,
+                              Register t1, Register t2) {
+  // Usually, when we invoke the sampling methods from within the client
+  // compiler, we do so in a stub.  However, sometimes, we are already in a stub
+  // when we want to call these things, and stack trace gathering gets confused
+  // when you call a stub inside another stub.
+  HEAP_MONITORING(sasm, noreg, size_in_bytes, con_size_in_bytes, obj, t1, t2, \
+  { \
+    save_live_registers(sasm, 1, true, false); \
+    __ NOT_LP64(push(rax)) LP64_ONLY(mov(c_rarg0, rax)); \
+    __ call(RuntimeAddress(
+        CAST_FROM_FN_PTR(address, \
+                         HeapMonitoring::object_alloc_unsized))); \
+    NOT_LP64(__ pop(rax)); \
+    restore_live_registers(sasm); \
+  });
+}
 
 OopMapSet* Runtime1::generate_code_for(StubID id, StubAssembler* sasm) {
 
@@ -1042,6 +1063,7 @@
 
           __ initialize_object(obj, klass, obj_size, 0, t1, t2, /* is_tlab_allocated */ true);
           __ verify_oop(obj);
+          heap_support_stub(sasm, obj, obj_size, 0, t1, t2);
           __ pop(rbx);
           __ pop(rdi);
           __ ret(0);
@@ -1170,8 +1192,12 @@
           __ subptr(arr_size, t1);  // body length
           __ addptr(t1, obj);       // body start
           if (!ZeroTLAB) {
+            // Initialize body destroys arr_size so remember it.
+            __ push(arr_size);
             __ initialize_body(t1, arr_size, 0, t2);
+            __ pop(arr_size);
           }
+          heap_support_stub(sasm, obj, arr_size, 0, t1, t2);
           __ verify_oop(obj);
           __ ret(0);
 
@@ -1504,6 +1530,22 @@
         NOT_LP64(__ pop(rax));
 
         restore_live_registers(sasm);
+      }
+      break;
+
+    case heap_object_sample_id:
+      { // rax,: object
+        StubFrame f(sasm, "heap_object_sample", dont_gc_arguments);
+        // We can't gc here so skip the oopmap but make sure that all
+        // the live registers get saved
+        save_live_registers(sasm, 1);
+
+        __ NOT_LP64(push(rax)) LP64_ONLY(mov(c_rarg0, rax));
+        __ call(RuntimeAddress(CAST_FROM_FN_PTR(address,
+                                                HeapMonitoring::object_alloc)));
+        NOT_LP64(__ pop(rax));
+
+        restore_live_registers(sasm);
       }
       break;