diff -r 000000000000 -r f90c822e73f8 src/share/vm/runtime/unhandledOops.hpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/share/vm/runtime/unhandledOops.hpp	Wed Apr 27 01:25:04 2016 +0800
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2005, 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.
+ *
+ */
+
+#ifndef SHARE_VM_RUNTIME_UNHANDLEDOOPS_HPP
+#define SHARE_VM_RUNTIME_UNHANDLEDOOPS_HPP
+
+#ifdef CHECK_UNHANDLED_OOPS
+
+// Detect unhanded oops in VM code
+
+// The design is that when an oop is declared on the stack as a local
+// variable, the oop is actually a C++ struct with constructor and
+// destructor.  The constructor adds the oop address on a list
+// off each thread and the destructor removes the oop.  At a potential
+// safepoint, the stack addresses of the local variable oops are trashed
+// with a recognizeable value.  If the local variable is used again, it
+// will segfault, indicating an unsafe use of that oop.
+// eg:
+//    oop o;    //register &o on list
+//    funct();  // if potential safepoint - causes clear_naked_oops()
+//              // which trashes o above.
+//    o->do_something();  // Crashes because o is unsafe.
+//
+// This code implements the details of the unhandled oop list on the thread.
+//
+
+class oop;
+class Thread;
+
+class UnhandledOopEntry : public CHeapObj<mtThread> {
+ friend class UnhandledOops;
+ private:
+  oop* _oop_ptr;
+  bool _ok_for_gc;
+  address _pc;
+ public:
+  oop* oop_ptr() { return _oop_ptr; }
+  UnhandledOopEntry() : _oop_ptr(NULL), _ok_for_gc(false), _pc(NULL) {}
+  UnhandledOopEntry(oop* op, address pc) :
+                        _oop_ptr(op),   _ok_for_gc(false), _pc(pc) {}
+};
+
+
+class UnhandledOops : public CHeapObj<mtThread> {
+ friend class Thread;
+ private:
+  Thread* _thread;
+  int _level;
+  GrowableArray<UnhandledOopEntry> *_oop_list;
+  void allow_unhandled_oop(oop* op);
+  void clear_unhandled_oops();
+  UnhandledOops(Thread* thread);
+  ~UnhandledOops();
+
+ public:
+  static void dump_oops(UnhandledOops* list);
+  void register_unhandled_oop(oop* op, address pc);
+  void unregister_unhandled_oop(oop* op);
+};
+
+#ifdef _LP64
+const intptr_t BAD_OOP_ADDR =  0xfffffffffffffff1;
+#else
+const intptr_t BAD_OOP_ADDR =  0xfffffff1;
+#endif // _LP64
+#endif // CHECK_UNHANDLED_OOPS
+
+#endif // SHARE_VM_RUNTIME_UNHANDLEDOOPS_HPP