• file
• revisions
• annotate
• diff
• comparison
• raw

src/share/vm/oops/oopsHierarchy.hpp@5f24d0319e54 (annotated)

src/share/vm/oops/oopsHierarchy.hpp

Fri, 29 Jan 2010 09:27:22 -0800

author

kvn

date

Fri, 29 Jan 2010 09:27:22 -0800

changeset 1637

5f24d0319e54

parent 1280

df6caf649ff7

child 1907

c18cbe5936b8

permissions

-rw-r--r--

4360113: Evict nmethods when code cache gets full
Summary: Speculatively unload the oldest nmethods when code cache gets full.
Reviewed-by: never, kvn
Contributed-by: eric.caspole@amd.com

duke@435	1	/*
xdono@1014	2	* Copyright 1997-2009 Sun Microsystems, Inc. All Rights Reserved.
duke@435	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
duke@435	4	*
duke@435	5	* This code is free software; you can redistribute it and/or modify it
duke@435	6	* under the terms of the GNU General Public License version 2 only, as
duke@435	7	* published by the Free Software Foundation.
duke@435	8	*
duke@435	9	* This code is distributed in the hope that it will be useful, but WITHOUT
duke@435	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
duke@435	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
duke@435	12	* version 2 for more details (a copy is included in the LICENSE file that
duke@435	13	* accompanied this code).
duke@435	14	*
duke@435	15	* You should have received a copy of the GNU General Public License version
duke@435	16	* 2 along with this work; if not, write to the Free Software Foundation,
duke@435	17	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
duke@435	18	*
duke@435	19	* Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
duke@435	20	* CA 95054 USA or visit www.sun.com if you need additional information or
duke@435	21	* have any questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	// OBJECT hierarchy
duke@435	26	// This hierarchy is a representation hierarchy, i.e. if A is a superclass
duke@435	27	// of B, A's representation is a prefix of B's representation.
duke@435	28
coleenp@548	29	typedef juint narrowOop; // Offset instead of address for an oop within a java object
coleenp@548	30	typedef class klassOopDesc* wideKlassOop; // to keep SA happy and unhandled oop
coleenp@548	31	// detector happy.
ysr@1280	32	typedef void* OopOrNarrowOopStar;
coleenp@548	33
duke@435	34	#ifndef CHECK_UNHANDLED_OOPS
duke@435	35
coleenp@548	36	typedef class oopDesc* oop;
duke@435	37	typedef class instanceOopDesc* instanceOop;
coleenp@548	38	typedef class methodOopDesc* methodOop;
coleenp@548	39	typedef class constMethodOopDesc* constMethodOop;
coleenp@548	40	typedef class methodDataOopDesc* methodDataOop;
coleenp@548	41	typedef class arrayOopDesc* arrayOop;
coleenp@548	42	typedef class objArrayOopDesc* objArrayOop;
coleenp@548	43	typedef class typeArrayOopDesc* typeArrayOop;
coleenp@548	44	typedef class constantPoolOopDesc* constantPoolOop;
coleenp@548	45	typedef class constantPoolCacheOopDesc* constantPoolCacheOop;
coleenp@548	46	typedef class symbolOopDesc* symbolOop;
coleenp@548	47	typedef class klassOopDesc* klassOop;
coleenp@548	48	typedef class markOopDesc* markOop;
duke@435	49	typedef class compiledICHolderOopDesc* compiledICHolderOop;
duke@435	50
duke@435	51	#else
duke@435	52
duke@435	53
duke@435	54	// When CHECK_UNHANDLED_OOPS is defined, an "oop" is a class with a
duke@435	55	// carefully chosen set of constructors and conversion operators to go
duke@435	56	// to and from the underlying oopDesc pointer type.
duke@435	57	//
duke@435	58	// Because oop and its subclasses <type>Oop are class types, arbitrary
duke@435	59	// conversions are not accepted by the compiler, and you may get a message
duke@435	60	// about overloading ambiguity (between long and int is common when converting
duke@435	61	// from a constant in 64 bit mode), or unable to convert from type to 'oop'.
duke@435	62	// Applying a cast to one of these conversion operators first will get to the
duke@435	63	// underlying oopDesc* type if appropriate.
duke@435	64	// Converting NULL to oop to Handle implicit is no longer accepted by the
duke@435	65	// compiler because there are too many steps in the conversion. Use Handle()
duke@435	66	// instead, which generates less code anyway.
duke@435	67
duke@435	68	class Thread;
duke@435	69	typedef class markOopDesc* markOop;
duke@435	70	class PromotedObject;
duke@435	71
duke@435	72
duke@435	73	class oop {
duke@435	74	oopDesc* _o;
duke@435	75
duke@435	76	void register_oop();
duke@435	77	void unregister_oop();
duke@435	78
duke@435	79	// friend class markOop;
duke@435	80	public:
duke@435	81	void set_obj(const void* p) {
duke@435	82	raw_set_obj(p);
duke@435	83	if (CheckUnhandledOops) register_oop();
duke@435	84	}
duke@435	85	void raw_set_obj(const void* p) { _o = (oopDesc*)p; }
duke@435	86
duke@435	87	oop() { set_obj(NULL); }
duke@435	88	oop(const volatile oop& o) { set_obj(o.obj()); }
duke@435	89	oop(const void* p) { set_obj(p); }
duke@435	90	oop(intptr_t i) { set_obj((void *)i); }
duke@435	91	#ifdef _LP64
duke@435	92	oop(int i) { set_obj((void *)i); }
duke@435	93	#endif
duke@435	94	~oop() {
duke@435	95	if (CheckUnhandledOops) unregister_oop();
duke@435	96	}
duke@435	97
duke@435	98	oopDesc* obj() const volatile { return _o; }
duke@435	99
duke@435	100	// General access
duke@435	101	oopDesc* operator->() const { return obj(); }
duke@435	102	bool operator==(const oop o) const { return obj() == o.obj(); }
duke@435	103	bool operator==(void *p) const { return obj() == p; }
duke@435	104	bool operator!=(const oop o) const { return obj() != o.obj(); }
duke@435	105	bool operator!=(void *p) const { return obj() != p; }
duke@435	106	bool operator==(intptr_t p) const { return obj() == (oopDesc*)p; }
duke@435	107	bool operator!=(intptr_t p) const { return obj() != (oopDesc*)p; }
duke@435	108
duke@435	109	bool operator<(oop o) const { return obj() < o.obj(); }
duke@435	110	bool operator>(oop o) const { return obj() > o.obj(); }
duke@435	111	bool operator<=(oop o) const { return obj() <= o.obj(); }
duke@435	112	bool operator>=(oop o) const { return obj() >= o.obj(); }
duke@435	113	bool operator!() const { return !obj(); }
duke@435	114
duke@435	115	// Cast
duke@435	116	operator void* () const { return (void *)obj(); }
duke@435	117	operator HeapWord* () const { return (HeapWord*)obj(); }
duke@435	118	operator oopDesc* () const { return obj(); }
duke@435	119	operator intptr_t* () const { return (intptr_t*)obj(); }
duke@435	120	operator PromotedObject* () const { return (PromotedObject*)obj(); }
duke@435	121	operator markOop () const { return markOop(obj()); }
duke@435	122
duke@435	123	operator address () const { return (address)obj(); }
duke@435	124	operator intptr_t () const { return (intptr_t)obj(); }
duke@435	125
duke@435	126	// from javaCalls.cpp
duke@435	127	operator jobject () const { return (jobject)obj(); }
duke@435	128	// from javaClasses.cpp
duke@435	129	operator JavaThread* () const { return (JavaThread*)obj(); }
xlu@948	130
xlu@948	131	#ifndef _LP64
duke@435	132	// from jvm.cpp
duke@435	133	operator jlong* () const { return (jlong*)obj(); }
xlu@948	134	#endif
duke@435	135
duke@435	136	// from parNewGeneration and other things that want to get to the end of
duke@435	137	// an oop for stuff (like constMethodKlass.cpp, objArrayKlass.cpp)
duke@435	138	operator oop* () const { return (oop *)obj(); }
duke@435	139	};
duke@435	140
duke@435	141	#define DEF_OOP(type) \
duke@435	142	class type##OopDesc; \
duke@435	143	class type##Oop : public oop { \
duke@435	144	public: \
duke@435	145	type##Oop() : oop() {} \
duke@435	146	type##Oop(const volatile oop& o) : oop(o) {} \
duke@435	147	type##Oop(const void* p) : oop(p) {} \
duke@435	148	operator type##OopDesc* () const { return (type##OopDesc*)obj(); } \
duke@435	149	type##OopDesc* operator->() const { \
duke@435	150	return (type##OopDesc*)obj(); \
duke@435	151	} \
duke@435	152	}; \
duke@435	153
duke@435	154	DEF_OOP(instance);
duke@435	155	DEF_OOP(method);
duke@435	156	DEF_OOP(methodData);
duke@435	157	DEF_OOP(array);
duke@435	158	DEF_OOP(constMethod);
duke@435	159	DEF_OOP(constantPool);
duke@435	160	DEF_OOP(constantPoolCache);
duke@435	161	DEF_OOP(objArray);
duke@435	162	DEF_OOP(typeArray);
duke@435	163	DEF_OOP(symbol);
duke@435	164	DEF_OOP(klass);
duke@435	165	DEF_OOP(compiledICHolder);
duke@435	166
duke@435	167	#endif // CHECK_UNHANDLED_OOPS
duke@435	168
duke@435	169	// The klass hierarchy is separate from the oop hierarchy.
duke@435	170
duke@435	171	class Klass;
duke@435	172	class instanceKlass;
duke@435	173	class instanceRefKlass;
duke@435	174	class methodKlass;
duke@435	175	class constMethodKlass;
duke@435	176	class methodDataKlass;
duke@435	177	class klassKlass;
duke@435	178	class instanceKlassKlass;
duke@435	179	class arrayKlassKlass;
duke@435	180	class objArrayKlassKlass;
duke@435	181	class typeArrayKlassKlass;
duke@435	182	class arrayKlass;
duke@435	183	class objArrayKlass;
duke@435	184	class typeArrayKlass;
coleenp@548	185	class constantPoolKlass;
coleenp@548	186	class constantPoolCacheKlass;
coleenp@548	187	class symbolKlass;
duke@435	188	class compiledICHolderKlass;