handles.hpp:Handle && KlassHandle

hotspot\src\share\vm\runtime\handles.hpp

//------------------------------------------------------------------------------------------------------------------------
// Specific Handles for different oop types
#define DEF_HANDLE(type, is_a)                   \
  class type##Handle;                            \
  class type##Handle: public Handle {            \
   protected:                                    \
    type##Oop    obj() const                     { return (type##Oop)Handle::obj(); } \
    type##Oop    non_null_obj() const            { return (type##Oop)Handle::non_null_obj(); } \
                                                 \
   public:                                       \
    /* Constructors */                           \
    type##Handle ()                              : Handle()                 {} \
    type##Handle (type##Oop obj) : Handle((oop)obj) {                         \
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(),             \
             "illegal type");                                                 \
    }                                                                         \
    type##Handle (Thread* thread, type##Oop obj) : Handle(thread, (oop)obj) { \
      assert(SharedSkipVerify || is_null() || ((oop)obj)->is_a(), "illegal type");  \
    }                                                                         \
    \
    /* Special constructor, use sparingly */ \
    type##Handle (type##Oop *handle, bool dummy) : Handle((oop*)handle, dummy) {} \
                                                 \
    /* Operators for ease of use */              \
    type##Oop    operator () () const            { return obj(); } \
    type##Oop    operator -> () const            { return non_null_obj(); } \
  };

/*
DEF_HANDLE(instance         , is_instance         )
DEF_HANDLE(method           , is_method           )
DEF_HANDLE(constMethod      , is_constMethod      )
DEF_HANDLE(methodData       , is_methodData       )
DEF_HANDLE(array            , is_array            )
DEF_HANDLE(constantPool     , is_constantPool     )
DEF_HANDLE(constantPoolCache, is_constantPoolCache)
DEF_HANDLE(objArray         , is_objArray         )
DEF_HANDLE(typeArray        , is_typeArray        )
*/
//------------------------------------------------------------------------------------------------------------------------
// Specific KlassHandles for different Klass types

#define DEF_KLASS_HANDLE(type, is_a)             \
  class type##Handle : public KlassHandle {      \
   public:                                       \
    /* Constructors */                           \
    type##Handle ()                              : KlassHandle()           {} \
    type##Handle (klassOop obj) : KlassHandle(obj) {                          \
      assert(SharedSkipVerify || is_null() || obj->klass_part()->is_a(),      \
             "illegal type");                                                 \
    }                                                                         \
    type##Handle (Thread* thread, klassOop obj) : KlassHandle(thread, obj) {  \
      assert(SharedSkipVerify || is_null() || obj->klass_part()->is_a(),      \
             "illegal type");                                                 \
    }                                                                         \
                                                 \
    /* Access to klass part */                   \
    type*        operator -> () const            { return (type*)obj()->klass_part(); } \
                                                 \
    static type##Handle cast(KlassHandle h)      { return type##Handle(h()); } \
                                                 \
  };

/*
DEF_KLASS_HANDLE(instanceKlass         , oop_is_instance_slow )
DEF_KLASS_HANDLE(methodKlass           , oop_is_method        )
DEF_KLASS_HANDLE(constMethodKlass      , oop_is_constMethod   )
DEF_KLASS_HANDLE(klassKlass            , oop_is_klass         )
DEF_KLASS_HANDLE(arrayKlassKlass       , oop_is_arrayKlass    )
DEF_KLASS_HANDLE(objArrayKlassKlass    , oop_is_objArrayKlass )
DEF_KLASS_HANDLE(typeArrayKlassKlass   , oop_is_typeArrayKlass)
DEF_KLASS_HANDLE(arrayKlass            , oop_is_array         )
DEF_KLASS_HANDLE(typeArrayKlass        , oop_is_typeArray_slow)
DEF_KLASS_HANDLE(objArrayKlass         , oop_is_objArray_slow )
DEF_KLASS_HANDLE(constantPoolKlass     , oop_is_constantPool  )
DEF_KLASS_HANDLE(constantPoolCacheKlass, oop_is_constantPool  )
*/

class instanceHandle;
class instanceHandle : public Handle {
protected:
    instanceOop obj() const {
        return (instanceOop)Handle::obj();
    }

    instanceOop non_null_obj() const {
        return (instanceOop)Handle::non_null_obj();
    }
public:
    instanceHandle() : Handle() {
    }
    instanceHandle(instanceOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_instance(), "illegal type");
    }
    instanceHandle(Thread* thread, instanceOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_instance(), "illegal type");
    }
    instanceHandle(instanceOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    instanceOop operator () () const {
        return obj();
    }
    instanceOop operator -> () const {
        return non_null_obj();
    }
};

class methodHandle;
class methodHandle : public Handle {
protected: 
    methodOop obj() const {
        return (methodOop)Handle::obj();
    }
    methodOop non_null_obj() const {
        return (methodOop)Handle::non_null_obj();
    }
public: 
    methodHandle() : Handle() {
    }
    methodHandle(methodOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_method(), "illegal type");
    }
    methodHandle(Thread* thread, methodOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_method(), "illegal type");
    }
    methodHandle(methodOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    methodOop operator () () const {
        return obj();
    }
    methodOop operator -> () const {
        return non_null_obj();
    }
};

class constMethodHandle;
class constMethodHandle : public Handle {
protected: 
    constMethodOop obj() const {
        return (constMethodOop)Handle::obj();
    }
    constMethodOop non_null_obj() const {
        return (constMethodOop)Handle::non_null_obj();
    }
public: 
    constMethodHandle() : Handle() {
    }
    constMethodHandle(constMethodOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constMethod(), "illegal type");
    }
    constMethodHandle(Thread* thread, constMethodOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constMethod(), "illegal type");
    }
    constMethodHandle(constMethodOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    constMethodOop operator () () const {
        return obj();
    }
    constMethodOop operator -> () const {
        return non_null_obj();
    }
};

class methodDataHandle;
class methodDataHandle : public Handle {
protected: 
    methodDataOop obj() const {
        return (methodDataOop)Handle::obj();
    }
    methodDataOop non_null_obj() const {
        return (methodDataOop)Handle::non_null_obj();
    }
public:
    methodDataHandle() : Handle() {
    }
    methodDataHandle(methodDataOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_methodData(), "illegal type");
    }
    methodDataHandle(Thread* thread, methodDataOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_methodData(), "illegal type");
    }
    methodDataHandle(methodDataOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    methodDataOop operator () () const {
        return obj();
    }
    methodDataOop operator -> () const {
        return non_null_obj();
    }
};

class arrayHandle;
class arrayHandle : public Handle {
protected: 
    arrayOop obj() const {
        return (arrayOop)Handle::obj();
    }
    arrayOop non_null_obj() const {
        return (arrayOop)Handle::non_null_obj();
    }
public: 
    arrayHandle() : Handle() {
    }
    arrayHandle(arrayOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_array(), "illegal type");
    }
    arrayHandle(Thread* thread, arrayOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_array(), "illegal type");
    }
    arrayHandle(arrayOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    arrayOop operator () () const {
        return obj();
    }
    arrayOop operator -> () const {
        return non_null_obj();
    }
};

class constantPoolHandle;
class constantPoolHandle : public Handle {
protected: 
    constantPoolOop obj() const {
        return (constantPoolOop)Handle::obj();
    }
    constantPoolOop non_null_obj() const {
        return (constantPoolOop)Handle::non_null_obj();
    }
public: 
    constantPoolHandle() : Handle() {
    }
    constantPoolHandle(constantPoolOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPool(), "illegal type");
    }
    constantPoolHandle(Thread* thread, constantPoolOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPool(), "illegal type");
    }
    constantPoolHandle(constantPoolOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    constantPoolOop operator () () const {
        return obj();
    }
    constantPoolOop operator -> () const {
        return non_null_obj();
    }
};

class constantPoolCacheHandle;
class constantPoolCacheHandle : public Handle {
protected: 
    constantPoolCacheOop obj() const {
        return (constantPoolCacheOop)Handle::obj();
    }
    constantPoolCacheOop non_null_obj() const {
        return (constantPoolCacheOop)Handle::non_null_obj();
    }
public: 
    constantPoolCacheHandle() : Handle() {
    }
    constantPoolCacheHandle(constantPoolCacheOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPoolCache(), "illegal type");
    }
    constantPoolCacheHandle(Thread* thread, constantPoolCacheOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_constantPoolCache(), "illegal type");
    }
    constantPoolCacheHandle(constantPoolCacheOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    constantPoolCacheOop operator () () const {
        return obj();
    }
    constantPoolCacheOop operator -> () const {
        return non_null_obj();
    }
};

class objArrayHandle;
class objArrayHandle : public Handle {
protected:
    objArrayOop obj() const {
        return (objArrayOop)Handle::obj();
    }
    objArrayOop non_null_obj() const {
        return (objArrayOop)Handle::non_null_obj();
    }
public: 
    objArrayHandle() : Handle() {
    }
    objArrayHandle(objArrayOop obj) : Handle((oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_objArray(), "illegal type");
    }
    objArrayHandle(Thread* thread, objArrayOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_objArray(), "illegal type");
    }
    objArrayHandle(objArrayOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    objArrayOop operator () () const {
        return obj();
    }
    objArrayOop operator -> () const {
        return non_null_obj();
    }
};

class typeArrayHandle;
class typeArrayHandle : public Handle {
protected: 
    typeArrayOop obj() const {
        return (typeArrayOop)Handle::obj();
    }
    typeArrayOop non_null_obj() const {
       return (typeArrayOop)Handle::non_null_obj();
    }
public:
    typeArrayHandle() : Handle() {
    }
    typeArrayHandle(typeArrayOop obj) : Handle((oop)obj) {
            assert(SharedSkipVerify || is_null() || ((oop)obj)->is_typeArray(), "illegal type");
    }
    typeArrayHandle(Thread* thread, typeArrayOop obj) : Handle(thread, (oop)obj) {
        assert(SharedSkipVerify || is_null() || ((oop)obj)->is_typeArray(), "illegal type");
    }
    typeArrayHandle(typeArrayOop *handle, bool dummy) : Handle((oop*)handle, dummy) {
    }
    typeArrayOop operator () () const {
        return obj();
    }
    typeArrayOop operator -> () const {
        return non_null_obj();
    }
};

class instanceKlassHandle : public KlassHandle {
public: 
    instanceKlassHandle() : KlassHandle() {
    }
    instanceKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_instance_slow(), "illegal type");
    }
    instanceKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_instance_slow(), "illegal type");
    }
    instanceKlass* operator -> () const {
        return (instanceKlass*)obj()->klass_part();
    }
    static instanceKlassHandle cast(KlassHandle h) {
        return instanceKlassHandle(h());
    }
};

class methodKlassHandle : public KlassHandle {
public:
    methodKlassHandle() : KlassHandle() {
    }
    methodKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_method(), "illegal type");
    }
    methodKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_method(), "illegal type");
    }
    methodKlass* operator -> () const {
        return (methodKlass*)obj()->klass_part();
    }
    static methodKlassHandle cast(KlassHandle h) {
        return methodKlassHandle(h());
    }
};

class constMethodKlassHandle : public KlassHandle {
public:
    constMethodKlassHandle() : KlassHandle() {
    }
    constMethodKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constMethod(), "illegal type");
    }
    constMethodKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constMethod(), "illegal type");
    }
    constMethodKlass* operator -> () const {
        return (constMethodKlass*)obj()->klass_part();
    }
    static constMethodKlassHandle cast(KlassHandle h) {
        return constMethodKlassHandle(h());
    }
};

class klassKlassHandle : public KlassHandle {
public: 
    klassKlassHandle() : KlassHandle() {
    }
    klassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_klass(), "illegal type");
    }
    klassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_klass(), "illegal type");
    }
    klassKlass* operator -> () const {
        return (klassKlass*)obj()->klass_part();
    }
    static klassKlassHandle cast(KlassHandle h) {
        return klassKlassHandle(h());
    }
};

class arrayKlassKlassHandle : public KlassHandle {
public: 
    arrayKlassKlassHandle() : KlassHandle() {
    }
    arrayKlassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_arrayKlass(), "illegal type");
    }
    arrayKlassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_arrayKlass(), "illegal type");
    }
    arrayKlassKlass* operator -> () const {
        return (arrayKlassKlass*)obj()->klass_part();
    }
    static arrayKlassKlassHandle cast(KlassHandle h) {
        return arrayKlassKlassHandle(h());
    }
};

class objArrayKlassKlassHandle : public KlassHandle {
public: 
    objArrayKlassKlassHandle() : KlassHandle() {
    }
    objArrayKlassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArrayKlass(), "illegal type");
    }
    objArrayKlassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArrayKlass(), "illegal type");
    }
    objArrayKlassKlass* operator -> () const {
        return (objArrayKlassKlass*)obj()->klass_part();
    }
    static objArrayKlassKlassHandle cast(KlassHandle h) {
        return objArrayKlassKlassHandle(h());
    }
};

class typeArrayKlassKlassHandle : public KlassHandle {
public: 
    typeArrayKlassKlassHandle() : KlassHandle() {
    }
    typeArrayKlassKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArrayKlass(), "illegal type");        
    }
    typeArrayKlassKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArrayKlass(), "illegal type");
    }
    typeArrayKlassKlass* operator -> () const {
        return (typeArrayKlassKlass*)obj()->klass_part();
    }
    static typeArrayKlassKlassHandle cast(KlassHandle h) {
        return typeArrayKlassKlassHandle(h());
    }
};

class arrayKlassHandle : public KlassHandle {
public: 
    arrayKlassHandle() : KlassHandle() {
    }
    arrayKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_array(), "illegal type");
    }
    arrayKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_array(), "illegal type");
    }
    arrayKlass* operator -> () const {
        return (arrayKlass*)obj()->klass_part();
    }
    static arrayKlassHandle cast(KlassHandle h) {
        return arrayKlassHandle(h());
    }
};

class typeArrayKlassHandle : public KlassHandle {
public: 
    typeArrayKlassHandle() : KlassHandle() {
    }
    typeArrayKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArray_slow(), "illegal type");
    }
    typeArrayKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_typeArray_slow(), "illegal type");
    }
    typeArrayKlass* operator -> () const {
        return (typeArrayKlass*)obj()->klass_part();
    }
    static typeArrayKlassHandle cast(KlassHandle h) {
        return typeArrayKlassHandle(h());
    }
};

class objArrayKlassHandle : public KlassHandle {
public:
    objArrayKlassHandle() : KlassHandle() {
    }
    objArrayKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArray_slow(), "illegal type");
    }
    objArrayKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_objArray_slow(), "illegal type");
    }
    objArrayKlass* operator -> () const {
        return (objArrayKlass*)obj()->klass_part();
    }
    static objArrayKlassHandle cast(KlassHandle h) {
        return objArrayKlassHandle(h());
    }
};

class constantPoolKlassHandle : public KlassHandle {
public: 
    constantPoolKlassHandle() : KlassHandle() {
    }
    constantPoolKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolKlass* operator -> () const {
        return (constantPoolKlass*)obj()->klass_part();
    }
    static constantPoolKlassHandle cast(KlassHandle h) {
        return constantPoolKlassHandle(h());
    }
};

class constantPoolCacheKlassHandle : public KlassHandle {
public: 
    constantPoolCacheKlassHandle() : KlassHandle() {
    }
    constantPoolCacheKlassHandle(klassOop obj) : KlassHandle(obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolCacheKlassHandle(Thread* thread, klassOop obj) : KlassHandle(thread, obj) {
        assert(SharedSkipVerify || is_null() || obj->klass_part()->oop_is_constantPool(), "illegal type");
    }
    constantPoolCacheKlass* operator -> () const {
        return (constantPoolCacheKlass*)obj()->klass_part();
    }
    static constantPoolCacheKlassHandle cast(KlassHandle h) {
        return constantPoolCacheKlassHandle(h());
    }
};