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

src/share/vm/utilities/accessFlags.hpp@c96030fff130 (annotated)

src/share/vm/utilities/accessFlags.hpp

Thu, 20 Nov 2008 16:56:09 -0800

author

ysr

date

Thu, 20 Nov 2008 16:56:09 -0800

changeset 888

c96030fff130

parent 435

a61af66fc99e

child 1145

e5b0439ef4ae

permissions

-rw-r--r--

6684579: SoftReference processing can be made more efficient
Summary: For current soft-ref clearing policies, we can decide at marking time if a soft-reference will definitely not be cleared, postponing the decision of whether it will definitely be cleared to the final reference processing phase. This can be especially beneficial in the case of concurrent collectors where the marking is usually concurrent but reference processing is usually not.
Reviewed-by: jmasa

duke@435	1	/*
duke@435	2	* Copyright 1997-2007 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	// AccessFlags is an abstraction over Java access flags.
duke@435	26
duke@435	27
duke@435	28	enum {
duke@435	29	// See jvm.h for shared JVM_ACC_XXX access flags
duke@435	30
duke@435	31	// HotSpot-specific access flags
duke@435	32
duke@435	33	// flags actually put in .class file
duke@435	34	JVM_ACC_WRITTEN_FLAGS = 0x00007FFF,
duke@435	35
duke@435	36	// methodOop flags
duke@435	37	JVM_ACC_MONITOR_MATCH = 0x10000000, // True if we know that monitorenter/monitorexit bytecodes match
duke@435	38	JVM_ACC_HAS_MONITOR_BYTECODES = 0x20000000, // Method contains monitorenter/monitorexit bytecodes
duke@435	39	JVM_ACC_HAS_LOOPS = 0x40000000, // Method has loops
duke@435	40	JVM_ACC_LOOPS_FLAG_INIT = (int)0x80000000,// The loop flag has been initialized
duke@435	41	JVM_ACC_QUEUED = 0x01000000, // Queued for compilation
duke@435	42	JVM_ACC_NOT_TIER1_COMPILABLE = 0x04000000,
duke@435	43	JVM_ACC_NOT_OSR_COMPILABLE = 0x08000000,
duke@435	44	JVM_ACC_HAS_LINE_NUMBER_TABLE = 0x00100000,
duke@435	45	JVM_ACC_HAS_CHECKED_EXCEPTIONS = 0x00400000,
duke@435	46	JVM_ACC_HAS_JSRS = 0x00800000,
duke@435	47	JVM_ACC_IS_OLD = 0x00010000, // RedefineClasses() has replaced this method
duke@435	48	JVM_ACC_IS_OBSOLETE = 0x00020000, // RedefineClasses() has made method obsolete
duke@435	49	JVM_ACC_IS_PREFIXED_NATIVE = 0x00040000, // JVMTI has prefixed this native method
duke@435	50
duke@435	51	// klassOop flags
duke@435	52	JVM_ACC_HAS_MIRANDA_METHODS = 0x10000000, // True if this class has miranda methods in it's vtable
duke@435	53	JVM_ACC_HAS_VANILLA_CONSTRUCTOR = 0x20000000, // True if klass has a vanilla default constructor
duke@435	54	JVM_ACC_HAS_FINALIZER = 0x40000000, // True if klass has a non-empty finalize() method
duke@435	55	JVM_ACC_IS_CLONEABLE = (int)0x80000000,// True if klass supports the Clonable interface
duke@435	56	JVM_ACC_HAS_FINAL_METHOD = 0x01000000, // True if klass has final method
duke@435	57
duke@435	58	// klassOop and methodOop flags
duke@435	59	JVM_ACC_HAS_LOCAL_VARIABLE_TABLE= 0x00200000,
duke@435	60
duke@435	61	JVM_ACC_PROMOTED_FLAGS = 0x00200000, // flags promoted from methods to the holding klass
duke@435	62
duke@435	63	// field flags
duke@435	64	// Note: these flags must be defined in the low order 16 bits because
duke@435	65	// instanceKlass only stores a ushort worth of information from the
duke@435	66	// AccessFlags value.
duke@435	67	// These bits must not conflict with any other field-related access flags
duke@435	68	// (e.g., ACC_ENUM).
duke@435	69	// Note that the class-related ACC_ANNOTATION bit conflicts with these flags.
duke@435	70	JVM_ACC_FIELD_ACCESS_WATCHED = 0x00002000, // field access is watched by JVMTI
duke@435	71	JVM_ACC_FIELD_MODIFICATION_WATCHED = 0x00008000, // field modification is watched by JVMTI
duke@435	72
duke@435	73	// flags accepted by set_field_flags()
duke@435	74	JVM_ACC_FIELD_FLAGS = 0x00008000 | JVM_ACC_WRITTEN_FLAGS
duke@435	75	};
duke@435	76
duke@435	77
duke@435	78	class AccessFlags VALUE_OBJ_CLASS_SPEC {
duke@435	79	friend class VMStructs;
duke@435	80	private:
duke@435	81	jint _flags;
duke@435	82
duke@435	83	public:
duke@435	84	// Java access flags
duke@435	85	bool is_public () const { return (_flags & JVM_ACC_PUBLIC ) != 0; }
duke@435	86	bool is_private () const { return (_flags & JVM_ACC_PRIVATE ) != 0; }
duke@435	87	bool is_protected () const { return (_flags & JVM_ACC_PROTECTED ) != 0; }
duke@435	88	bool is_static () const { return (_flags & JVM_ACC_STATIC ) != 0; }
duke@435	89	bool is_final () const { return (_flags & JVM_ACC_FINAL ) != 0; }
duke@435	90	bool is_synchronized() const { return (_flags & JVM_ACC_SYNCHRONIZED) != 0; }
duke@435	91	bool is_super () const { return (_flags & JVM_ACC_SUPER ) != 0; }
duke@435	92	bool is_volatile () const { return (_flags & JVM_ACC_VOLATILE ) != 0; }
duke@435	93	bool is_transient () const { return (_flags & JVM_ACC_TRANSIENT ) != 0; }
duke@435	94	bool is_native () const { return (_flags & JVM_ACC_NATIVE ) != 0; }
duke@435	95	bool is_interface () const { return (_flags & JVM_ACC_INTERFACE ) != 0; }
duke@435	96	bool is_abstract () const { return (_flags & JVM_ACC_ABSTRACT ) != 0; }
duke@435	97	bool is_strict () const { return (_flags & JVM_ACC_STRICT ) != 0; }
duke@435	98
duke@435	99	// Attribute flags
duke@435	100	bool is_synthetic () const { return (_flags & JVM_ACC_SYNTHETIC ) != 0; }
duke@435	101
duke@435	102	// methodOop flags
duke@435	103	bool is_monitor_matching () const { return (_flags & JVM_ACC_MONITOR_MATCH ) != 0; }
duke@435	104	bool has_monitor_bytecodes () const { return (_flags & JVM_ACC_HAS_MONITOR_BYTECODES ) != 0; }
duke@435	105	bool has_loops () const { return (_flags & JVM_ACC_HAS_LOOPS ) != 0; }
duke@435	106	bool loops_flag_init () const { return (_flags & JVM_ACC_LOOPS_FLAG_INIT ) != 0; }
duke@435	107	bool queued_for_compilation () const { return (_flags & JVM_ACC_QUEUED ) != 0; }
duke@435	108	bool is_not_tier1_compilable () const { return (_flags & JVM_ACC_NOT_TIER1_COMPILABLE ) != 0; }
duke@435	109	bool is_not_osr_compilable () const { return (_flags & JVM_ACC_NOT_OSR_COMPILABLE ) != 0; }
duke@435	110	bool has_linenumber_table () const { return (_flags & JVM_ACC_HAS_LINE_NUMBER_TABLE ) != 0; }
duke@435	111	bool has_checked_exceptions () const { return (_flags & JVM_ACC_HAS_CHECKED_EXCEPTIONS ) != 0; }
duke@435	112	bool has_jsrs () const { return (_flags & JVM_ACC_HAS_JSRS ) != 0; }
duke@435	113	bool is_old () const { return (_flags & JVM_ACC_IS_OLD ) != 0; }
duke@435	114	bool is_obsolete () const { return (_flags & JVM_ACC_IS_OBSOLETE ) != 0; }
duke@435	115	bool is_prefixed_native () const { return (_flags & JVM_ACC_IS_PREFIXED_NATIVE ) != 0; }
duke@435	116
duke@435	117	// klassOop flags
duke@435	118	bool has_miranda_methods () const { return (_flags & JVM_ACC_HAS_MIRANDA_METHODS ) != 0; }
duke@435	119	bool has_vanilla_constructor () const { return (_flags & JVM_ACC_HAS_VANILLA_CONSTRUCTOR) != 0; }
duke@435	120	bool has_finalizer () const { return (_flags & JVM_ACC_HAS_FINALIZER ) != 0; }
duke@435	121	bool has_final_method () const { return (_flags & JVM_ACC_HAS_FINAL_METHOD ) != 0; }
duke@435	122	bool is_cloneable () const { return (_flags & JVM_ACC_IS_CLONEABLE ) != 0; }
duke@435	123	// klassOop and methodOop flags
duke@435	124	bool has_localvariable_table () const { return (_flags & JVM_ACC_HAS_LOCAL_VARIABLE_TABLE) != 0; }
duke@435	125	void set_has_localvariable_table() { atomic_set_bits(JVM_ACC_HAS_LOCAL_VARIABLE_TABLE); }
duke@435	126	void clear_has_localvariable_table() { atomic_clear_bits(JVM_ACC_HAS_LOCAL_VARIABLE_TABLE); }
duke@435	127
duke@435	128	// field flags
duke@435	129	bool is_field_access_watched() const { return (_flags & JVM_ACC_FIELD_ACCESS_WATCHED) != 0; }
duke@435	130	bool is_field_modification_watched() const
duke@435	131	{ return (_flags & JVM_ACC_FIELD_MODIFICATION_WATCHED) != 0; }
duke@435	132
duke@435	133	// get .class file flags
duke@435	134	jint get_flags () const { return (_flags & JVM_ACC_WRITTEN_FLAGS); }
duke@435	135
duke@435	136	// Initialization
duke@435	137	void add_promoted_flags(jint flags) { _flags |= (flags & JVM_ACC_PROMOTED_FLAGS); }
duke@435	138	void set_field_flags(jint flags) { _flags = (flags & JVM_ACC_FIELD_FLAGS); }
duke@435	139	void set_flags(jint flags) { _flags = (flags & JVM_ACC_WRITTEN_FLAGS); }
duke@435	140
duke@435	141	void set_queued_for_compilation() { atomic_set_bits(JVM_ACC_QUEUED); }
duke@435	142	void clear_queued_for_compilation() { atomic_clear_bits(JVM_ACC_QUEUED); }
duke@435	143
duke@435	144	// Atomic update of flags
duke@435	145	void atomic_set_bits(jint bits);
duke@435	146	void atomic_clear_bits(jint bits);
duke@435	147
duke@435	148	private:
duke@435	149	friend class methodOopDesc;
duke@435	150	friend class Klass;
duke@435	151	friend class ClassFileParser;
duke@435	152	// the functions below should only be called on the _access_flags inst var directly,
duke@435	153	// otherwise they are just changing a copy of the flags
duke@435	154
duke@435	155	// attribute flags
duke@435	156	void set_is_synthetic() { atomic_set_bits(JVM_ACC_SYNTHETIC); }
duke@435	157
duke@435	158	// methodOop flags
duke@435	159	void set_monitor_matching() { atomic_set_bits(JVM_ACC_MONITOR_MATCH); }
duke@435	160	void set_has_monitor_bytecodes() { atomic_set_bits(JVM_ACC_HAS_MONITOR_BYTECODES); }
duke@435	161	void set_has_loops() { atomic_set_bits(JVM_ACC_HAS_LOOPS); }
duke@435	162	void set_loops_flag_init() { atomic_set_bits(JVM_ACC_LOOPS_FLAG_INIT); }
duke@435	163	void set_not_tier1_compilable() { atomic_set_bits(JVM_ACC_NOT_TIER1_COMPILABLE); }
duke@435	164	void set_not_osr_compilable() { atomic_set_bits(JVM_ACC_NOT_OSR_COMPILABLE); }
duke@435	165	void set_has_linenumber_table() { atomic_set_bits(JVM_ACC_HAS_LINE_NUMBER_TABLE); }
duke@435	166	void set_has_checked_exceptions() { atomic_set_bits(JVM_ACC_HAS_CHECKED_EXCEPTIONS); }
duke@435	167	void set_has_jsrs() { atomic_set_bits(JVM_ACC_HAS_JSRS); }
duke@435	168	void set_is_old() { atomic_set_bits(JVM_ACC_IS_OLD); }
duke@435	169	void set_is_obsolete() { atomic_set_bits(JVM_ACC_IS_OBSOLETE); }
duke@435	170	void set_is_prefixed_native() { atomic_set_bits(JVM_ACC_IS_PREFIXED_NATIVE); }
duke@435	171
duke@435	172	// klassOop flags
duke@435	173	void set_has_vanilla_constructor() { atomic_set_bits(JVM_ACC_HAS_VANILLA_CONSTRUCTOR); }
duke@435	174	void set_has_finalizer() { atomic_set_bits(JVM_ACC_HAS_FINALIZER); }
duke@435	175	void set_has_final_method() { atomic_set_bits(JVM_ACC_HAS_FINAL_METHOD); }
duke@435	176	void set_is_cloneable() { atomic_set_bits(JVM_ACC_IS_CLONEABLE); }
duke@435	177	void set_has_miranda_methods() { atomic_set_bits(JVM_ACC_HAS_MIRANDA_METHODS); }
duke@435	178
duke@435	179	public:
duke@435	180	// field flags
duke@435	181	void set_is_field_access_watched(const bool value)
duke@435	182	{
duke@435	183	if (value) {
duke@435	184	atomic_set_bits(JVM_ACC_FIELD_ACCESS_WATCHED);
duke@435	185	} else {
duke@435	186	atomic_clear_bits(JVM_ACC_FIELD_ACCESS_WATCHED);
duke@435	187	}
duke@435	188	}
duke@435	189	void set_is_field_modification_watched(const bool value)
duke@435	190	{
duke@435	191	if (value) {
duke@435	192	atomic_set_bits(JVM_ACC_FIELD_MODIFICATION_WATCHED);
duke@435	193	} else {
duke@435	194	atomic_clear_bits(JVM_ACC_FIELD_MODIFICATION_WATCHED);
duke@435	195	}
duke@435	196	}
duke@435	197
duke@435	198	// Conversion
duke@435	199	jshort as_short() { return (jshort)_flags; }
duke@435	200	jint as_int() { return _flags; }
duke@435	201
duke@435	202	// Printing/debugging
duke@435	203	void print_on(outputStream* st) const PRODUCT_RETURN;
duke@435	204	};