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

src/share/vm/oops/typeArrayOop.hpp@ce8f6bb717c9 (annotated)

src/share/vm/oops/typeArrayOop.hpp

Tue, 29 Apr 2014 15:17:27 +0200

author

goetz

date

Tue, 29 Apr 2014 15:17:27 +0200

changeset 6911

ce8f6bb717c9

parent 6461

bdd155477289

child 7293

e4bd8244c085

permissions

-rw-r--r--

8042195: Introduce umbrella header orderAccess.inline.hpp.
Reviewed-by: dholmes, kvn, stefank, twisti

duke@435	1	/*
coleenp@4037	2	* Copyright (c) 1997, 2012, 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
stefank@2314	25	#ifndef SHARE_VM_OOPS_TYPEARRAYOOP_HPP
stefank@2314	26	#define SHARE_VM_OOPS_TYPEARRAYOOP_HPP
stefank@2314	27
stefank@2314	28	#include "oops/arrayOop.hpp"
stefank@2314	29	#include "oops/typeArrayKlass.hpp"
goetz@6911	30	#include "runtime/orderAccess.inline.hpp"
stefank@2314	31
duke@435	32	// A typeArrayOop is an array containing basic types (non oop elements).
duke@435	33	// It is used for arrays of {characters, singles, doubles, bytes, shorts, integers, longs}
duke@435	34	#include <limits.h>
duke@435	35
duke@435	36	class typeArrayOopDesc : public arrayOopDesc {
duke@435	37	protected:
duke@435	38	jchar* char_base() const { return (jchar*) base(T_CHAR); }
duke@435	39	jboolean* bool_base() const { return (jboolean*)base(T_BOOLEAN); }
duke@435	40	jbyte* byte_base() const { return (jbyte*) base(T_BYTE); }
duke@435	41	jint* int_base() const { return (jint*) base(T_INT); }
duke@435	42	jlong* long_base() const { return (jlong*) base(T_LONG); }
duke@435	43	jshort* short_base() const { return (jshort*) base(T_SHORT); }
duke@435	44	jfloat* float_base() const { return (jfloat*) base(T_FLOAT); }
duke@435	45	jdouble* double_base() const { return (jdouble*) base(T_DOUBLE); }
duke@435	46
coleenp@4142	47	friend class TypeArrayKlass;
duke@435	48
duke@435	49	public:
duke@435	50	jbyte* byte_at_addr(int which) const {
duke@435	51	assert(is_within_bounds(which), "index out of bounds");
duke@435	52	return &byte_base()[which];
duke@435	53	}
duke@435	54
duke@435	55	jboolean* bool_at_addr(int which) const {
duke@435	56	assert(is_within_bounds(which), "index out of bounds");
duke@435	57	return &bool_base()[which];
duke@435	58	}
duke@435	59
duke@435	60	jchar* char_at_addr(int which) const {
duke@435	61	assert(is_within_bounds(which), "index out of bounds");
duke@435	62	return &char_base()[which];
duke@435	63	}
duke@435	64
duke@435	65	jint* int_at_addr(int which) const {
duke@435	66	assert(is_within_bounds(which), "index out of bounds");
duke@435	67	return &int_base()[which];
duke@435	68	}
duke@435	69
duke@435	70	jshort* short_at_addr(int which) const {
duke@435	71	assert(is_within_bounds(which), "index out of bounds");
duke@435	72	return &short_base()[which];
duke@435	73	}
duke@435	74
duke@435	75	jushort* ushort_at_addr(int which) const { // for field descriptor arrays
duke@435	76	assert(is_within_bounds(which), "index out of bounds");
duke@435	77	return (jushort*) &short_base()[which];
duke@435	78	}
duke@435	79
duke@435	80	jlong* long_at_addr(int which) const {
duke@435	81	assert(is_within_bounds(which), "index out of bounds");
duke@435	82	return &long_base()[which];
duke@435	83	}
duke@435	84
duke@435	85	jfloat* float_at_addr(int which) const {
duke@435	86	assert(is_within_bounds(which), "index out of bounds");
duke@435	87	return &float_base()[which];
duke@435	88	}
duke@435	89
duke@435	90	jdouble* double_at_addr(int which) const {
duke@435	91	assert(is_within_bounds(which), "index out of bounds");
duke@435	92	return &double_base()[which];
duke@435	93	}
duke@435	94
duke@435	95	jbyte byte_at(int which) const { return *byte_at_addr(which); }
duke@435	96	void byte_at_put(int which, jbyte contents) { *byte_at_addr(which) = contents; }
duke@435	97
duke@435	98	jboolean bool_at(int which) const { return *bool_at_addr(which); }
duke@435	99	void bool_at_put(int which, jboolean contents) { *bool_at_addr(which) = contents; }
duke@435	100
duke@435	101	jchar char_at(int which) const { return *char_at_addr(which); }
duke@435	102	void char_at_put(int which, jchar contents) { *char_at_addr(which) = contents; }
duke@435	103
duke@435	104	jint int_at(int which) const { return *int_at_addr(which); }
duke@435	105	void int_at_put(int which, jint contents) { *int_at_addr(which) = contents; }
duke@435	106
duke@435	107	jshort short_at(int which) const { return *short_at_addr(which); }
duke@435	108	void short_at_put(int which, jshort contents) { *short_at_addr(which) = contents; }
duke@435	109
duke@435	110	jushort ushort_at(int which) const { return *ushort_at_addr(which); }
duke@435	111	void ushort_at_put(int which, jushort contents) { *ushort_at_addr(which) = contents; }
duke@435	112
duke@435	113	jlong long_at(int which) const { return *long_at_addr(which); }
duke@435	114	void long_at_put(int which, jlong contents) { *long_at_addr(which) = contents; }
duke@435	115
duke@435	116	jfloat float_at(int which) const { return *float_at_addr(which); }
duke@435	117	void float_at_put(int which, jfloat contents) { *float_at_addr(which) = contents; }
duke@435	118
duke@435	119	jdouble double_at(int which) const { return *double_at_addr(which); }
duke@435	120	void double_at_put(int which, jdouble contents) { *double_at_addr(which) = contents; }
duke@435	121
duke@435	122	jbyte byte_at_acquire(int which) const { return OrderAccess::load_acquire(byte_at_addr(which)); }
duke@435	123	void release_byte_at_put(int which, jbyte contents) { OrderAccess::release_store(byte_at_addr(which), contents); }
duke@435	124
coleenp@4037	125	// Java thinks metadata arrays are just arrays of either long or int, since
coleenp@4037	126	// there doesn't seem to be T_ADDRESS, so this is a bit of unfortunate
coleenp@4037	127	// casting
coleenp@4037	128	#ifdef _LP64
coleenp@4037	129	Metadata* metadata_at(int which) const {
coleenp@4037	130	return (Metadata*)*long_at_addr(which); }
coleenp@4037	131	void metadata_at_put(int which, Metadata* contents) {
coleenp@4037	132	*long_at_addr(which) = (long)contents;
coleenp@4037	133	}
coleenp@4037	134	#else
coleenp@4037	135	Metadata* metadata_at(int which) const {
coleenp@4037	136	return (Metadata*)*int_at_addr(which); }
coleenp@4037	137	void metadata_at_put(int which, Metadata* contents) {
coleenp@4037	138	*int_at_addr(which) = (int)contents;
coleenp@4037	139	}
coleenp@4037	140	#endif // _LP64
coleenp@4037	141
duke@435	142	// Sizing
duke@435	143
duke@435	144	// Returns the number of words necessary to hold an array of "len"
duke@435	145	// elements each of the given "byte_size".
duke@435	146	private:
duke@435	147	static int object_size(int lh, int length) {
duke@435	148	int instance_header_size = Klass::layout_helper_header_size(lh);
duke@435	149	int element_shift = Klass::layout_helper_log2_element_size(lh);
duke@435	150	DEBUG_ONLY(BasicType etype = Klass::layout_helper_element_type(lh));
duke@435	151	assert(length <= arrayOopDesc::max_array_length(etype), "no overflow");
duke@435	152
duke@435	153	julong size_in_bytes = length;
duke@435	154	size_in_bytes <<= element_shift;
duke@435	155	size_in_bytes += instance_header_size;
duke@435	156	julong size_in_words = ((size_in_bytes + (HeapWordSize-1)) >> LogHeapWordSize);
duke@435	157	assert(size_in_words <= (julong)max_jint, "no overflow");
duke@435	158
duke@435	159	return align_object_size((intptr_t)size_in_words);
duke@435	160	}
duke@435	161
duke@435	162	public:
duke@435	163	int object_size() {
coleenp@4142	164	TypeArrayKlass* tk = TypeArrayKlass::cast(klass());
duke@435	165	return object_size(tk->layout_helper(), length());
duke@435	166	}
duke@435	167	};
stefank@2314	168
stefank@2314	169	#endif // SHARE_VM_OOPS_TYPEARRAYOOP_HPP