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

annotate src/share/vm/oops/oop.inline.hpp @ 6862:8a5ea0a9ccc4

7127708: G1: change task num types from int to uint in concurrent mark Summary: Change the type of various task num fields, parameters etc to unsigned and rename them to be more consistent with the other collectors. Code changes were also reviewed by Vitaly Davidovich. Reviewed-by: johnc Contributed-by: Kaushik Srenevasan <kaushik@twitter.com>

author	johnc
date	Sat, 06 Oct 2012 01:17:44 -0700
parents	22b8d3d181d9
children	8e47bac5643a

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

Mercurial > hg > truffle

annotate src/share/vm/oops/oop.inline.hpp @ 6862:8a5ea0a9ccc4