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

annotate src/share/vm/oops/oop.inline.hpp @ 3917:eca1193ca245

4965777: GC changes to support use of discovered field for pending references Summary: If and when the reference handler thread is able to use the discovered field to link reference objects in its pending list, so will GC. In that case, GC will scan through this field once a reference object has been placed on the pending list, but not scan that field before that stage, as the field is used by the concurrent GC thread to link discovered objects. When ReferenceHandleR thread does not use the discovered field for the purpose of linking the elements in the pending list, as would be the case in older JDKs, the JVM will fall back to the old behaviour of using the next field for that purpose. Reviewed-by: jcoomes, mchung, stefank

author	ysr
date	Wed, 07 Sep 2011 13:55:42 -0700
parents	c7f3d0b4570f
children	0654ee04b214 b0efc7ee3b31

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	2 * Copyright (c) 1997, 2011, 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/compactingPermGenGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	34 #include "memory/genCollectedHeap.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	35 #include "memory/generation.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	36 #include "memory/permGen.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	37 #include "memory/specialized_oop_closures.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	38 #include "oops/arrayKlass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	39 #include "oops/arrayOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	40 #include "oops/klass.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	41 #include "oops/klassOop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	42 #include "oops/markOop.inline.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	43 #include "oops/oop.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	44 #include "runtime/atomic.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	45 #include "runtime/os.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	46 #ifdef TARGET_ARCH_x86
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	47 # include "bytes_x86.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	48 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	49 #ifdef TARGET_ARCH_sparc
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	50 # include "bytes_sparc.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	51 #endif
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	52 #ifdef TARGET_ARCH_zero
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	53 # include "bytes_zero.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	54 #endif
2192 b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	55 #ifdef TARGET_ARCH_arm
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	56 # include "bytes_arm.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	57 #endif
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	58 #ifdef TARGET_ARCH_ppc
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	59 # include "bytes_ppc.hpp"
b92c45f2bc75 7016023: Enable building ARM and PPC from src/closed repository bobv parents: 2177 diff changeset	60 #endif
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	61
0 a61af66fc99e Initial load duke parents: diff changeset	62 // Implementation of all inlined member functions defined in oop.hpp
a61af66fc99e Initial load duke parents: diff changeset	63 // We need a separate file to avoid circular references
a61af66fc99e Initial load duke parents: diff changeset	64
a61af66fc99e Initial load duke parents: diff changeset	65 inline void oopDesc::release_set_mark(markOop m) {
a61af66fc99e Initial load duke parents: diff changeset	66 OrderAccess::release_store_ptr(&_mark, m);
a61af66fc99e Initial load duke parents: diff changeset	67 }
a61af66fc99e Initial load duke parents: diff changeset	68
a61af66fc99e Initial load duke parents: diff changeset	69 inline markOop oopDesc::cas_set_mark(markOop new_mark, markOop old_mark) {
a61af66fc99e Initial load duke parents: diff changeset	70 return (markOop) Atomic::cmpxchg_ptr(new_mark, &_mark, old_mark);
a61af66fc99e Initial load duke parents: diff changeset	71 }
a61af66fc99e Initial load duke parents: diff changeset	72
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	73 inline klassOop oopDesc::klass() const {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	74 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	75 return (klassOop)decode_heap_oop_not_null(_metadata._compressed_klass);
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	76 } else {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	77 return _metadata._klass;
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	78 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	79 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	80
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	81 inline klassOop oopDesc::klass_or_null() const volatile {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	82 // can be NULL in CMS
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	83 if (UseCompressedOops) {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	84 return (klassOop)decode_heap_oop(_metadata._compressed_klass);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	85 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	86 return _metadata._klass;
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 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	89
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	90 inline int oopDesc::klass_gap_offset_in_bytes() {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	91 assert(UseCompressedOops, "only applicable to compressed headers");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	92 return oopDesc::klass_offset_in_bytes() + sizeof(narrowOop);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	93 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	94
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	95 inline oop* oopDesc::klass_addr() {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	96 // 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	97 // UseCompressedOops
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	98 assert(!UseCompressedOops, "only supported with uncompressed oops");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	99 return (oop*) &_metadata._klass;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	100 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	101
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	102 inline narrowOop* oopDesc::compressed_klass_addr() {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	103 assert(UseCompressedOops, "only called by compressed oops");
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	104 return (narrowOop*) &_metadata._compressed_klass;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	105 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	106
0 a61af66fc99e Initial load duke parents: diff changeset	107 inline void oopDesc::set_klass(klassOop k) {
a61af66fc99e Initial load duke parents: diff changeset	108 // since klasses are promoted no store check is needed
a61af66fc99e Initial load duke parents: diff changeset	109 assert(Universe::is_bootstrapping() \|\| k != NULL, "must be a real klassOop");
a61af66fc99e Initial load duke parents: diff changeset	110 assert(Universe::is_bootstrapping() \|\| k->is_klass(), "not a klassOop");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	111 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	112 oop_store_without_check(compressed_klass_addr(), (oop)k);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	113 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	114 oop_store_without_check(klass_addr(), (oop) k);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	115 }
0 a61af66fc99e Initial load duke parents: diff changeset	116 }
a61af66fc99e Initial load duke parents: diff changeset	117
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	118 inline int oopDesc::klass_gap() const {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	119 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	120 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	121
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	122 inline void oopDesc::set_klass_gap(int v) {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	123 if (UseCompressedOops) {
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	124 (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	125 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	126 }
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	127
0 a61af66fc99e Initial load duke parents: diff changeset	128 inline void oopDesc::set_klass_to_list_ptr(oop k) {
a61af66fc99e Initial load duke parents: diff changeset	129 // This is only to be used during GC, for from-space objects, so no
a61af66fc99e Initial load duke parents: diff changeset	130 // barrier is needed.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	131 if (UseCompressedOops) {
454 df4305d4c1a1 6774607: SIGSEGV or (!is_null(v),"oop value can never be zero") assertion when running with CMS and COOPs ysr parents: 356 diff changeset	132 _metadata._compressed_klass = 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	133 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	134 _metadata._klass = (klassOop)k;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	135 }
0 a61af66fc99e Initial load duke parents: diff changeset	136 }
a61af66fc99e Initial load duke parents: diff changeset	137
a61af66fc99e Initial load duke parents: diff changeset	138 inline void oopDesc::init_mark() { set_mark(markOopDesc::prototype_for_object(this)); }
a61af66fc99e Initial load duke parents: diff changeset	139 inline Klass* oopDesc::blueprint() const { return klass()->klass_part(); }
a61af66fc99e Initial load duke parents: diff changeset	140
a61af66fc99e Initial load duke parents: diff changeset	141 inline bool oopDesc::is_a(klassOop k) const { return blueprint()->is_subtype_of(k); }
a61af66fc99e Initial load duke parents: diff changeset	142
a61af66fc99e Initial load duke parents: diff changeset	143 inline bool oopDesc::is_instance() const { return blueprint()->oop_is_instance(); }
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	144 inline bool oopDesc::is_instanceMirror() const { return blueprint()->oop_is_instanceMirror(); }
0 a61af66fc99e Initial load duke parents: diff changeset	145 inline bool oopDesc::is_instanceRef() const { return blueprint()->oop_is_instanceRef(); }
a61af66fc99e Initial load duke parents: diff changeset	146 inline bool oopDesc::is_array() const { return blueprint()->oop_is_array(); }
a61af66fc99e Initial load duke parents: diff changeset	147 inline bool oopDesc::is_objArray() const { return blueprint()->oop_is_objArray(); }
a61af66fc99e Initial load duke parents: diff changeset	148 inline bool oopDesc::is_typeArray() const { return blueprint()->oop_is_typeArray(); }
a61af66fc99e Initial load duke parents: diff changeset	149 inline bool oopDesc::is_javaArray() const { return blueprint()->oop_is_javaArray(); }
a61af66fc99e Initial load duke parents: diff changeset	150 inline bool oopDesc::is_klass() const { return blueprint()->oop_is_klass(); }
a61af66fc99e Initial load duke parents: diff changeset	151 inline bool oopDesc::is_thread() const { return blueprint()->oop_is_thread(); }
a61af66fc99e Initial load duke parents: diff changeset	152 inline bool oopDesc::is_method() const { return blueprint()->oop_is_method(); }
a61af66fc99e Initial load duke parents: diff changeset	153 inline bool oopDesc::is_constMethod() const { return blueprint()->oop_is_constMethod(); }
a61af66fc99e Initial load duke parents: diff changeset	154 inline bool oopDesc::is_methodData() const { return blueprint()->oop_is_methodData(); }
a61af66fc99e Initial load duke parents: diff changeset	155 inline bool oopDesc::is_constantPool() const { return blueprint()->oop_is_constantPool(); }
a61af66fc99e Initial load duke parents: diff changeset	156 inline bool oopDesc::is_constantPoolCache() const { return blueprint()->oop_is_constantPoolCache(); }
a61af66fc99e Initial load duke parents: diff changeset	157 inline bool oopDesc::is_compiledICHolder() const { return blueprint()->oop_is_compiledICHolder(); }
a61af66fc99e Initial load duke parents: diff changeset	158
a61af66fc99e Initial load duke parents: diff changeset	159 inline void* oopDesc::field_base(int offset) const { return (void)&((char)this)[offset]; }
a61af66fc99e Initial load duke parents: diff changeset	160
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	161 template <class T> inline T* oopDesc::obj_field_addr(int offset) const { return (T*)field_base(offset); }
0 a61af66fc99e Initial load duke parents: diff changeset	162 inline jbyte* oopDesc::byte_field_addr(int offset) const { return (jbyte*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	163 inline jchar* oopDesc::char_field_addr(int offset) const { return (jchar*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	164 inline jboolean* oopDesc::bool_field_addr(int offset) const { return (jboolean*)field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	165 inline jint* oopDesc::int_field_addr(int offset) const { return (jint*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	166 inline jshort* oopDesc::short_field_addr(int offset) const { return (jshort*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	167 inline jlong* oopDesc::long_field_addr(int offset) const { return (jlong*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	168 inline jfloat* oopDesc::float_field_addr(int offset) const { return (jfloat*) field_base(offset); }
a61af66fc99e Initial load duke parents: diff changeset	169 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	170 inline address* oopDesc::address_field_addr(int offset) const { return (address*) field_base(offset); }
0 a61af66fc99e Initial load duke parents: diff changeset	171
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	172
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	173 // 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	174 // 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	175 // 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	176 // 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	177 // 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	178
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(oop obj) { return obj == NULL; }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	180 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	181
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	182 // 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	183 // 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	184 // 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	185
1571 2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	186 inline bool check_obj_alignment(oop obj) {
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	187 return (intptr_t)obj % MinObjAlignmentInBytes == 0;
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	188 }
2d127394260e 6916623: Align object to 16 bytes to use Compressed Oops with java heap up to 64Gb kvn parents: 845 diff changeset	189
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	190 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	191 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	192 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	193 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	194 address base = Universe::narrow_oop_base();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	195 int shift = Universe::narrow_oop_shift();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	196 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	197 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	198 uint64_t result = pd >> shift;
135 b7268662a986 6689523: max heap calculation for compressed oops is off by MaxPermSize coleenp parents: 133 diff changeset	199 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	200 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	201 return (narrowOop)result;
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
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	204 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	205 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	206 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	207
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	208 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	209 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	210 address base = Universe::narrow_oop_base();
660978a2a31a 6791178: Specialize for zero as the compressed oop vm heap base kvn parents: 518 diff changeset	211 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	212 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	213 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	214 return result;
113 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
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	217 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	218 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	219 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	220
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_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	222 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	223
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	224 // 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	225 // 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	226 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	227 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	228
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	229 // 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	230 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	231 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	232 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	233 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	234
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	235 // 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	236 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	237 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	238 return decode_heap_oop(*p);
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
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	241 // 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	242 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	243 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	244
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	245 // 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	246 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	247 *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	248 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	249 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	250
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	251 // 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	252 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	253 *p = encode_heap_oop(v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	254 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	255 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	256
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	257 // 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	258 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	259 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	260 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	261 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	262 narrowOop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	263 OrderAccess::release_store(p, v);
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
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	266 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	267 volatile narrowOop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	268 // 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	269 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	270 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	271
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	272 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	273 volatile oop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	274 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	275 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	276
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	277 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	278 oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	279 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	280 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	281 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	282 volatile narrowOop* p, oop v) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	283 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	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
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	287 // 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	288 // not headers.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	289 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	290 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	291 // 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	292 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	293 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	294 // 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	295 return decode_heap_oop(old);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	296 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	297 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	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
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	301 inline oop oopDesc::atomic_compare_exchange_oop(oop exchange_value,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	302 volatile HeapWord *dest,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	303 oop compare_value) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	304 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	305 // encode exchange and compare value from oop to T
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	306 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	307 narrowOop cmp = encode_heap_oop(compare_value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	308
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	309 narrowOop old = (narrowOop) Atomic::cmpxchg(val, (narrowOop*)dest, cmp);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	310 // 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	311 return decode_heap_oop(old);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	312 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	313 return (oop)Atomic::cmpxchg_ptr(exchange_value, (oop*)dest, compare_value);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	314 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	315 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	316
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	317 // 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	318 // 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	319 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	320 return UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	321 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	322 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	323 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	324 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	325 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	326 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	327 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	328 inline void oopDesc::obj_field_raw_put(int offset, oop value) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	329 UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	330 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	331 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	332 }
0 a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 inline jbyte oopDesc::byte_field(int offset) const { return (jbyte) *byte_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	335 inline void oopDesc::byte_field_put(int offset, jbyte contents) { *byte_field_addr(offset) = (jint) contents; }
a61af66fc99e Initial load duke parents: diff changeset	336
a61af66fc99e Initial load duke parents: diff changeset	337 inline jboolean oopDesc::bool_field(int offset) const { return (jboolean) *bool_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	338 inline void oopDesc::bool_field_put(int offset, jboolean contents) { *bool_field_addr(offset) = (jint) contents; }
a61af66fc99e Initial load duke parents: diff changeset	339
a61af66fc99e Initial load duke parents: diff changeset	340 inline jchar oopDesc::char_field(int offset) const { return (jchar) *char_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	341 inline void oopDesc::char_field_put(int offset, jchar contents) { *char_field_addr(offset) = (jint) contents; }
a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 inline jint oopDesc::int_field(int offset) const { return *int_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	344 inline void oopDesc::int_field_put(int offset, jint contents) { *int_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 inline jshort oopDesc::short_field(int offset) const { return (jshort) *short_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	347 inline void oopDesc::short_field_put(int offset, jshort contents) { *short_field_addr(offset) = (jint) contents;}
a61af66fc99e Initial load duke parents: diff changeset	348
a61af66fc99e Initial load duke parents: diff changeset	349 inline jlong oopDesc::long_field(int offset) const { return *long_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	350 inline void oopDesc::long_field_put(int offset, jlong contents) { *long_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	351
a61af66fc99e Initial load duke parents: diff changeset	352 inline jfloat oopDesc::float_field(int offset) const { return *float_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	353 inline void oopDesc::float_field_put(int offset, jfloat contents) { *float_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 inline jdouble oopDesc::double_field(int offset) const { return *double_field_addr(offset); }
a61af66fc99e Initial load duke parents: diff changeset	356 inline void oopDesc::double_field_put(int offset, jdouble contents) { *double_field_addr(offset) = contents; }
a61af66fc99e Initial load duke parents: diff changeset	357
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	358 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	359 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	360
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	361 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	362 return UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	363 decode_heap_oop((narrowOop)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	364 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	365 : decode_heap_oop((oop)
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	366 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	367 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	368 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	369 UseCompressedOops ?
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	370 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	371 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	372 }
0 a61af66fc99e Initial load duke parents: diff changeset	373
a61af66fc99e Initial load duke parents: diff changeset	374 inline jbyte oopDesc::byte_field_acquire(int offset) const { return OrderAccess::load_acquire(byte_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	375 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	376
a61af66fc99e Initial load duke parents: diff changeset	377 inline jboolean oopDesc::bool_field_acquire(int offset) const { return OrderAccess::load_acquire(bool_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	378 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	379
a61af66fc99e Initial load duke parents: diff changeset	380 inline jchar oopDesc::char_field_acquire(int offset) const { return OrderAccess::load_acquire(char_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	381 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	382
a61af66fc99e Initial load duke parents: diff changeset	383 inline jint oopDesc::int_field_acquire(int offset) const { return OrderAccess::load_acquire(int_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	384 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	385
a61af66fc99e Initial load duke parents: diff changeset	386 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	387 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	388
a61af66fc99e Initial load duke parents: diff changeset	389 inline jlong oopDesc::long_field_acquire(int offset) const { return OrderAccess::load_acquire(long_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	390 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	391
a61af66fc99e Initial load duke parents: diff changeset	392 inline jfloat oopDesc::float_field_acquire(int offset) const { return OrderAccess::load_acquire(float_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	393 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	394
a61af66fc99e Initial load duke parents: diff changeset	395 inline jdouble oopDesc::double_field_acquire(int offset) const { return OrderAccess::load_acquire(double_field_addr(offset)); }
a61af66fc99e Initial load duke parents: diff changeset	396 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	397
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 647 diff changeset	398 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	399 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	400
0 a61af66fc99e Initial load duke parents: diff changeset	401 inline int oopDesc::size_given_klass(Klass* klass) {
a61af66fc99e Initial load duke parents: diff changeset	402 int lh = klass->layout_helper();
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	403 int s;
0 a61af66fc99e Initial load duke parents: diff changeset	404
a61af66fc99e Initial load duke parents: diff changeset	405 // lh is now a value computed at class initialization that may hint
a61af66fc99e Initial load duke parents: diff changeset	406 // at the size. For instances, this is positive and equal to the
a61af66fc99e Initial load duke parents: diff changeset	407 // size. For arrays, this is negative and provides log2 of the
a61af66fc99e Initial load duke parents: diff changeset	408 // array element size. For other oops, it is zero and thus requires
a61af66fc99e Initial load duke parents: diff changeset	409 // a virtual call.
a61af66fc99e Initial load duke parents: diff changeset	410 //
a61af66fc99e Initial load duke parents: diff changeset	411 // We go to all this trouble because the size computation is at the
a61af66fc99e Initial load duke parents: diff changeset	412 // heart of phase 2 of mark-compaction, and called for every object,
a61af66fc99e Initial load duke parents: diff changeset	413 // alive or dead. So the speed here is equal in importance to the
a61af66fc99e Initial load duke parents: diff changeset	414 // speed of allocation.
a61af66fc99e Initial load duke parents: diff changeset	415
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	416 if (lh > Klass::_lh_neutral_value) {
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	417 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	418 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	419 } else {
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	420 s = klass->oop_size(this);
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	421 }
c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2192 diff changeset	422 } else if (lh <= Klass::_lh_neutral_value) {
0 a61af66fc99e Initial load duke parents: diff changeset	423 // The most common case is instances; fall through if so.
a61af66fc99e Initial load duke parents: diff changeset	424 if (lh < Klass::_lh_neutral_value) {
a61af66fc99e Initial load duke parents: diff changeset	425 // Second most common case is arrays. We have to fetch the
a61af66fc99e Initial load duke parents: diff changeset	426 // length of the array, shift (multiply) it appropriately,
a61af66fc99e Initial load duke parents: diff changeset	427 // up to wordSize, add the header, and align to object size.
a61af66fc99e Initial load duke parents: diff changeset	428 size_t size_in_bytes;
a61af66fc99e Initial load duke parents: diff changeset	429 #ifdef _M_IA64
a61af66fc99e Initial load duke parents: diff changeset	430 // The Windows Itanium Aug 2002 SDK hoists this load above
a61af66fc99e Initial load duke parents: diff changeset	431 // the check for s < 0. An oop at the end of the heap will
a61af66fc99e Initial load duke parents: diff changeset	432 // cause an access violation if this load is performed on a non
a61af66fc99e Initial load duke parents: diff changeset	433 // array oop. Making the reference volatile prohibits this.
a61af66fc99e Initial load duke parents: diff changeset	434 // (%%% please explain by what magic the length is actually fetched!)
a61af66fc99e Initial load duke parents: diff changeset	435 volatile int *array_length;
a61af66fc99e Initial load duke parents: diff changeset	436 array_length = (volatile int *)( (intptr_t)this +
a61af66fc99e Initial load duke parents: diff changeset	437 arrayOopDesc::length_offset_in_bytes() );
a61af66fc99e Initial load duke parents: diff changeset	438 assert(array_length > 0, "Integer arithmetic problem somewhere");
a61af66fc99e Initial load duke parents: diff changeset	439 // Put into size_t to avoid overflow.
a61af66fc99e Initial load duke parents: diff changeset	440 size_in_bytes = (size_t) array_length;
a61af66fc99e Initial load duke parents: diff changeset	441 size_in_bytes = size_in_bytes << Klass::layout_helper_log2_element_size(lh);
a61af66fc99e Initial load duke parents: diff changeset	442 #else
a61af66fc99e Initial load duke parents: diff changeset	443 size_t array_length = (size_t) ((arrayOop)this)->length();
a61af66fc99e Initial load duke parents: diff changeset	444 size_in_bytes = array_length << Klass::layout_helper_log2_element_size(lh);
a61af66fc99e Initial load duke parents: diff changeset	445 #endif
a61af66fc99e Initial load duke parents: diff changeset	446 size_in_bytes += Klass::layout_helper_header_size(lh);
a61af66fc99e Initial load duke parents: diff changeset	447
a61af66fc99e Initial load duke parents: diff changeset	448 // This code could be simplified, but by keeping array_header_in_bytes
a61af66fc99e Initial load duke parents: diff changeset	449 // in units of bytes and doing it this way we can round up just once,
a61af66fc99e Initial load duke parents: diff changeset	450 // skipping the intermediate round to HeapWordSize. Cast the result
a61af66fc99e Initial load duke parents: diff changeset	451 // of round_to to size_t to guarantee unsigned division == right shift.
a61af66fc99e Initial load duke parents: diff changeset	452 s = (int)((size_t)round_to(size_in_bytes, MinObjAlignmentInBytes) /
a61af66fc99e Initial load duke parents: diff changeset	453 HeapWordSize);
a61af66fc99e Initial load duke parents: diff changeset	454
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	455 // UseParNewGC, UseParallelGC and UseG1GC can change the length field
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	456 // 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	457 // 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	458 // 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	459 // a concurrent change.
0 a61af66fc99e Initial load duke parents: diff changeset	460 // UseParNewGC also runs with promotion labs (which look like int
a61af66fc99e Initial load duke parents: diff changeset	461 // filler arrays) which are subject to changing their declared size
a61af66fc99e Initial load duke parents: diff changeset	462 // when finally retiring a PLAB; this also can cause the first disjunct
a61af66fc99e Initial load duke parents: diff changeset	463 // to fail for another worker thread that is concurrently walking the block
a61af66fc99e Initial load duke parents: diff changeset	464 // offset table. Both these invariant failures are benign for their
a61af66fc99e Initial load duke parents: diff changeset	465 // current uses; we relax the assertion checking to cover these two cases below:
a61af66fc99e Initial load duke parents: diff changeset	466 // is_objArray() && is_forwarded() // covers first scenario above
a61af66fc99e Initial load duke parents: diff changeset	467 // \|\| is_typeArray() // covers second scenario above
a61af66fc99e Initial load duke parents: diff changeset	468 // 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	469 // technique, we will need to suitably modify the assertion.
0 a61af66fc99e Initial load duke parents: diff changeset	470 assert((s == klass->oop_size(this)) \|\|
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	471 (Universe::heap()->is_gc_active() &&
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	472 ((is_typeArray() && UseParNewGC) \|\|
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	473 (is_objArray() && is_forwarded() && (UseParNewGC \|\| UseParallelGC \|\| UseG1GC)))),
0 a61af66fc99e Initial load duke parents: diff changeset	474 "wrong array object size");
a61af66fc99e Initial load duke parents: diff changeset	475 } else {
a61af66fc99e Initial load duke parents: diff changeset	476 // Must be zero, so bite the bullet and take the virtual call.
a61af66fc99e Initial load duke parents: diff changeset	477 s = klass->oop_size(this);
a61af66fc99e Initial load duke parents: diff changeset	478 }
a61af66fc99e Initial load duke parents: diff changeset	479 }
a61af66fc99e Initial load duke parents: diff changeset	480
a61af66fc99e Initial load duke parents: diff changeset	481 assert(s % MinObjAlignment == 0, "alignment check");
a61af66fc99e Initial load duke parents: diff changeset	482 assert(s > 0, "Bad size calculated");
a61af66fc99e Initial load duke parents: diff changeset	483 return s;
a61af66fc99e Initial load duke parents: diff changeset	484 }
a61af66fc99e Initial load duke parents: diff changeset	485
a61af66fc99e Initial load duke parents: diff changeset	486
a61af66fc99e Initial load duke parents: diff changeset	487 inline int oopDesc::size() {
a61af66fc99e Initial load duke parents: diff changeset	488 return size_given_klass(blueprint());
a61af66fc99e Initial load duke parents: diff changeset	489 }
a61af66fc99e Initial load duke parents: diff changeset	490
a61af66fc99e Initial load duke parents: diff changeset	491 inline bool oopDesc::is_parsable() {
a61af66fc99e Initial load duke parents: diff changeset	492 return blueprint()->oop_is_parsable(this);
a61af66fc99e Initial load duke parents: diff changeset	493 }
a61af66fc99e Initial load duke parents: diff changeset	494
518 0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 454 diff changeset	495 inline bool oopDesc::is_conc_safe() {
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 454 diff changeset	496 return blueprint()->oop_is_conc_safe(this);
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 454 diff changeset	497 }
0af8b0718fc9 6692899: CMS: many vm.parallel_class_loading tests fail with assert "missing Printezis mark" jmasa parents: 454 diff changeset	498
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	499 inline void update_barrier_set(void* p, oop v) {
0 a61af66fc99e Initial load duke parents: diff changeset	500 assert(oopDesc::bs() != NULL, "Uninitialized bs in oop!");
a61af66fc99e Initial load duke parents: diff changeset	501 oopDesc::bs()->write_ref_field(p, v);
a61af66fc99e Initial load duke parents: diff changeset	502 }
a61af66fc99e Initial load duke parents: diff changeset	503
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	504 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	505 oopDesc::bs()->write_ref_field_pre(p, v);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	506 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	507
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	508 template <class T> inline void oop_store(T* p, oop v) {
0 a61af66fc99e Initial load duke parents: diff changeset	509 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	510 oop_store((volatile T*)p, v);
0 a61af66fc99e Initial load duke parents: diff changeset	511 } else {
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	512 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	513 oopDesc::encode_store_heap_oop(p, v);
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	514 update_barrier_set((void*)p, v); // cast away type
0 a61af66fc99e Initial load duke parents: diff changeset	515 }
a61af66fc99e Initial load duke parents: diff changeset	516 }
a61af66fc99e Initial load duke parents: diff changeset	517
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	518 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	519 update_barrier_set_pre((T*)p, v); // cast away volatile
0 a61af66fc99e Initial load duke parents: diff changeset	520 // 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	521 oopDesc::release_encode_store_heap_oop(p, v);
845 df6caf649ff7 6700789: G1: Enable use of compressed oops with G1 heaps ysr parents: 710 diff changeset	522 update_barrier_set((void*)p, v); // cast away type
0 a61af66fc99e Initial load duke parents: diff changeset	523 }
a61af66fc99e Initial load duke parents: diff changeset	524
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	525 template <class T> inline void oop_store_without_check(T* p, oop v) {
0 a61af66fc99e Initial load duke parents: diff changeset	526 // XXX YSR FIX ME!!!
a61af66fc99e Initial load duke parents: diff changeset	527 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	528 oop_store(p, v);
0 a61af66fc99e Initial load duke parents: diff changeset	529 } else {
a61af66fc99e Initial load duke parents: diff changeset	530 assert(!Universe::heap()->barrier_set()->write_ref_needs_barrier(p, v),
a61af66fc99e Initial load duke parents: diff changeset	531 "oop store without store check failed");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	532 oopDesc::encode_store_heap_oop(p, v);
0 a61af66fc99e Initial load duke parents: diff changeset	533 }
a61af66fc99e Initial load duke parents: diff changeset	534 }
a61af66fc99e Initial load duke parents: diff changeset	535
a61af66fc99e Initial load duke parents: diff changeset	536 // When it absolutely has to get there.
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	537 template <class T> inline void oop_store_without_check(volatile T* p, oop v) {
0 a61af66fc99e Initial load duke parents: diff changeset	538 // XXX YSR FIX ME!!!
a61af66fc99e Initial load duke parents: diff changeset	539 if (always_do_update_barrier) {
a61af66fc99e Initial load duke parents: diff changeset	540 oop_store(p, v);
a61af66fc99e Initial load duke parents: diff changeset	541 } else {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	542 assert(!Universe::heap()->barrier_set()->write_ref_needs_barrier((T*)p, v),
0 a61af66fc99e Initial load duke parents: diff changeset	543 "oop store without store check failed");
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	544 oopDesc::release_encode_store_heap_oop(p, v);
0 a61af66fc99e Initial load duke parents: diff changeset	545 }
a61af66fc99e Initial load duke parents: diff changeset	546 }
a61af66fc99e Initial load duke parents: diff changeset	547
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	548 // 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	549 // (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	550 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	551 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	552 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	553 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	554 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	555 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	556 }
0 a61af66fc99e Initial load duke parents: diff changeset	557
a61af66fc99e Initial load duke parents: diff changeset	558 // Used only for markSweep, scavenging
a61af66fc99e Initial load duke parents: diff changeset	559 inline bool oopDesc::is_gc_marked() const {
a61af66fc99e Initial load duke parents: diff changeset	560 return mark()->is_marked();
a61af66fc99e Initial load duke parents: diff changeset	561 }
a61af66fc99e Initial load duke parents: diff changeset	562
a61af66fc99e Initial load duke parents: diff changeset	563 inline bool oopDesc::is_locked() const {
a61af66fc99e Initial load duke parents: diff changeset	564 return mark()->is_locked();
a61af66fc99e Initial load duke parents: diff changeset	565 }
a61af66fc99e Initial load duke parents: diff changeset	566
a61af66fc99e Initial load duke parents: diff changeset	567 inline bool oopDesc::is_unlocked() const {
a61af66fc99e Initial load duke parents: diff changeset	568 return mark()->is_unlocked();
a61af66fc99e Initial load duke parents: diff changeset	569 }
a61af66fc99e Initial load duke parents: diff changeset	570
a61af66fc99e Initial load duke parents: diff changeset	571 inline bool oopDesc::has_bias_pattern() const {
a61af66fc99e Initial load duke parents: diff changeset	572 return mark()->has_bias_pattern();
a61af66fc99e Initial load duke parents: diff changeset	573 }
a61af66fc99e Initial load duke parents: diff changeset	574
a61af66fc99e Initial load duke parents: diff changeset	575
a61af66fc99e Initial load duke parents: diff changeset	576 // used only for asserts
a61af66fc99e Initial load duke parents: diff changeset	577 inline bool oopDesc::is_oop(bool ignore_mark_word) const {
a61af66fc99e Initial load duke parents: diff changeset	578 oop obj = (oop) this;
a61af66fc99e Initial load duke parents: diff changeset	579 if (!check_obj_alignment(obj)) return false;
a61af66fc99e Initial load duke parents: diff changeset	580 if (!Universe::heap()->is_in_reserved(obj)) return false;
a61af66fc99e Initial load duke parents: diff changeset	581 // obj is aligned and accessible in heap
a61af66fc99e Initial load duke parents: diff changeset	582 // try to find metaclass cycle safely without seg faulting on bad input
a61af66fc99e Initial load duke parents: diff changeset	583 // we should reach klassKlassObj by following klass link at most 3 times
a61af66fc99e Initial load duke parents: diff changeset	584 for (int i = 0; i < 3; i++) {
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	585 obj = obj->klass_or_null();
0 a61af66fc99e Initial load duke parents: diff changeset	586 // klass should be aligned and in permspace
a61af66fc99e Initial load duke parents: diff changeset	587 if (!check_obj_alignment(obj)) return false;
a61af66fc99e Initial load duke parents: diff changeset	588 if (!Universe::heap()->is_in_permanent(obj)) return false;
a61af66fc99e Initial load duke parents: diff changeset	589 }
a61af66fc99e Initial load duke parents: diff changeset	590 if (obj != Universe::klassKlassObj()) {
a61af66fc99e Initial load duke parents: diff changeset	591 // During a dump, the _klassKlassObj moved to a shared space.
a61af66fc99e Initial load duke parents: diff changeset	592 if (DumpSharedSpaces && Universe::klassKlassObj()->is_shared()) {
a61af66fc99e Initial load duke parents: diff changeset	593 return true;
a61af66fc99e Initial load duke parents: diff changeset	594 }
a61af66fc99e Initial load duke parents: diff changeset	595 return false;
a61af66fc99e Initial load duke parents: diff changeset	596 }
a61af66fc99e Initial load duke parents: diff changeset	597
a61af66fc99e Initial load duke parents: diff changeset	598 // Header verification: the mark is typically non-NULL. If we're
a61af66fc99e Initial load duke parents: diff changeset	599 // at a safepoint, it must not be null.
a61af66fc99e Initial load duke parents: diff changeset	600 // Outside of a safepoint, the header could be changing (for example,
a61af66fc99e Initial load duke parents: diff changeset	601 // another thread could be inflating a lock on this object).
a61af66fc99e Initial load duke parents: diff changeset	602 if (ignore_mark_word) {
a61af66fc99e Initial load duke parents: diff changeset	603 return true;
a61af66fc99e Initial load duke parents: diff changeset	604 }
a61af66fc99e Initial load duke parents: diff changeset	605 if (mark() != NULL) {
a61af66fc99e Initial load duke parents: diff changeset	606 return true;
a61af66fc99e Initial load duke parents: diff changeset	607 }
a61af66fc99e Initial load duke parents: diff changeset	608 return !SafepointSynchronize::is_at_safepoint();
a61af66fc99e Initial load duke parents: diff changeset	609 }
a61af66fc99e Initial load duke parents: diff changeset	610
a61af66fc99e Initial load duke parents: diff changeset	611
a61af66fc99e Initial load duke parents: diff changeset	612 // used only for asserts
a61af66fc99e Initial load duke parents: diff changeset	613 inline bool oopDesc::is_oop_or_null(bool ignore_mark_word) const {
a61af66fc99e Initial load duke parents: diff changeset	614 return this == NULL ? true : is_oop(ignore_mark_word);
a61af66fc99e Initial load duke parents: diff changeset	615 }
a61af66fc99e Initial load duke parents: diff changeset	616
a61af66fc99e Initial load duke parents: diff changeset	617 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	618 // used only for asserts
a61af66fc99e Initial load duke parents: diff changeset	619 inline bool oopDesc::is_unlocked_oop() const {
a61af66fc99e Initial load duke parents: diff changeset	620 if (!Universe::heap()->is_in_reserved(this)) return false;
a61af66fc99e Initial load duke parents: diff changeset	621 return mark()->is_unlocked();
a61af66fc99e Initial load duke parents: diff changeset	622 }
a61af66fc99e Initial load duke parents: diff changeset	623 #endif // PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	624
a61af66fc99e Initial load duke parents: diff changeset	625 inline void oopDesc::follow_header() {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	626 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	627 MarkSweep::mark_and_push(compressed_klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	628 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	629 MarkSweep::mark_and_push(klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	630 }
0 a61af66fc99e Initial load duke parents: diff changeset	631 }
a61af66fc99e Initial load duke parents: diff changeset	632
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	633 inline void oopDesc::follow_contents(void) {
0 a61af66fc99e Initial load duke parents: diff changeset	634 assert (is_gc_marked(), "should be marked");
a61af66fc99e Initial load duke parents: diff changeset	635 blueprint()->oop_follow_contents(this);
a61af66fc99e Initial load duke parents: diff changeset	636 }
a61af66fc99e Initial load duke parents: diff changeset	637
a61af66fc99e Initial load duke parents: diff changeset	638
a61af66fc99e Initial load duke parents: diff changeset	639 // Used by scavengers
a61af66fc99e Initial load duke parents: diff changeset	640
a61af66fc99e Initial load duke parents: diff changeset	641 inline bool oopDesc::is_forwarded() const {
a61af66fc99e Initial load duke parents: diff changeset	642 // The extra heap check is needed since the obj might be locked, in which case the
a61af66fc99e Initial load duke parents: diff changeset	643 // mark would point to a stack location and have the sentinel bit cleared
a61af66fc99e Initial load duke parents: diff changeset	644 return mark()->is_marked();
a61af66fc99e Initial load duke parents: diff changeset	645 }
a61af66fc99e Initial load duke parents: diff changeset	646
a61af66fc99e Initial load duke parents: diff changeset	647 // Used by scavengers
a61af66fc99e Initial load duke parents: diff changeset	648 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	649 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	650 "forwarding to something not aligned");
0 a61af66fc99e Initial load duke parents: diff changeset	651 assert(Universe::heap()->is_in_reserved(p),
a61af66fc99e Initial load duke parents: diff changeset	652 "forwarding to something not in heap");
a61af66fc99e Initial load duke parents: diff changeset	653 markOop m = markOopDesc::encode_pointer_as_mark(p);
a61af66fc99e Initial load duke parents: diff changeset	654 assert(m->decode_pointer() == p, "encoding must be reversable");
a61af66fc99e Initial load duke parents: diff changeset	655 set_mark(m);
a61af66fc99e Initial load duke parents: diff changeset	656 }
a61af66fc99e Initial load duke parents: diff changeset	657
a61af66fc99e Initial load duke parents: diff changeset	658 // Used by parallel scavengers
a61af66fc99e Initial load duke parents: diff changeset	659 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	660 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	661 "forwarding to something not aligned");
0 a61af66fc99e Initial load duke parents: diff changeset	662 assert(Universe::heap()->is_in_reserved(p),
a61af66fc99e Initial load duke parents: diff changeset	663 "forwarding to something not in heap");
a61af66fc99e Initial load duke parents: diff changeset	664 markOop m = markOopDesc::encode_pointer_as_mark(p);
a61af66fc99e Initial load duke parents: diff changeset	665 assert(m->decode_pointer() == p, "encoding must be reversable");
a61af66fc99e Initial load duke parents: diff changeset	666 return cas_set_mark(m, compare) == compare;
a61af66fc99e Initial load duke parents: diff changeset	667 }
a61af66fc99e Initial load duke parents: diff changeset	668
a61af66fc99e Initial load duke parents: diff changeset	669 // Note that the forwardee is not the same thing as the displaced_mark.
a61af66fc99e Initial load duke parents: diff changeset	670 // The forwardee is used when copying during scavenge and mark-sweep.
a61af66fc99e Initial load duke parents: diff changeset	671 // 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	672 inline oop oopDesc::forwardee() const {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	673 return (oop) mark()->decode_pointer();
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	674 }
0 a61af66fc99e Initial load duke parents: diff changeset	675
a61af66fc99e Initial load duke parents: diff changeset	676 inline bool oopDesc::has_displaced_mark() const {
a61af66fc99e Initial load duke parents: diff changeset	677 return mark()->has_displaced_mark_helper();
a61af66fc99e Initial load duke parents: diff changeset	678 }
a61af66fc99e Initial load duke parents: diff changeset	679
a61af66fc99e Initial load duke parents: diff changeset	680 inline markOop oopDesc::displaced_mark() const {
a61af66fc99e Initial load duke parents: diff changeset	681 return mark()->displaced_mark_helper();
a61af66fc99e Initial load duke parents: diff changeset	682 }
a61af66fc99e Initial load duke parents: diff changeset	683
a61af66fc99e Initial load duke parents: diff changeset	684 inline void oopDesc::set_displaced_mark(markOop m) {
a61af66fc99e Initial load duke parents: diff changeset	685 mark()->set_displaced_mark_helper(m);
a61af66fc99e Initial load duke parents: diff changeset	686 }
a61af66fc99e Initial load duke parents: diff changeset	687
a61af66fc99e Initial load duke parents: diff changeset	688 // The following method needs to be MT safe.
a61af66fc99e Initial load duke parents: diff changeset	689 inline int oopDesc::age() const {
a61af66fc99e Initial load duke parents: diff changeset	690 assert(!is_forwarded(), "Attempt to read age from forwarded mark");
a61af66fc99e Initial load duke parents: diff changeset	691 if (has_displaced_mark()) {
a61af66fc99e Initial load duke parents: diff changeset	692 return displaced_mark()->age();
a61af66fc99e Initial load duke parents: diff changeset	693 } else {
a61af66fc99e Initial load duke parents: diff changeset	694 return mark()->age();
a61af66fc99e Initial load duke parents: diff changeset	695 }
a61af66fc99e Initial load duke parents: diff changeset	696 }
a61af66fc99e Initial load duke parents: diff changeset	697
a61af66fc99e Initial load duke parents: diff changeset	698 inline void oopDesc::incr_age() {
a61af66fc99e Initial load duke parents: diff changeset	699 assert(!is_forwarded(), "Attempt to increment age of forwarded mark");
a61af66fc99e Initial load duke parents: diff changeset	700 if (has_displaced_mark()) {
a61af66fc99e Initial load duke parents: diff changeset	701 set_displaced_mark(displaced_mark()->incr_age());
a61af66fc99e Initial load duke parents: diff changeset	702 } else {
a61af66fc99e Initial load duke parents: diff changeset	703 set_mark(mark()->incr_age());
a61af66fc99e Initial load duke parents: diff changeset	704 }
a61af66fc99e Initial load duke parents: diff changeset	705 }
a61af66fc99e Initial load duke parents: diff changeset	706
a61af66fc99e Initial load duke parents: diff changeset	707
a61af66fc99e Initial load duke parents: diff changeset	708 inline intptr_t oopDesc::identity_hash() {
a61af66fc99e Initial load duke parents: diff changeset	709 // Fast case; if the object is unlocked and the hash value is set, no locking is needed
a61af66fc99e Initial load duke parents: diff changeset	710 // Note: The mark must be read into local variable to avoid concurrent updates.
a61af66fc99e Initial load duke parents: diff changeset	711 markOop mrk = mark();
a61af66fc99e Initial load duke parents: diff changeset	712 if (mrk->is_unlocked() && !mrk->has_no_hash()) {
a61af66fc99e Initial load duke parents: diff changeset	713 return mrk->hash();
a61af66fc99e Initial load duke parents: diff changeset	714 } else if (mrk->is_marked()) {
a61af66fc99e Initial load duke parents: diff changeset	715 return mrk->hash();
a61af66fc99e Initial load duke parents: diff changeset	716 } else {
a61af66fc99e Initial load duke parents: diff changeset	717 return slow_identity_hash();
a61af66fc99e Initial load duke parents: diff changeset	718 }
a61af66fc99e Initial load duke parents: diff changeset	719 }
a61af66fc99e Initial load duke parents: diff changeset	720
a61af66fc99e Initial load duke parents: diff changeset	721 inline void oopDesc::oop_iterate_header(OopClosure* blk) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	722 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	723 blk->do_oop(compressed_klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	724 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	725 blk->do_oop(klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	726 }
0 a61af66fc99e Initial load duke parents: diff changeset	727 }
a61af66fc99e Initial load duke parents: diff changeset	728
a61af66fc99e Initial load duke parents: diff changeset	729 inline void oopDesc::oop_iterate_header(OopClosure* blk, MemRegion mr) {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	730 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	731 if (mr.contains(compressed_klass_addr())) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	732 blk->do_oop(compressed_klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	733 }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	734 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	735 if (mr.contains(klass_addr())) blk->do_oop(klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	736 }
0 a61af66fc99e Initial load duke parents: diff changeset	737 }
a61af66fc99e Initial load duke parents: diff changeset	738
a61af66fc99e Initial load duke parents: diff changeset	739 inline int oopDesc::adjust_pointers() {
a61af66fc99e Initial load duke parents: diff changeset	740 debug_only(int check_size = size());
a61af66fc99e Initial load duke parents: diff changeset	741 int s = blueprint()->oop_adjust_pointers(this);
a61af66fc99e Initial load duke parents: diff changeset	742 assert(s == check_size, "should be the same");
a61af66fc99e Initial load duke parents: diff changeset	743 return s;
a61af66fc99e Initial load duke parents: diff changeset	744 }
a61af66fc99e Initial load duke parents: diff changeset	745
a61af66fc99e Initial load duke parents: diff changeset	746 inline void oopDesc::adjust_header() {
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	747 if (UseCompressedOops) {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	748 MarkSweep::adjust_pointer(compressed_klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	749 } else {
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	750 MarkSweep::adjust_pointer(klass_addr());
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	751 }
0 a61af66fc99e Initial load duke parents: diff changeset	752 }
a61af66fc99e Initial load duke parents: diff changeset	753
a61af66fc99e Initial load duke parents: diff changeset	754 #define OOP_ITERATE_DEFN(OopClosureType, nv_suffix) \
a61af66fc99e Initial load duke parents: diff changeset	755 \
a61af66fc99e Initial load duke parents: diff changeset	756 inline int oopDesc::oop_iterate(OopClosureType* blk) { \
a61af66fc99e Initial load duke parents: diff changeset	757 SpecializationStats::record_call(); \
a61af66fc99e Initial load duke parents: diff changeset	758 return blueprint()->oop_oop_iterate##nv_suffix(this, blk); \
a61af66fc99e Initial load duke parents: diff changeset	759 } \
a61af66fc99e Initial load duke parents: diff changeset	760 \
a61af66fc99e Initial load duke parents: diff changeset	761 inline int oopDesc::oop_iterate(OopClosureType* blk, MemRegion mr) { \
a61af66fc99e Initial load duke parents: diff changeset	762 SpecializationStats::record_call(); \
a61af66fc99e Initial load duke parents: diff changeset	763 return blueprint()->oop_oop_iterate##nv_suffix##_m(this, blk, mr); \
a61af66fc99e Initial load duke parents: diff changeset	764 }
a61af66fc99e Initial load duke parents: diff changeset	765
a61af66fc99e Initial load duke parents: diff changeset	766 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DEFN)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	767 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DEFN)
0 a61af66fc99e Initial load duke parents: diff changeset	768
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	769 #ifndef SERIALGC
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	770 #define OOP_ITERATE_BACKWARDS_DEFN(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	771 \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	772 inline int oopDesc::oop_iterate_backwards(OopClosureType* blk) { \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	773 SpecializationStats::record_call(); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	774 return blueprint()->oop_oop_iterate_backwards##nv_suffix(this, blk); \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	775 }
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	776
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	777 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DEFN)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	778 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DEFN)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	779 #endif // !SERIALGC
0 a61af66fc99e Initial load duke parents: diff changeset	780
a61af66fc99e Initial load duke parents: diff changeset	781 inline bool oopDesc::is_shared() const {
a61af66fc99e Initial load duke parents: diff changeset	782 return CompactingPermGenGen::is_shared(this);
a61af66fc99e Initial load duke parents: diff changeset	783 }
a61af66fc99e Initial load duke parents: diff changeset	784
a61af66fc99e Initial load duke parents: diff changeset	785 inline bool oopDesc::is_shared_readonly() const {
a61af66fc99e Initial load duke parents: diff changeset	786 return CompactingPermGenGen::is_shared_readonly(this);
a61af66fc99e Initial load duke parents: diff changeset	787 }
a61af66fc99e Initial load duke parents: diff changeset	788
a61af66fc99e Initial load duke parents: diff changeset	789 inline bool oopDesc::is_shared_readwrite() const {
a61af66fc99e Initial load duke parents: diff changeset	790 return CompactingPermGenGen::is_shared_readwrite(this);
a61af66fc99e Initial load duke parents: diff changeset	791 }
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	792
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1846 diff changeset	793 #endif // SHARE_VM_OOPS_OOP_INLINE_HPP

Mercurial > hg > truffle

annotate src/share/vm/oops/oop.inline.hpp @ 3917:eca1193ca245