*** old/src/share/vm/prims/unsafe.cpp	Wed Apr 22 10:51:38 2015
--- new/src/share/vm/prims/unsafe.cpp	Wed Apr 22 10:51:38 2015

*** 170,200 ****
--- 170,195 ----
  
  #define SET_FIELD_VOLATILE(obj, offset, type_name, x) \
    oop p = JNIHandles::resolve(obj); \
    OrderAccess::release_store_fence((volatile type_name*)index_oop_from_field_offset_long(p, offset), x);
  
  // Macros for oops that check UseCompressedOops
  
  #define GET_OOP_FIELD(obj, offset, v) \
    oop p = JNIHandles::resolve(obj);   \
    oop v;                              \
    if (UseCompressedOops) {            \
      narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset); \
      v = oopDesc::decode_heap_oop(n);                                \
    } else {                            \
      v = *(oop*)index_oop_from_field_offset_long(p, offset);                 \
    }
  
  
  // Get/SetObject must be special-cased, since it works with handles.
  
  // These functions allow a null base pointer with an arbitrary address.
  // But if the base pointer is non-null, the offset should make some sense.
  // That is, it should be in the range [0, MAX_OBJECT_SIZE].
  UNSAFE_ENTRY(jobject, Unsafe_GetObject(JNIEnv *env, jobject unsafe, jobject obj, jlong offset))
    UnsafeWrapper("Unsafe_GetObject");
    GET_OOP_FIELD(obj, offset, v)
+   oop p = JNIHandles::resolve(obj);
+   oop v;
+   if (UseCompressedOops) {            \
+     narrowOop n = *(narrowOop*)index_oop_from_field_offset_long(p, offset);
+     v = oopDesc::decode_heap_oop(n);
+   } else {
+     v = *(oop*)index_oop_from_field_offset_long(p, offset);
+   }
    jobject ret = JNIHandles::make_local(env, v);
  #if INCLUDE_ALL_GCS
    // We could be accessing the referent field in a reference
    // object. If G1 is enabled then we need to register non-null
    // referent with the SATB barrier.

*** 259,268 ****
--- 254,282 ----
      oop_store((oop*)addr, x);
    }
    OrderAccess::fence();
  UNSAFE_END
  
+ UNSAFE_ENTRY(jobject, Unsafe_GetUncompressedObject(JNIEnv *env, jobject unsafe, jlong addr))
+   UnsafeWrapper("Unsafe_GetUncompressedObject");
+   oop v = *(oop*) (address) addr;
+   return JNIHandles::make_local(env, v);
+ UNSAFE_END
+ 
+ UNSAFE_ENTRY(jclass, Unsafe_GetJavaMirror(JNIEnv *env, jobject unsafe, jlong metaspace_klass))
+   UnsafeWrapper("Unsafe_GetJavaMirror");
+   Klass* klass = (Klass*) (address) metaspace_klass;
+   return (jclass) JNIHandles::make_local(klass->java_mirror());
+ UNSAFE_END
+ 
+ UNSAFE_ENTRY(jlong, Unsafe_GetKlassPointer(JNIEnv *env, jobject unsafe, jobject obj))
+   UnsafeWrapper("Unsafe_GetKlassPointer");
+   oop o = JNIHandles::resolve(obj);
+   jlong klass = (jlong) (address) o->klass();
+   return klass;
+ UNSAFE_END
+ 
  #ifndef SUPPORTS_NATIVE_CX8
  
  // VM_Version::supports_cx8() is a surrogate for 'supports atomic long memory ops'.
  //
  // On platforms which do not support atomic compare-and-swap of jlong (8 byte)

*** 1220,1229 ****
--- 1234,1247 ----
      {CC"getObject",        CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObject)},
      {CC"putObject",        CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObject)},
      {CC"getObjectVolatile",CC"("OBJ"J)"OBJ"",   FN_PTR(Unsafe_GetObjectVolatile)},
      {CC"putObjectVolatile",CC"("OBJ"J"OBJ")V",  FN_PTR(Unsafe_SetObjectVolatile)},
  
+     {CC"getUncompressedObject", CC"("ADR")"OBJ, FN_PTR(Unsafe_GetUncompressedObject)},
+     {CC"getJavaMirror",         CC"("ADR")"CLS, FN_PTR(Unsafe_GetJavaMirror)},
+     {CC"getKlassPointer",       CC"("OBJ")"ADR, FN_PTR(Unsafe_GetKlassPointer)},
+ 
      DECLARE_GETPUTOOP(Boolean, Z),
      DECLARE_GETPUTOOP(Byte, B),
      DECLARE_GETPUTOOP(Short, S),
      DECLARE_GETPUTOOP(Char, C),
      DECLARE_GETPUTOOP(Int, I),