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

src/share/vm/oops/objArrayOop.hpp@d1896d1dda3e (annotated)

src/share/vm/oops/objArrayOop.hpp

Sat, 30 Oct 2010 11:45:35 -0700

author

jrose

date

Sat, 30 Oct 2010 11:45:35 -0700

changeset 2265

d1896d1dda3e

parent 1907

c18cbe5936b8

child 2314

f95d63e2154a

permissions

-rw-r--r--

6981788: GC map generator sometimes picks up the wrong kind of instruction operand
Summary: Distinguish pool indexes from cache indexes in recently changed code.
Reviewed-by: never

duke@435	1	/*
trims@1907	2	* Copyright (c) 1997, 2009, Oracle and/or its affiliates. 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	*
trims@1907	19	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
trims@1907	20	* or visit www.oracle.com if you need additional information or have any
trims@1907	21	* questions.
duke@435	22	*
duke@435	23	*/
duke@435	24
duke@435	25	// An objArrayOop is an array containing oops.
duke@435	26	// Evaluating "String arg[10]" will create an objArrayOop.
duke@435	27
duke@435	28	class objArrayOopDesc : public arrayOopDesc {
coleenp@548	29	friend class objArrayKlass;
coleenp@548	30	friend class Runtime1;
coleenp@548	31	friend class psPromotionManager;
ysr@777	32	friend class CSMarkOopClosure;
ysr@777	33	friend class G1ParScanPartialArrayClosure;
coleenp@548	34
coleenp@548	35	template <class T> T* obj_at_addr(int index) const {
coleenp@548	36	assert(is_within_bounds(index), "index out of bounds");
coleenp@548	37	return &((T*)base())[index];
coleenp@548	38	}
coleenp@548	39
ysr@1526	40	private:
ysr@1526	41	// Give size of objArrayOop in HeapWords minus the header
ysr@1526	42	static int array_size(int length) {
ysr@1526	43	const int OopsPerHeapWord = HeapWordSize/heapOopSize;
ysr@1526	44	assert(OopsPerHeapWord >= 1 && (HeapWordSize % heapOopSize == 0),
ysr@1526	45	"Else the following (new) computation would be in error");
ysr@1526	46	#ifdef ASSERT
ysr@1526	47	// The old code is left in for sanity-checking; it'll
ysr@1526	48	// go away pretty soon. XXX
ysr@1526	49	// Without UseCompressedOops, this is simply:
ysr@1526	50	// oop->length() * HeapWordsPerOop;
ysr@1526	51	// With narrowOops, HeapWordsPerOop is 1/2 or equal 0 as an integer.
ysr@1526	52	// The oop elements are aligned up to wordSize
ysr@1526	53	const int HeapWordsPerOop = heapOopSize/HeapWordSize;
ysr@1526	54	int old_res;
ysr@1526	55	if (HeapWordsPerOop > 0) {
ysr@1526	56	old_res = length * HeapWordsPerOop;
ysr@1526	57	} else {
ysr@1526	58	old_res = align_size_up(length, OopsPerHeapWord)/OopsPerHeapWord;
ysr@1526	59	}
ysr@1526	60	#endif // ASSERT
ysr@1530	61	int res = ((uint)length + OopsPerHeapWord - 1)/OopsPerHeapWord;
ysr@1526	62	assert(res == old_res, "Inconsistency between old and new.");
ysr@1526	63	return res;
ysr@1526	64	}
ysr@1526	65
duke@435	66	public:
twisti@1330	67	// Returns the offset of the first element.
twisti@1330	68	static int base_offset_in_bytes() {
twisti@1330	69	return arrayOopDesc::base_offset_in_bytes(T_OBJECT);
twisti@1330	70	}
twisti@1330	71
coleenp@548	72	// base is the address following the header.
coleenp@548	73	HeapWord* base() const { return (HeapWord*) arrayOopDesc::base(T_OBJECT); }
coleenp@548	74
duke@435	75	// Accessing
coleenp@548	76	oop obj_at(int index) const {
coleenp@548	77	// With UseCompressedOops decode the narrow oop in the objArray to an
coleenp@548	78	// uncompressed oop. Otherwise this is simply a "*" operator.
coleenp@548	79	if (UseCompressedOops) {
coleenp@548	80	return load_decode_heap_oop(obj_at_addr<narrowOop>(index));
coleenp@548	81	} else {
coleenp@548	82	return load_decode_heap_oop(obj_at_addr<oop>(index));
coleenp@548	83	}
coleenp@548	84	}
duke@435	85
coleenp@548	86	void obj_at_put(int index, oop value) {
coleenp@548	87	if (UseCompressedOops) {
coleenp@548	88	oop_store(obj_at_addr<narrowOop>(index), value);
coleenp@548	89	} else {
coleenp@548	90	oop_store(obj_at_addr<oop>(index), value);
coleenp@548	91	}
coleenp@548	92	}
duke@435	93	// Sizing
coleenp@548	94	static int header_size() { return arrayOopDesc::header_size(T_OBJECT); }
coleenp@548	95	int object_size() { return object_size(length()); }
duke@435	96
coleenp@548	97	static int object_size(int length) {
coleenp@548	98	// This returns the object size in HeapWords.
ysr@1530	99	uint asz = array_size(length);
ysr@1530	100	uint osz = align_object_size(header_size() + asz);
ysr@1530	101	assert(osz >= asz, "no overflow");
ysr@1530	102	assert((int)osz > 0, "no overflow");
ysr@1530	103	return (int)osz;
duke@435	104	}
coleenp@548	105
coleenp@548	106	// special iterators for index ranges, returns size of object
coleenp@548	107	#define ObjArrayOop_OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
coleenp@548	108	int oop_iterate_range(OopClosureType* blk, int start, int end);
coleenp@548	109
coleenp@548	110	ALL_OOP_OOP_ITERATE_CLOSURES_1(ObjArrayOop_OOP_ITERATE_DECL)
ysr@777	111	ALL_OOP_OOP_ITERATE_CLOSURES_2(ObjArrayOop_OOP_ITERATE_DECL)
duke@435	112	};