truffle: src/share/vm/oops/oop.inline.hpp annotate

annotate src/share/vm/oops/oop.inline.hpp @ 14649:f6301b007a16

6498581: ThreadInterruptTest3 produces wrong output on Windows Summary: There is race condition between os::interrupt and os::is_interrupted on Windows. In JVM_Sleep(Thread.sleep), check if thread gets interrupted, it may see interrupted but not really interrupted so cause spurious waking up (early return from sleep). Fix by checking if interrupt event really gets set thus prevent false return. For intrinsic of _isInterrupted, on Windows, go fastpath only on bit not set. Reviewed-by: acorn, kvn Contributed-by: david.holmes@oracle.com, yumin.qi@oracle.com

author	minqi
date	Wed, 26 Feb 2014 15:20:41 -0800
parents	3205e78d8193
children	7f0e0366ec81 78bbf4d43a14

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
7982 10d5f25a7c67 8000968: NPG: UseCompressedKlassPointers asserts with ObjectAlignmentInBytes for > 32G CompressedOops hseigel parents: 6848 diff changeset	2 * Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
0 a61af66fc99e Initial load duke parents: diff changeset	3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
a61af66fc99e Initial load duke parents: diff changeset	4 *
a61af66fc99e Initial load duke parents: diff changeset	5 * This code is free software; you can redistribute it and/or modify it
a61af66fc99e Initial load duke parents: diff changeset	6 * under the terms of the GNU General Public License version 2 only, as
a61af66fc99e Initial load duke parents: diff changeset	7 * published by the Free Software Foundation.
a61af66fc99e Initial load duke parents: diff changeset	8 *
a61af66fc99e Initial load duke parents: diff changeset	9 * This code is distributed in the hope that it will be useful, but WITHOUT
a61af66fc99e Initial load duke parents: diff changeset	10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
a61af66fc99e Initial load duke parents: diff changeset	11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
a61af66fc99e Initial load duke parents: diff changeset	12 * version 2 for more details (a copy is included in the LICENSE file that
a61af66fc99e Initial load duke parents: diff changeset	13 * accompanied this code).
a61af66fc99e Initial load duke parents: diff changeset	14 *
a61af66fc99e Initial load duke parents: diff changeset	15 * You should have received a copy of the GNU General Public License version
a61af66fc99e Initial load duke parents: diff changeset	16 * 2 along with this work; if not, write to the Free Software Foundation,
a61af66fc99e Initial load duke parents: diff changeset	17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
a61af66fc99e Initial load duke parents: diff changeset	18 *
1552 c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 845 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 845 diff changeset	20 * or visit www.oracle.com if you need additional information or have any
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 845 diff changeset	21 * questions.
0 a61af66fc99e Initial load duke parents: diff changeset	22 *
a61af66fc99e Initial load duke parents: diff changeset	23 */
a61af66fc99e Initial load duke parents: diff changeset	24
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	25 #ifndef SHARE_VM_OOPS_OOP_INLINE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	26 #define SHARE_VM_OOPS_OOP_INLINE_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	28 #include "gc_implementation/shared/ageTable.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	29 #include "gc_implementation/shared/markSweep.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	30 #include "gc_interface/collectedHeap.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	31 #include "memory/barrierSet.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	32 #include "memory/cardTableModRefBS.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	33 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	34 #include "memory/generation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	35 #include "memory/specialized_oop_closures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	36 #include "oops/arrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	37 #include "oops/arrayOop.hpp"
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	38 #include "oops/klass.inline.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	39 #include "oops/markOop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	40 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	41 #include "runtime/atomic.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	42 #include "runtime/os.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6848 diff changeset	43 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	44 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	45 # include "bytes_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	46 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	47 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	48 # include "bytes_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	49 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	50 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	51 # include "bytes_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	52 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	53 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	54 # include "bytes_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	55 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	56 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	57 # include "bytes_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	58 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	59
0 a61af66fc99e Initial load duke parents: diff changeset	60 // Implementation of all inlined member functions defined in oop.hpp
a61af66fc99e Initial load duke parents: diff changeset	61 // We need a separate file to avoid circular references
a61af66fc99e Initial load duke parents: diff changeset	62
a61af66fc99e Initial load duke parents: diff changeset	63 inline void oopDesc::release_set_mark(markOop m) {
a61af66fc99e Initial load duke parents: diff changeset	64 OrderAccess::release_store_ptr(&_mark, m);
a61af66fc99e Initial load duke parents: diff changeset	65 }
a61af66fc99e Initial load duke parents: diff changeset	66
a61af66fc99e Initial load duke parents: diff changeset	67 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) {
a61af66fc99e Initial load duke parents: diff changeset	68 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark);
a61af66fc99e Initial load duke parents: diff changeset	69 }
a61af66fc99e Initial load duke parents: diff changeset	70
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	71 inline Klass* oopDesc::klass() const {
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	72 if (UseCompressedClassPointers) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	73 return Klass::decode_klass_not_null(_metadata._compressed_klass);
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	74 } else {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	75 return _metadata._klass;
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	76 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	77 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	78
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	79 inline Klass* oopDesc::klass_or_null() const volatile {
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	80 // can be NULL in CMS
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	81 if (UseCompressedClassPointers) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	82 return Klass::decode_klass(_metadata._compressed_klass);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	83 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	84 return _metadata._klass;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	85 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	86 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	87
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	88 inline int oopDesc::klass_gap_offset_in_bytes() {
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	89 assert(UseCompressedClassPointers, "only applicable to compressed klass pointers");
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	90 return oopDesc::klass_offset_in_bytes() + sizeof(narrowKlass);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	91 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	92
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	93 inline Klass** oopDesc::klass_addr() {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	94 // Only used internally and with CMS and will not work with
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	95 // UseCompressedOops
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	96 assert(!UseCompressedClassPointers, "only supported with uncompressed klass pointers");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	97 return (Klass**) &_metadata._klass;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	98 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	99
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	100 inline narrowKlass* oopDesc::compressed_klass_addr() {
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	101 assert(UseCompressedClassPointers, "only called by compressed klass pointers");
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	102 return &_metadata._compressed_klass;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	103 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	104
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	105 inline void oopDesc::set_klass(Klass* k) {
0 a61af66fc99e Initial load duke parents: diff changeset	106 // since klasses are promoted no store check is needed
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	107 assert(Universe::is_bootstrapping() \|\| k != NULL, "must be a real Klass*");
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	108 assert(Universe::is_bootstrapping() \|\| k->is_klass(), "not a Klass*");
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	109 if (UseCompressedClassPointers) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	110 *compressed_klass_addr() = Klass::encode_klass_not_null(k);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	111 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	112 *klass_addr() = k;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	113 }
0 a61af66fc99e Initial load duke parents: diff changeset	114 }
a61af66fc99e Initial load duke parents: diff changeset	115
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	116 inline int oopDesc::klass_gap() const {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	117 return (int)(((intptr_t)this) + klass_gap_offset_in_bytes());
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	118 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	119
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	120 inline void oopDesc::set_klass_gap(int v) {
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	121 if (UseCompressedClassPointers) {
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	122 (int)(((intptr_t)this) + klass_gap_offset_in_bytes()) = v;
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	123 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	124 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	125
0 a61af66fc99e Initial load duke parents: diff changeset	126 inline void oopDesc::set_klass_to_list_ptr(oop k) {
a61af66fc99e Initial load duke parents: diff changeset	127 // This is only to be used during GC, for from-space objects, so no
a61af66fc99e Initial load duke parents: diff changeset	128 // barrier is needed.
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	129 if (UseCompressedClassPointers) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	130 _metadata._compressed_klass = (narrowKlass)encode_heap_oop(k); // may be null (parnew overflow handling)
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	131 } else {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	132 _metadata._klass = (Klass*)(address)k;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	133 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	134 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	135
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	136 inline oop oopDesc::list_ptr_from_klass() {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	137 // This is only to be used during GC, for from-space objects.
12226 7944aba7ba41 8015107: NPG: Use consistent naming for metaspace concepts ehelin parents: 12056 diff changeset	138 if (UseCompressedClassPointers) {
12056 740e263c80c6 8003424: Enable Class Data Sharing for CompressedOops hseigel parents: 8003 diff changeset	139 return decode_heap_oop((narrowOop)_metadata._compressed_klass);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	140 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	141 // Special case for GC
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	142 return (oop)(address)_metadata._klass;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	143 }
0 a61af66fc99e Initial load duke parents: diff changeset	144 }
a61af66fc99e Initial load duke parents: diff changeset	145
a61af66fc99e Initial load duke parents: diff changeset	146 inline void oopDesc::init_mark() { set_mark(markOopDesc::prototype_for_object(this)); }
a61af66fc99e Initial load duke parents: diff changeset	147
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	148 inline bool oopDesc::is_a(Klass* k) const { return klass()->is_subtype_of(k); }
0 a61af66fc99e Initial load duke parents: diff changeset	149
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	150 inline bool oopDesc::is_instance() const { return klass()->oop_is_instance(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	151 inline bool oopDesc::is_instanceMirror() const { return klass()->oop_is_instanceMirror(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	152 inline bool oopDesc::is_instanceRef() const { return klass()->oop_is_instanceRef(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	153 inline bool oopDesc::is_array() const { return klass()->oop_is_array(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	154 inline bool oopDesc::is_objArray() const { return klass()->oop_is_objArray(); }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	155 inline bool oopDesc::is_typeArray() const { return klass()->oop_is_typeArray(); }
0 a61af66fc99e Initial load duke parents: diff changeset	156
a61af66fc99e Initial load duke parents: diff changeset	157 inline void* oopDesc::field_base(int offset) const { return (void)&((char)this)[offset]; }
a61af66fc99e Initial load duke parents: diff changeset	158
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	159 template <class T> inline T* oopDesc::obj_field_addr(int offset) const { return (T*)field_base(offset); }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	160 inline Metadata oopDesc::metadata_field_addr(int offset) const { return (Metadata)field_base(offset); }
0 a61af66fc99e Initial load duke parents: diff changeset	161 inline jbyte* oopDesc::byte_field_addr(int offset) const { return (jbyte*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	162 inline jchar* oopDesc::char_field_addr(int offset) const { return (jchar*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	163 inline jboolean* oopDesc::bool_field_addr(int offset) const { return (jboolean*)field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	164 inline jint* oopDesc::int_field_addr(int offset) const { return (jint*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	165 inline jshort* oopDesc::short_field_addr(int offset) const { return (jshort*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	166 inline jlong* oopDesc::long_field_addr(int offset) const { return (jlong*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	167 inline jfloat* oopDesc::float_field_addr(int offset) const { return (jfloat*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	168 inline jdouble* oopDesc::double_field_addr(int offset) const { return (jdouble*) field_base(offset); }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	169 inline address* oopDesc::address_field_addr(int offset) const { return (address*) field_base(offset); }
0 a61af66fc99e Initial load duke parents: diff changeset	170
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	171
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	172 // Functions for getting and setting oops within instance objects.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	173 // If the oops are compressed, the type passed to these overloaded functions
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	174 // is narrowOop. All functions are overloaded so they can be called by
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	175 // template functions without conditionals (the compiler instantiates via
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	176 // the right type and inlines the appopriate code).
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	177
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	178 inline bool oopDesc::is_null(oop obj) { return obj == NULL; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	179 inline bool oopDesc::is_null(narrowOop obj) { return obj == 0; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	180
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	181 // Algorithm for encoding and decoding oops from 64 bit pointers to 32 bit
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	182 // offset from the heap base. Saving the check for null can save instructions
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	183 // in inner GC loops so these are separated.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	184
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	185 inline bool check_obj_alignment(oop obj) {
12316 190899198332 7195622: CheckUnhandledOops has limited usefulness now hseigel parents: 12226 diff changeset	186 return cast_from_oop<intptr_t>(obj) % MinObjAlignmentInBytes == 0;
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	187 }
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	188
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	189 inline narrowOop oopDesc::encode_heap_oop_not_null(oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	190 assert(!is_null(v), "oop value can never be zero");
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	191 assert(check_obj_alignment(v), "Address not aligned");
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	192 assert(Universe::heap()->is_in_reserved(v), "Address not in heap");
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	193 address base = Universe::narrow_oop_base();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	194 int shift = Universe::narrow_oop_shift();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	195 uint64_t pd = (uint64_t)(pointer_delta((void)v, (void)base, 1));
135 b7268662a986 6689523: max heap calculation for compressed oops is off by MaxPermSize coleenp parents: 133 diff changeset	196 assert(OopEncodingHeapMax > pd, "change encoding max if new encoding");
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	197 uint64_t result = pd >> shift;
135 b7268662a986 6689523: max heap calculation for compressed oops is off by MaxPermSize coleenp parents: 133 diff changeset	198 assert((result & CONST64(0xffffffff00000000)) == 0, "narrow oop overflow");
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	199 assert(decode_heap_oop(result) == v, "reversibility");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	200 return (narrowOop)result;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	201 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	202
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	203 inline narrowOop oopDesc::encode_heap_oop(oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	204 return (is_null(v)) ? (narrowOop)0 : encode_heap_oop_not_null(v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	205 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	206
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	207 inline oop oopDesc::decode_heap_oop_not_null(narrowOop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	208 assert(!is_null(v), "narrow oop value can never be zero");
642 660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	209 address base = Universe::narrow_oop_base();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	210 int shift = Universe::narrow_oop_shift();
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	211 oop result = (oop)(void*)((uintptr_t)base + ((uintptr_t)v << shift));
1846 d55217dc206f 6829194: JSR 292 needs to support compressed oops twisti parents: 1579 diff changeset	212 assert(check_obj_alignment(result), err_msg("address not aligned: " PTR_FORMAT, (void*) result));
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	213 return result;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	214 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	215
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	216 inline oop oopDesc::decode_heap_oop(narrowOop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	217 return is_null(v) ? (oop)NULL : decode_heap_oop_not_null(v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	218 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	219
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	220 inline oop oopDesc::decode_heap_oop_not_null(oop v) { return v; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	221 inline oop oopDesc::decode_heap_oop(oop v) { return v; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	222
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	223 // Load an oop out of the Java heap as is without decoding.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	224 // Called by GC to check for null before decoding.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	225 inline oop oopDesc::load_heap_oop(oop* p) { return *p; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	226 inline narrowOop oopDesc::load_heap_oop(narrowOop* p) { return *p; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	227
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	228 // Load and decode an oop out of the Java heap into a wide oop.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	229 inline oop oopDesc::load_decode_heap_oop_not_null(oop* p) { return *p; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	230 inline oop oopDesc::load_decode_heap_oop_not_null(narrowOop* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	231 return decode_heap_oop_not_null(*p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	232 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	233
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	234 // Load and decode an oop out of the heap accepting null
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	235 inline oop oopDesc::load_decode_heap_oop(oop* p) { return *p; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	236 inline oop oopDesc::load_decode_heap_oop(narrowOop* p) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	237 return decode_heap_oop(*p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	238 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	239
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	240 // Store already encoded heap oop into the heap.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	241 inline void oopDesc::store_heap_oop(oop* p, oop v) { *p = v; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	242 inline void oopDesc::store_heap_oop(narrowOop* p, narrowOop v) { *p = v; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	243
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	244 // Encode and store a heap oop.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	245 inline void oopDesc::encode_store_heap_oop_not_null(narrowOop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	246 *p = encode_heap_oop_not_null(v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	247 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	248 inline void oopDesc::encode_store_heap_oop_not_null(oop* p, oop v) { *p = v; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	249
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	250 // Encode and store a heap oop allowing for null.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	251 inline void oopDesc::encode_store_heap_oop(narrowOop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	252 *p = encode_heap_oop(v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	253 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	254 inline void oopDesc::encode_store_heap_oop(oop* p, oop v) { *p = v; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	255
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	256 // Store heap oop as is for volatile fields.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	257 inline void oopDesc::release_store_heap_oop(volatile oop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	258 OrderAccess::release_store_ptr(p, v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	259 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	260 inline void oopDesc::release_store_heap_oop(volatile narrowOop* p,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	261 narrowOop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	262 OrderAccess::release_store(p, v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	263 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	264
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	265 inline void oopDesc::release_encode_store_heap_oop_not_null(
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	266 volatile narrowOop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	267 // heap oop is not pointer sized.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	268 OrderAccess::release_store(p, encode_heap_oop_not_null(v));
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	269 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	270
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	271 inline void oopDesc::release_encode_store_heap_oop_not_null(
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	272 volatile oop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	273 OrderAccess::release_store_ptr(p, v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	274 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	275
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	276 inline void oopDesc::release_encode_store_heap_oop(volatile oop* p,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	277 oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	278 OrderAccess::release_store_ptr(p, v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	279 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	280 inline void oopDesc::release_encode_store_heap_oop(
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	281 volatile narrowOop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	282 OrderAccess::release_store(p, encode_heap_oop(v));
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	283 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	284
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	285
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	286 // These functions are only used to exchange oop fields in instances,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	287 // not headers.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	288 inline oop oopDesc::atomic_exchange_oop(oop exchange_value, volatile HeapWord *dest) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	289 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	290 // encode exchange value from oop to T
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	291 narrowOop val = encode_heap_oop(exchange_value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	292 narrowOop old = (narrowOop)Atomic::xchg(val, (narrowOop*)dest);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	293 // decode old from T to oop
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	294 return decode_heap_oop(old);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	295 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	296 return (oop)Atomic::xchg_ptr(exchange_value, (oop*)dest);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	297 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	298 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	299
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	300 // In order to put or get a field out of an instance, must first check
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	301 // if the field has been compressed and uncompress it.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	302 inline oop oopDesc::obj_field(int offset) const {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	303 return UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	304 load_decode_heap_oop(obj_field_addr<narrowOop>(offset)) :
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	305 load_decode_heap_oop(obj_field_addr<oop>(offset));
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	306 }
3932 b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	307 inline volatile oop oopDesc::obj_field_volatile(int offset) const {
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	308 volatile oop value = obj_field(offset);
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	309 OrderAccess::acquire();
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	310 return value;
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	311 }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	312 inline void oopDesc::obj_field_put(int offset, oop value) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	313 UseCompressedOops ? oop_store(obj_field_addr<narrowOop>(offset), value) :
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	314 oop_store(obj_field_addr<oop>(offset), value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	315 }
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	316
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	317 inline Metadata* oopDesc::metadata_field(int offset) const {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	318 return *metadata_field_addr(offset);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	319 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	320
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	321 inline void oopDesc::metadata_field_put(int offset, Metadata* value) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	322 *metadata_field_addr(offset) = value;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	323 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	324
3932 b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	325 inline void oopDesc::obj_field_put_raw(int offset, oop value) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	326 UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	327 encode_store_heap_oop(obj_field_addr<narrowOop>(offset), value) :
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	328 encode_store_heap_oop(obj_field_addr<oop>(offset), value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	329 }
3932 b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	330 inline void oopDesc::obj_field_put_volatile(int offset, oop value) {
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	331 OrderAccess::release();
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	332 obj_field_put(offset, value);
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	333 OrderAccess::fence();
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	334 }
0 a61af66fc99e Initial load duke parents: diff changeset	335
a61af66fc99e Initial load duke parents: diff changeset	336 inline jbyte oopDesc::byte_field(int offset) const { return (jbyte) *byte_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	337 inline void oopDesc::byte_field_put(int offset, jbyte contents) { *byte_field_addr(offset) = (jint) contents; }
a61af66fc99e Initial load duke parents: diff changeset	338
a61af66fc99e Initial load duke parents: diff changeset	339 inline jboolean oopDesc::bool_field(int offset) const { return (jboolean) *bool_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	340 inline void oopDesc::bool_field_put(int offset, jboolean contents) { *bool_field_addr(offset) = (jint) contents; }
a61af66fc99e Initial load duke parents: diff changeset	341
a61af66fc99e Initial load duke parents: diff changeset	342 inline jchar oopDesc::char_field(int offset) const { return (jchar) *char_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	343 inline void oopDesc::char_field_put(int offset, jchar contents) { *char_field_addr(offset) = (jint) contents; }
a61af66fc99e Initial load duke parents: diff changeset	344
a61af66fc99e Initial load duke parents: diff changeset	345 inline jint oopDesc::int_field(int offset) const { return *int_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	346 inline void oopDesc::int_field_put(int offset, jint contents) { *int_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	347
a61af66fc99e Initial load duke parents: diff changeset	348 inline jshort oopDesc::short_field(int offset) const { return (jshort) *short_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	349 inline void oopDesc::short_field_put(int offset, jshort contents) { *short_field_addr(offset) = (jint) contents;}
a61af66fc99e Initial load duke parents: diff changeset	350
a61af66fc99e Initial load duke parents: diff changeset	351 inline jlong oopDesc::long_field(int offset) const { return *long_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	352 inline void oopDesc::long_field_put(int offset, jlong contents) { *long_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	353
a61af66fc99e Initial load duke parents: diff changeset	354 inline jfloat oopDesc::float_field(int offset) const { return *float_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	355 inline void oopDesc::float_field_put(int offset, jfloat contents) { *float_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	356
a61af66fc99e Initial load duke parents: diff changeset	357 inline jdouble oopDesc::double_field(int offset) const { return *double_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	358 inline void oopDesc::double_field_put(int offset, jdouble contents) { *double_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	359
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	360 inline address oopDesc::address_field(int offset) const { return *address_field_addr(offset); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	361 inline void oopDesc::address_field_put(int offset, address contents) { *address_field_addr(offset) = contents; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	362
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	363 inline oop oopDesc::obj_field_acquire(int offset) const {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	364 return UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	365 decode_heap_oop((narrowOop)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	366 OrderAccess::load_acquire(obj_field_addr<narrowOop>(offset)))
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	367 : decode_heap_oop((oop)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	368 OrderAccess::load_ptr_acquire(obj_field_addr<oop>(offset)));
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	369 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	370 inline void oopDesc::release_obj_field_put(int offset, oop value) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	371 UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	372 oop_store((volatile narrowOop*)obj_field_addr<narrowOop>(offset), value) :
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	373 oop_store((volatile oop*) obj_field_addr<oop>(offset), value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	374 }
0 a61af66fc99e Initial load duke parents: diff changeset	375
a61af66fc99e Initial load duke parents: diff changeset	376 inline jbyte oopDesc::byte_field_acquire(int offset) const { return OrderAccess::load_acquire(byte_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	377 inline void oopDesc::release_byte_field_put(int offset, jbyte contents) { OrderAccess::release_store(byte_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	378
a61af66fc99e Initial load duke parents: diff changeset	379 inline jboolean oopDesc::bool_field_acquire(int offset) const { return OrderAccess::load_acquire(bool_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	380 inline void oopDesc::release_bool_field_put(int offset, jboolean contents) { OrderAccess::release_store(bool_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	381
a61af66fc99e Initial load duke parents: diff changeset	382 inline jchar oopDesc::char_field_acquire(int offset) const { return OrderAccess::load_acquire(char_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	383 inline void oopDesc::release_char_field_put(int offset, jchar contents) { OrderAccess::release_store(char_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	384
a61af66fc99e Initial load duke parents: diff changeset	385 inline jint oopDesc::int_field_acquire(int offset) const { return OrderAccess::load_acquire(int_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	386 inline void oopDesc::release_int_field_put(int offset, jint contents) { OrderAccess::release_store(int_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	387
a61af66fc99e Initial load duke parents: diff changeset	388 inline jshort oopDesc::short_field_acquire(int offset) const { return (jshort)OrderAccess::load_acquire(short_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	389 inline void oopDesc::release_short_field_put(int offset, jshort contents) { OrderAccess::release_store(short_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	390
a61af66fc99e Initial load duke parents: diff changeset	391 inline jlong oopDesc::long_field_acquire(int offset) const { return OrderAccess::load_acquire(long_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	392 inline void oopDesc::release_long_field_put(int offset, jlong contents) { OrderAccess::release_store(long_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	393
a61af66fc99e Initial load duke parents: diff changeset	394 inline jfloat oopDesc::float_field_acquire(int offset) const { return OrderAccess::load_acquire(float_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	395 inline void oopDesc::release_float_field_put(int offset, jfloat contents) { OrderAccess::release_store(float_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	396
a61af66fc99e Initial load duke parents: diff changeset	397 inline jdouble oopDesc::double_field_acquire(int offset) const { return OrderAccess::load_acquire(double_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	398 inline void oopDesc::release_double_field_put(int offset, jdouble contents) { OrderAccess::release_store(double_field_addr(offset), contents); }
a61af66fc99e Initial load duke parents: diff changeset	399
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 647 diff changeset	400 inline address oopDesc::address_field_acquire(int offset) const { return (address) OrderAccess::load_ptr_acquire(address_field_addr(offset)); }
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 647 diff changeset	401 inline void oopDesc::release_address_field_put(int offset, address contents) { OrderAccess::release_store_ptr(address_field_addr(offset), contents); }
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 647 diff changeset	402
0 a61af66fc99e Initial load duke parents: diff changeset	403 inline int oopDesc::size_given_klass(Klass* klass) {
a61af66fc99e Initial load duke parents: diff changeset	404 int lh = klass->layout_helper();
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	405 int s;
0 a61af66fc99e Initial load duke parents: diff changeset	406
a61af66fc99e Initial load duke parents: diff changeset	407 // lh is now a value computed at class initialization that may hint
a61af66fc99e Initial load duke parents: diff changeset	408 // at the size. For instances, this is positive and equal to the
a61af66fc99e Initial load duke parents: diff changeset	409 // size. For arrays, this is negative and provides log2 of the
a61af66fc99e Initial load duke parents: diff changeset	410 // array element size. For other oops, it is zero and thus requires
a61af66fc99e Initial load duke parents: diff changeset	411 // a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	412 //
a61af66fc99e Initial load duke parents: diff changeset	413 // We go to all this trouble because the size computation is at the
a61af66fc99e Initial load duke parents: diff changeset	414 // heart of phase 2 of mark-compaction, and called for every object,
a61af66fc99e Initial load duke parents: diff changeset	415 // alive or dead. So the speed here is equal in importance to the
a61af66fc99e Initial load duke parents: diff changeset	416 // speed of allocation.
a61af66fc99e Initial load duke parents: diff changeset	417
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	418 if (lh > Klass::_lh_neutral_value) {
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	419 if (!Klass::layout_helper_needs_slow_path(lh)) {
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	420 s = lh >> LogHeapWordSize; // deliver size scaled by wordSize
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	421 } else {
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	422 s = klass->oop_size(this);
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	423 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	424 } else if (lh <= Klass::_lh_neutral_value) {
0 a61af66fc99e Initial load duke parents: diff changeset	425 // The most common case is instances; fall through if so.
a61af66fc99e Initial load duke parents: diff changeset	426 if (lh < Klass::_lh_neutral_value) {
a61af66fc99e Initial load duke parents: diff changeset	427 // Second most common case is arrays. We have to fetch the
a61af66fc99e Initial load duke parents: diff changeset	428 // length of the array, shift (multiply) it appropriately,
a61af66fc99e Initial load duke parents: diff changeset	429 // up to wordSize, add the header, and align to object size.
a61af66fc99e Initial load duke parents: diff changeset	430 size_t size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	431 #ifdef _M_IA64
a61af66fc99e Initial load duke parents: diff changeset	432 // The Windows Itanium Aug 2002 SDK hoists this load above
a61af66fc99e Initial load duke parents: diff changeset	433 // the check for s < 0. An oop at the end of the heap will
a61af66fc99e Initial load duke parents: diff changeset	434 // cause an access violation if this load is performed on a non
a61af66fc99e Initial load duke parents: diff changeset	435 // array oop. Making the reference volatile prohibits this.
a61af66fc99e Initial load duke parents: diff changeset	436 // (%%% please explain by what magic the length is actually fetched!)
a61af66fc99e Initial load duke parents: diff changeset	437 volatile int *array_length;
a61af66fc99e Initial load duke parents: diff changeset	438 array_length = (volatile int *)( (intptr_t)this +
a61af66fc99e Initial load duke parents: diff changeset	439 arrayOopDesc::length_offset_in_bytes() );
a61af66fc99e Initial load duke parents: diff changeset	440 assert(array_length > 0, "Integer arithmetic problem somewhere");
a61af66fc99e Initial load duke parents: diff changeset	441 // Put into size_t to avoid overflow.
a61af66fc99e Initial load duke parents: diff changeset	442 size_in_bytes = (size_t) array_length;
a61af66fc99e Initial load duke parents: diff changeset	443 size_in_bytes = size_in_bytes << Klass::layout_helper_log2_element_size(lh);
a61af66fc99e Initial load duke parents: diff changeset	444 #else
a61af66fc99e Initial load duke parents: diff changeset	445 size_t array_length = (size_t) ((arrayOop)this)->length();
a61af66fc99e Initial load duke parents: diff changeset	446 size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh);
a61af66fc99e Initial load duke parents: diff changeset	447 #endif
a61af66fc99e Initial load duke parents: diff changeset	448 size_in_bytes += Klass::layout_helper_header_size(lh);
a61af66fc99e Initial load duke parents: diff changeset	449
a61af66fc99e Initial load duke parents: diff changeset	450 // This code could be simplified, but by keeping array_header_in_bytes
a61af66fc99e Initial load duke parents: diff changeset	451 // in units of bytes and doing it this way we can round up just once,
a61af66fc99e Initial load duke parents: diff changeset	452 // skipping the intermediate round to HeapWordSize. Cast the result
a61af66fc99e Initial load duke parents: diff changeset	453 // of round_to to size_t to guarantee unsigned division == right shift.
a61af66fc99e Initial load duke parents: diff changeset	454 s = (int)((size_t)round_to(size_in_bytes, MinObjAlignmentInBytes) /
a61af66fc99e Initial load duke parents: diff changeset	455 HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	456
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	457 // UseParNewGC, UseParallelGC and UseG1GC can change the length field
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	458 // of an "old copy" of an object array in the young gen so it indicates
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	459 // the grey portion of an already copied array. This will cause the first
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	460 // disjunct below to fail if the two comparands are computed across such
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	461 // a concurrent change.
0 a61af66fc99e Initial load duke parents: diff changeset	462 // UseParNewGC also runs with promotion labs (which look like int
a61af66fc99e Initial load duke parents: diff changeset	463 // filler arrays) which are subject to changing their declared size
a61af66fc99e Initial load duke parents: diff changeset	464 // when finally retiring a PLAB; this also can cause the first disjunct
a61af66fc99e Initial load duke parents: diff changeset	465 // to fail for another worker thread that is concurrently walking the block
a61af66fc99e Initial load duke parents: diff changeset	466 // offset table. Both these invariant failures are benign for their
a61af66fc99e Initial load duke parents: diff changeset	467 // current uses; we relax the assertion checking to cover these two cases below:
a61af66fc99e Initial load duke parents: diff changeset	468 // is_objArray() && is_forwarded() // covers first scenario above
a61af66fc99e Initial load duke parents: diff changeset	469 // \|\| is_typeArray() // covers second scenario above
a61af66fc99e Initial load duke parents: diff changeset	470 // If and when UseParallelGC uses the same obj array oop stealing/chunking
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	471 // technique, we will need to suitably modify the assertion.
0 a61af66fc99e Initial load duke parents: diff changeset	472 assert((s == klass->oop_size(this)) \|\|
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	473 (Universe::heap()->is_gc_active() &&
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	474 ((is_typeArray() && UseParNewGC) \|\|
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	475 (is_objArray() && is_forwarded() && (UseParNewGC \|\| UseParallelGC \|\| UseG1GC)))),
0 a61af66fc99e Initial load duke parents: diff changeset	476 "wrong array object size");
a61af66fc99e Initial load duke parents: diff changeset	477 } else {
a61af66fc99e Initial load duke parents: diff changeset	478 // Must be zero, so bite the bullet and take the virtual call.
a61af66fc99e Initial load duke parents: diff changeset	479 s = klass->oop_size(this);
a61af66fc99e Initial load duke parents: diff changeset	480 }
a61af66fc99e Initial load duke parents: diff changeset	481 }
a61af66fc99e Initial load duke parents: diff changeset	482
a61af66fc99e Initial load duke parents: diff changeset	483 assert(s % MinObjAlignment == 0, "alignment check");
a61af66fc99e Initial load duke parents: diff changeset	484 assert(s > 0, "Bad size calculated");
a61af66fc99e Initial load duke parents: diff changeset	485 return s;
a61af66fc99e Initial load duke parents: diff changeset	486 }
a61af66fc99e Initial load duke parents: diff changeset	487
a61af66fc99e Initial load duke parents: diff changeset	488
a61af66fc99e Initial load duke parents: diff changeset	489 inline int oopDesc::size() {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	490 return size_given_klass(klass());
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 454 diff changeset	491 }
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 454 diff changeset	492
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	493 inline void update_barrier_set(void* p, oop v, bool release = false) {
0 a61af66fc99e Initial load duke parents: diff changeset	494 assert(oopDesc::bs() != NULL, "Uninitialized bs in oop!");
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	495 oopDesc::bs()->write_ref_field(p, v, release);
0 a61af66fc99e Initial load duke parents: diff changeset	496 }
a61af66fc99e Initial load duke parents: diff changeset	497
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	498 template <class T> inline void update_barrier_set_pre(T* p, oop v) {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	499 oopDesc::bs()->write_ref_field_pre(p, v);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	500 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	501
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	502 template <class T> inline void oop_store(T* p, oop v) {
0 a61af66fc99e Initial load duke parents: diff changeset	503 if (always_do_update_barrier) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	504 oop_store((volatile T*)p, v);
0 a61af66fc99e Initial load duke parents: diff changeset	505 } else {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	506 update_barrier_set_pre(p, v);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	507 oopDesc::encode_store_heap_oop(p, v);
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	508 // always_do_update_barrier == false =>
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	509 // Either we are at a safepoint (in GC) or CMS is not used. In both
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	510 // cases it's unnecessary to mark the card as dirty with release sematics.
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	511 update_barrier_set((void)p, v, false / release */); // cast away type
0 a61af66fc99e Initial load duke parents: diff changeset	512 }
a61af66fc99e Initial load duke parents: diff changeset	513 }
a61af66fc99e Initial load duke parents: diff changeset	514
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	515 template <class T> inline void oop_store(volatile T* p, oop v) {
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	516 update_barrier_set_pre((T*)p, v); // cast away volatile
0 a61af66fc99e Initial load duke parents: diff changeset	517 // Used by release_obj_field_put, so use release_store_ptr.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	518 oopDesc::release_encode_store_heap_oop(p, v);
14443 3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	519 // When using CMS we must mark the card corresponding to p as dirty
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	520 // with release sematics to prevent that CMS sees the dirty card but
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	521 // not the new value v at p due to reordering of the two
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	522 // stores. Note that CMS has a concurrent precleaning phase, where
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	523 // it reads the card table while the Java threads are running.
3205e78d8193 8029396: PPC64 (part 212): Several memory ordering fixes in C-code. goetz parents: 12316 diff changeset	524 update_barrier_set((void)p, v, true / release */); // cast away type
0 a61af66fc99e Initial load duke parents: diff changeset	525 }
a61af66fc99e Initial load duke parents: diff changeset	526
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	527 // Should replace *addr = oop assignments where addr type depends on UseCompressedOops
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	528 // (without having to remember the function name this calls).
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	529 inline void oop_store_raw(HeapWord* addr, oop value) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	530 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	531 oopDesc::encode_store_heap_oop((narrowOop*)addr, value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	532 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	533 oopDesc::encode_store_heap_oop((oop*)addr, value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	534 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	535 }
0 a61af66fc99e Initial load duke parents: diff changeset	536
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	537 inline oop oopDesc::atomic_compare_exchange_oop(oop exchange_value,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	538 volatile HeapWord *dest,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	539 oop compare_value,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	540 bool prebarrier) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	541 if (UseCompressedOops) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	542 if (prebarrier) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	543 update_barrier_set_pre((narrowOop*)dest, exchange_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	544 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	545 // encode exchange and compare value from oop to T
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	546 narrowOop val = encode_heap_oop(exchange_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	547 narrowOop cmp = encode_heap_oop(compare_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	548
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	549 narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	550 // decode old from T to oop
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	551 return decode_heap_oop(old);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	552 } else {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	553 if (prebarrier) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	554 update_barrier_set_pre((oop*)dest, exchange_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	555 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	556 return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	557 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	558 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	559
0 a61af66fc99e Initial load duke parents: diff changeset	560 // Used only for markSweep, scavenging
a61af66fc99e Initial load duke parents: diff changeset	561 inline bool oopDesc::is_gc_marked() const {
a61af66fc99e Initial load duke parents: diff changeset	562 return mark()->is_marked();
a61af66fc99e Initial load duke parents: diff changeset	563 }
a61af66fc99e Initial load duke parents: diff changeset	564
a61af66fc99e Initial load duke parents: diff changeset	565 inline bool oopDesc::is_locked() const {
a61af66fc99e Initial load duke parents: diff changeset	566 return mark()->is_locked();
a61af66fc99e Initial load duke parents: diff changeset	567 }
a61af66fc99e Initial load duke parents: diff changeset	568
a61af66fc99e Initial load duke parents: diff changeset	569 inline bool oopDesc::is_unlocked() const {
a61af66fc99e Initial load duke parents: diff changeset	570 return mark()->is_unlocked();
a61af66fc99e Initial load duke parents: diff changeset	571 }
a61af66fc99e Initial load duke parents: diff changeset	572
a61af66fc99e Initial load duke parents: diff changeset	573 inline bool oopDesc::has_bias_pattern() const {
a61af66fc99e Initial load duke parents: diff changeset	574 return mark()->has_bias_pattern();
a61af66fc99e Initial load duke parents: diff changeset	575 }
a61af66fc99e Initial load duke parents: diff changeset	576
a61af66fc99e Initial load duke parents: diff changeset	577
a61af66fc99e Initial load duke parents: diff changeset	578 // used only for asserts
a61af66fc99e Initial load duke parents: diff changeset	579 inline bool oopDesc::is_oop(bool ignore_mark_word) const {
a61af66fc99e Initial load duke parents: diff changeset	580 oop obj = (oop) this;
a61af66fc99e Initial load duke parents: diff changeset	581 if (!check_obj_alignment(obj)) return false;
a61af66fc99e Initial load duke parents: diff changeset	582 if (!Universe::heap()->is_in_reserved(obj)) return false;
a61af66fc99e Initial load duke parents: diff changeset	583 // obj is aligned and accessible in heap
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	584 if (Universe::heap()->is_in_reserved(obj->klass_or_null())) return false;
0 a61af66fc99e Initial load duke parents: diff changeset	585
a61af66fc99e Initial load duke parents: diff changeset	586 // Header verification: the mark is typically non-NULL. If we're
a61af66fc99e Initial load duke parents: diff changeset	587 // at a safepoint, it must not be null.
a61af66fc99e Initial load duke parents: diff changeset	588 // Outside of a safepoint, the header could be changing (for example,
a61af66fc99e Initial load duke parents: diff changeset	589 // another thread could be inflating a lock on this object).
a61af66fc99e Initial load duke parents: diff changeset	590 if (ignore_mark_word) {
a61af66fc99e Initial load duke parents: diff changeset	591 return true;
a61af66fc99e Initial load duke parents: diff changeset	592 }
a61af66fc99e Initial load duke parents: diff changeset	593 if (mark() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	594 return true;
a61af66fc99e Initial load duke parents: diff changeset	595 }
a61af66fc99e Initial load duke parents: diff changeset	596 return !SafepointSynchronize::is_at_safepoint();
a61af66fc99e Initial load duke parents: diff changeset	597 }
a61af66fc99e Initial load duke parents: diff changeset	598
a61af66fc99e Initial load duke parents: diff changeset	599
a61af66fc99e Initial load duke parents: diff changeset	600 // used only for asserts
a61af66fc99e Initial load duke parents: diff changeset	601 inline bool oopDesc::is_oop_or_null(bool ignore_mark_word) const {
a61af66fc99e Initial load duke parents: diff changeset	602 return this == NULL ? true : is_oop(ignore_mark_word);
a61af66fc99e Initial load duke parents: diff changeset	603 }
a61af66fc99e Initial load duke parents: diff changeset	604
a61af66fc99e Initial load duke parents: diff changeset	605 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	606 // used only for asserts
a61af66fc99e Initial load duke parents: diff changeset	607 inline bool oopDesc::is_unlocked_oop() const {
a61af66fc99e Initial load duke parents: diff changeset	608 if (!Universe::heap()->is_in_reserved(this)) return false;
a61af66fc99e Initial load duke parents: diff changeset	609 return mark()->is_unlocked();
a61af66fc99e Initial load duke parents: diff changeset	610 }
a61af66fc99e Initial load duke parents: diff changeset	611 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	612
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	613 inline void oopDesc::follow_contents(void) {
0 a61af66fc99e Initial load duke parents: diff changeset	614 assert (is_gc_marked(), "should be marked");
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	615 klass()->oop_follow_contents(this);
0 a61af66fc99e Initial load duke parents: diff changeset	616 }
a61af66fc99e Initial load duke parents: diff changeset	617
a61af66fc99e Initial load duke parents: diff changeset	618 // Used by scavengers
a61af66fc99e Initial load duke parents: diff changeset	619
a61af66fc99e Initial load duke parents: diff changeset	620 inline bool oopDesc::is_forwarded() const {
a61af66fc99e Initial load duke parents: diff changeset	621 // The extra heap check is needed since the obj might be locked, in which case the
a61af66fc99e Initial load duke parents: diff changeset	622 // mark would point to a stack location and have the sentinel bit cleared
a61af66fc99e Initial load duke parents: diff changeset	623 return mark()->is_marked();
a61af66fc99e Initial load duke parents: diff changeset	624 }
a61af66fc99e Initial load duke parents: diff changeset	625
a61af66fc99e Initial load duke parents: diff changeset	626 // Used by scavengers
a61af66fc99e Initial load duke parents: diff changeset	627 inline void oopDesc::forward_to(oop p) {
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	628 assert(check_obj_alignment(p),
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	629 "forwarding to something not aligned");
0 a61af66fc99e Initial load duke parents: diff changeset	630 assert(Universe::heap()->is_in_reserved(p),
a61af66fc99e Initial load duke parents: diff changeset	631 "forwarding to something not in heap");
a61af66fc99e Initial load duke parents: diff changeset	632 markOop m = markOopDesc::encode_pointer_as_mark(p);
a61af66fc99e Initial load duke parents: diff changeset	633 assert(m->decode_pointer() == p, "encoding must be reversable");
a61af66fc99e Initial load duke parents: diff changeset	634 set_mark(m);
a61af66fc99e Initial load duke parents: diff changeset	635 }
a61af66fc99e Initial load duke parents: diff changeset	636
a61af66fc99e Initial load duke parents: diff changeset	637 // Used by parallel scavengers
a61af66fc99e Initial load duke parents: diff changeset	638 inline bool oopDesc::cas_forward_to(oop p, markOop compare) {
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	639 assert(check_obj_alignment(p),
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	640 "forwarding to something not aligned");
0 a61af66fc99e Initial load duke parents: diff changeset	641 assert(Universe::heap()->is_in_reserved(p),
a61af66fc99e Initial load duke parents: diff changeset	642 "forwarding to something not in heap");
a61af66fc99e Initial load duke parents: diff changeset	643 markOop m = markOopDesc::encode_pointer_as_mark(p);
a61af66fc99e Initial load duke parents: diff changeset	644 assert(m->decode_pointer() == p, "encoding must be reversable");
a61af66fc99e Initial load duke parents: diff changeset	645 return cas_set_mark(m, compare) == compare;
a61af66fc99e Initial load duke parents: diff changeset	646 }
a61af66fc99e Initial load duke parents: diff changeset	647
a61af66fc99e Initial load duke parents: diff changeset	648 // Note that the forwardee is not the same thing as the displaced_mark.
a61af66fc99e Initial load duke parents: diff changeset	649 // The forwardee is used when copying during scavenge and mark-sweep.
a61af66fc99e Initial load duke parents: diff changeset	650 // It does need to clear the low two locking- and GC-related bits.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	651 inline oop oopDesc::forwardee() const {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	652 return (oop) mark()->decode_pointer();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	653 }
0 a61af66fc99e Initial load duke parents: diff changeset	654
a61af66fc99e Initial load duke parents: diff changeset	655 inline bool oopDesc::has_displaced_mark() const {
a61af66fc99e Initial load duke parents: diff changeset	656 return mark()->has_displaced_mark_helper();
a61af66fc99e Initial load duke parents: diff changeset	657 }
a61af66fc99e Initial load duke parents: diff changeset	658
a61af66fc99e Initial load duke parents: diff changeset	659 inline markOop oopDesc::displaced_mark() const {
a61af66fc99e Initial load duke parents: diff changeset	660 return mark()->displaced_mark_helper();
a61af66fc99e Initial load duke parents: diff changeset	661 }
a61af66fc99e Initial load duke parents: diff changeset	662
a61af66fc99e Initial load duke parents: diff changeset	663 inline void oopDesc::set_displaced_mark(markOop m) {
a61af66fc99e Initial load duke parents: diff changeset	664 mark()->set_displaced_mark_helper(m);
a61af66fc99e Initial load duke parents: diff changeset	665 }
a61af66fc99e Initial load duke parents: diff changeset	666
a61af66fc99e Initial load duke parents: diff changeset	667 // The following method needs to be MT safe.
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6727 diff changeset	668 inline uint oopDesc::age() const {
0 a61af66fc99e Initial load duke parents: diff changeset	669 assert(!is_forwarded(), "Attempt to read age from forwarded mark");
a61af66fc99e Initial load duke parents: diff changeset	670 if (has_displaced_mark()) {
a61af66fc99e Initial load duke parents: diff changeset	671 return displaced_mark()->age();
a61af66fc99e Initial load duke parents: diff changeset	672 } else {
a61af66fc99e Initial load duke parents: diff changeset	673 return mark()->age();
a61af66fc99e Initial load duke parents: diff changeset	674 }
a61af66fc99e Initial load duke parents: diff changeset	675 }
a61af66fc99e Initial load duke parents: diff changeset	676
a61af66fc99e Initial load duke parents: diff changeset	677 inline void oopDesc::incr_age() {
a61af66fc99e Initial load duke parents: diff changeset	678 assert(!is_forwarded(), "Attempt to increment age of forwarded mark");
a61af66fc99e Initial load duke parents: diff changeset	679 if (has_displaced_mark()) {
a61af66fc99e Initial load duke parents: diff changeset	680 set_displaced_mark(displaced_mark()->incr_age());
a61af66fc99e Initial load duke parents: diff changeset	681 } else {
a61af66fc99e Initial load duke parents: diff changeset	682 set_mark(mark()->incr_age());
a61af66fc99e Initial load duke parents: diff changeset	683 }
a61af66fc99e Initial load duke parents: diff changeset	684 }
a61af66fc99e Initial load duke parents: diff changeset	685
a61af66fc99e Initial load duke parents: diff changeset	686
a61af66fc99e Initial load duke parents: diff changeset	687 inline intptr_t oopDesc::identity_hash() {
a61af66fc99e Initial load duke parents: diff changeset	688 // Fast case; if the object is unlocked and the hash value is set, no locking is needed
a61af66fc99e Initial load duke parents: diff changeset	689 // Note: The mark must be read into local variable to avoid concurrent updates.
a61af66fc99e Initial load duke parents: diff changeset	690 markOop mrk = mark();
a61af66fc99e Initial load duke parents: diff changeset	691 if (mrk->is_unlocked() && !mrk->has_no_hash()) {
a61af66fc99e Initial load duke parents: diff changeset	692 return mrk->hash();
a61af66fc99e Initial load duke parents: diff changeset	693 } else if (mrk->is_marked()) {
a61af66fc99e Initial load duke parents: diff changeset	694 return mrk->hash();
a61af66fc99e Initial load duke parents: diff changeset	695 } else {
a61af66fc99e Initial load duke parents: diff changeset	696 return slow_identity_hash();
a61af66fc99e Initial load duke parents: diff changeset	697 }
a61af66fc99e Initial load duke parents: diff changeset	698 }
a61af66fc99e Initial load duke parents: diff changeset	699
a61af66fc99e Initial load duke parents: diff changeset	700 inline int oopDesc::adjust_pointers() {
a61af66fc99e Initial load duke parents: diff changeset	701 debug_only(int check_size = size());
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	702 int s = klass()->oop_adjust_pointers(this);
0 a61af66fc99e Initial load duke parents: diff changeset	703 assert(s == check_size, "should be the same");
a61af66fc99e Initial load duke parents: diff changeset	704 return s;
a61af66fc99e Initial load duke parents: diff changeset	705 }
a61af66fc99e Initial load duke parents: diff changeset	706
a61af66fc99e Initial load duke parents: diff changeset	707 #define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	708 \
a61af66fc99e Initial load duke parents: diff changeset	709 inline int oopDesc::oop_iterate(OopClosureType* blk) { \
a61af66fc99e Initial load duke parents: diff changeset	710 SpecializationStats::record_call(); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	711 return klass()->oop_oop_iterate##nv_suffix(this, blk); \
0 a61af66fc99e Initial load duke parents: diff changeset	712 } \
a61af66fc99e Initial load duke parents: diff changeset	713 \
a61af66fc99e Initial load duke parents: diff changeset	714 inline int oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \
a61af66fc99e Initial load duke parents: diff changeset	715 SpecializationStats::record_call(); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	716 return klass()->oop_oop_iterate##nv_suffix##_m(this, blk, mr); \
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	717 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	718
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	719
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	720 inline int oopDesc::oop_iterate_no_header(OopClosure* blk) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	721 // The NoHeaderExtendedOopClosure wraps the OopClosure and proxies all
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	722 // the do_oop calls, but turns off all other features in ExtendedOopClosure.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	723 NoHeaderExtendedOopClosure cl(blk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	724 return oop_iterate(&cl);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	725 }
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	726
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	727 inline int oopDesc::oop_iterate_no_header(OopClosure* blk, MemRegion mr) {
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	728 NoHeaderExtendedOopClosure cl(blk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	729 return oop_iterate(&cl, mr);
0 a61af66fc99e Initial load duke parents: diff changeset	730 }
a61af66fc99e Initial load duke parents: diff changeset	731
a61af66fc99e Initial load duke parents: diff changeset	732 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DEFN)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	733 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	734
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6848 diff changeset	735 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	736 #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	737 \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	738 inline int oopDesc::oop_iterate_backwards(OopClosureType* blk) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	739 SpecializationStats::record_call(); \
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 3932 diff changeset	740 return klass()->oop_oop_iterate_backwards##nv_suffix(this, blk); \
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	741 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	742
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	743 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DEFN)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	744 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DEFN)
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6848 diff changeset	745 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	746
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	747 #endif // SHARE_VM_OOPS_OOP_INLINE_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/oop.inline.hpp @ 14649:f6301b007a16