graal-compiler: src/share/vm/oops/oop.hpp annotate

annotate src/share/vm/oops/oop.hpp @ 10185:d50cc62e94ff

8012715: G1: GraphKit accesses PtrQueue::_index as int but is size_t Summary: In graphKit INT operations were generated to access PtrQueue::_index which has type size_t. This is 64 bit on 64-bit machines. No problems occur on little endian machines as long as the index fits into 32 bit, but on big endian machines the upper part is read, which is zero. This leads to unnecessary branches to the slow path in the runtime. Reviewed-by: twisti, johnc Contributed-by: Martin Doerr <martin.doerr@sap.com>

author	johnc
date	Wed, 24 Apr 2013 14:48:43 -0700
parents	db9981fd3124
children	740e263c80c6

rev	line source
0 a61af66fc99e Initial load duke parents: diff changeset	1 /*
6008 b632e80fc9dc 4988100: oop_verify_old_oop appears to be dead brutisso 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: 1123 diff changeset	19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
c18cbe5936b8 6941466: Oracle rebranding changes for Hotspot repositories trims parents: 1123 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: 1123 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: 1706 diff changeset	25 #ifndef SHARE_VM_OOPS_OOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	26 #define SHARE_VM_OOPS_OOP_HPP
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	27
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	28 #include "memory/iterator.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	29 #include "memory/memRegion.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	30 #include "memory/specialized_oop_closures.hpp"
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	31 #include "oops/metadata.hpp"
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	32 #include "utilities/macros.hpp"
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	33 #include "utilities/top.hpp"
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	34
0 a61af66fc99e Initial load duke parents: diff changeset	35 // oopDesc is the top baseclass for objects classes. The {name}Desc classes describe
a61af66fc99e Initial load duke parents: diff changeset	36 // the format of Java objects so the fields can be accessed from C++.
a61af66fc99e Initial load duke parents: diff changeset	37 // oopDesc is abstract.
a61af66fc99e Initial load duke parents: diff changeset	38 // (see oopHierarchy for complete oop class hierarchy)
a61af66fc99e Initial load duke parents: diff changeset	39 //
a61af66fc99e Initial load duke parents: diff changeset	40 // no virtual functions allowed
a61af66fc99e Initial load duke parents: diff changeset	41
a61af66fc99e Initial load duke parents: diff changeset	42 // store into oop with store check
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	43 template <class T> void oop_store(T* p, oop v);
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	44 template <class T> void oop_store(volatile T* p, oop v);
0 a61af66fc99e Initial load duke parents: diff changeset	45
a61af66fc99e Initial load duke parents: diff changeset	46 extern bool always_do_update_barrier;
a61af66fc99e Initial load duke parents: diff changeset	47
a61af66fc99e Initial load duke parents: diff changeset	48 // Forward declarations.
a61af66fc99e Initial load duke parents: diff changeset	49 class OopClosure;
a61af66fc99e Initial load duke parents: diff changeset	50 class ScanClosure;
a61af66fc99e Initial load duke parents: diff changeset	51 class FastScanClosure;
a61af66fc99e Initial load duke parents: diff changeset	52 class FilteringClosure;
a61af66fc99e Initial load duke parents: diff changeset	53 class BarrierSet;
a61af66fc99e Initial load duke parents: diff changeset	54 class CMSIsAliveClosure;
a61af66fc99e Initial load duke parents: diff changeset	55
a61af66fc99e Initial load duke parents: diff changeset	56 class PSPromotionManager;
a61af66fc99e Initial load duke parents: diff changeset	57 class ParCompactionManager;
a61af66fc99e Initial load duke parents: diff changeset	58
a61af66fc99e Initial load duke parents: diff changeset	59 class oopDesc {
a61af66fc99e Initial load duke parents: diff changeset	60 friend class VMStructs;
a61af66fc99e Initial load duke parents: diff changeset	61 private:
a61af66fc99e Initial load duke parents: diff changeset	62 volatile markOop _mark;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	63 union _metadata {
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	64 Klass* _klass;
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	65 narrowOop _compressed_klass;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	66 } _metadata;
0 a61af66fc99e Initial load duke parents: diff changeset	67
a61af66fc99e Initial load duke parents: diff changeset	68 // Fast access to barrier set. Must be initialized.
a61af66fc99e Initial load duke parents: diff changeset	69 static BarrierSet* _bs;
a61af66fc99e Initial load duke parents: diff changeset	70
a61af66fc99e Initial load duke parents: diff changeset	71 public:
a61af66fc99e Initial load duke parents: diff changeset	72 markOop mark() const { return _mark; }
a61af66fc99e Initial load duke parents: diff changeset	73 markOop* mark_addr() const { return (markOop*) &_mark; }
a61af66fc99e Initial load duke parents: diff changeset	74
a61af66fc99e Initial load duke parents: diff changeset	75 void set_mark(volatile markOop m) { _mark = m; }
a61af66fc99e Initial load duke parents: diff changeset	76
a61af66fc99e Initial load duke parents: diff changeset	77 void release_set_mark(markOop m);
a61af66fc99e Initial load duke parents: diff changeset	78 markOop cas_set_mark(markOop new_mark, markOop old_mark);
a61af66fc99e Initial load duke parents: diff changeset	79
a61af66fc99e Initial load duke parents: diff changeset	80 // Used only to re-initialize the mark word (e.g., of promoted
a61af66fc99e Initial load duke parents: diff changeset	81 // objects during a GC) -- requires a valid klass pointer
a61af66fc99e Initial load duke parents: diff changeset	82 void init_mark();
a61af66fc99e Initial load duke parents: diff changeset	83
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	84 Klass* klass() const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	85 Klass* klass_or_null() const volatile;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	86 Klass** klass_addr();
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	87 narrowOop* compressed_klass_addr();
0 a61af66fc99e Initial load duke parents: diff changeset	88
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	89 void set_klass(Klass* k);
167 feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	90
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	91 // For klass field compression
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	92 int klass_gap() const;
feeb96a45707 6696264: assert("narrow oop can never be zero") for GCBasher & ParNewGC coleenp parents: 135 diff changeset	93 void set_klass_gap(int z);
0 a61af66fc99e Initial load duke parents: diff changeset	94 // For when the klass pointer is being used as a linked list "next" field.
a61af66fc99e Initial load duke parents: diff changeset	95 void set_klass_to_list_ptr(oop k);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	96 oop list_ptr_from_klass();
0 a61af66fc99e Initial load duke parents: diff changeset	97
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	98 // size of object header, aligned to platform wordSize
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	99 static int header_size() { return sizeof(oopDesc)/HeapWordSize; }
0 a61af66fc99e Initial load duke parents: diff changeset	100
a61af66fc99e Initial load duke parents: diff changeset	101 // Returns whether this is an instance of k or an instance of a subclass of k
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	102 bool is_a(Klass* k) const;
0 a61af66fc99e Initial load duke parents: diff changeset	103
a61af66fc99e Initial load duke parents: diff changeset	104 // Returns the actual oop size of the object
a61af66fc99e Initial load duke parents: diff changeset	105 int size();
a61af66fc99e Initial load duke parents: diff changeset	106
a61af66fc99e Initial load duke parents: diff changeset	107 // Sometimes (for complicated concurrency-related reasons), it is useful
a61af66fc99e Initial load duke parents: diff changeset	108 // to be able to figure out the size of an object knowing its klass.
a61af66fc99e Initial load duke parents: diff changeset	109 int size_given_klass(Klass* klass);
a61af66fc99e Initial load duke parents: diff changeset	110
a61af66fc99e Initial load duke parents: diff changeset	111 // type test operations (inlined in oop.inline.h)
a61af66fc99e Initial load duke parents: diff changeset	112 bool is_instance() const;
2376 c7f3d0b4570f 7017732: move static fields into Class to prepare for perm gen removal never parents: 2227 diff changeset	113 bool is_instanceMirror() const;
0 a61af66fc99e Initial load duke parents: diff changeset	114 bool is_instanceRef() const;
a61af66fc99e Initial load duke parents: diff changeset	115 bool is_array() const;
a61af66fc99e Initial load duke parents: diff changeset	116 bool is_objArray() const;
a61af66fc99e Initial load duke parents: diff changeset	117 bool is_typeArray() const;
a61af66fc99e Initial load duke parents: diff changeset	118
a61af66fc99e Initial load duke parents: diff changeset	119 private:
a61af66fc99e Initial load duke parents: diff changeset	120 // field addresses in oop
a61af66fc99e Initial load duke parents: diff changeset	121 void* field_base(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	122
a61af66fc99e Initial load duke parents: diff changeset	123 jbyte* byte_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	124 jchar* char_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	125 jboolean* bool_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	126 jint* int_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	127 jshort* short_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	128 jlong* long_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	129 jfloat* float_field_addr(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	130 jdouble* double_field_addr(int offset) const;
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	131 Metadata** metadata_field_addr(int offset) const;
0 a61af66fc99e Initial load duke parents: diff changeset	132
a61af66fc99e Initial load duke parents: diff changeset	133 public:
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	134 // Need this as public for garbage collection.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	135 template <class T> T* obj_field_addr(int offset) const;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	136
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	137 // Needed for javaClasses
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	138 address* address_field_addr(int offset) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	139
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	140 static bool is_null(oop obj);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	141 static bool is_null(narrowOop obj);
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	142 static bool is_null(Klass* obj);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	143
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	144 // Decode an oop pointer from a narrowOop if compressed.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	145 // These are overloaded for oop and narrowOop as are the other functions
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	146 // below so that they can be called in template functions.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	147 static oop decode_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	148 static oop 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	149 static oop decode_heap_oop(oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	150 static oop decode_heap_oop(narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	151
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	152 // Encode an oop pointer to a narrow oop. The or_null versions accept
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	153 // null oop pointer, others do not in order to eliminate the
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	154 // null checking branches.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	155 static narrowOop 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	156 static narrowOop encode_heap_oop(oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	157
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	158 // Load an oop out of the Java heap
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	159 static narrowOop load_heap_oop(narrowOop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	160 static oop load_heap_oop(oop* p);
0 a61af66fc99e Initial load duke parents: diff changeset	161
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	162 // Load an oop out of Java heap and decode it to an uncompressed oop.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	163 static oop 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	164 static oop load_decode_heap_oop_not_null(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	165 static oop 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	166 static oop load_decode_heap_oop(oop* p);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	167
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	168 // Store an oop into the heap.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	169 static void store_heap_oop(narrowOop* p, narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	170 static void store_heap_oop(oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	171
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	172 // Encode oop if UseCompressedOops and store into the heap.
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	173 static void 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	174 static void encode_store_heap_oop_not_null(oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	175 static void 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	176 static void encode_store_heap_oop(oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	177
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	178 static void release_store_heap_oop(volatile narrowOop* p, narrowOop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	179 static void 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	180
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	181 static void release_encode_store_heap_oop_not_null(volatile narrowOop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	182 static void release_encode_store_heap_oop_not_null(volatile oop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	183 static void release_encode_store_heap_oop(volatile narrowOop* p, oop v);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	184 static void release_encode_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	185
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	186 static oop 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	187 static oop atomic_compare_exchange_oop(oop exchange_value,
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	188 volatile HeapWord *dest,
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	189 oop compare_value,
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	190 bool prebarrier = false);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	191
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	192 // klass encoding for klass pointer in objects.
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	193 static narrowOop encode_klass_not_null(Klass* v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	194 static narrowOop encode_klass(Klass* v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	195
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	196 static Klass* decode_klass_not_null(narrowOop v);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	197 static Klass* decode_klass(narrowOop v);
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	198
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	199 // Access to fields in a instanceOop through these methods.
0 a61af66fc99e Initial load duke parents: diff changeset	200 oop obj_field(int offset) const;
3932 b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	201 volatile oop obj_field_volatile(int offset) const;
0 a61af66fc99e Initial load duke parents: diff changeset	202 void obj_field_put(int offset, oop value);
3932 b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	203 void obj_field_put_raw(int offset, oop value);
b0efc7ee3b31 7085860: JSR 292: implement CallSite.setTargetNormal and setTargetVolatile as native methods twisti parents: 2376 diff changeset	204 void obj_field_put_volatile(int offset, oop value);
0 a61af66fc99e Initial load duke parents: diff changeset	205
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	206 Metadata* metadata_field(int offset) const;
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	207 void metadata_field_put(int offset, Metadata* value);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	208
0 a61af66fc99e Initial load duke parents: diff changeset	209 jbyte byte_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	210 void byte_field_put(int offset, jbyte contents);
a61af66fc99e Initial load duke parents: diff changeset	211
a61af66fc99e Initial load duke parents: diff changeset	212 jchar char_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	213 void char_field_put(int offset, jchar contents);
a61af66fc99e Initial load duke parents: diff changeset	214
a61af66fc99e Initial load duke parents: diff changeset	215 jboolean bool_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	216 void bool_field_put(int offset, jboolean contents);
a61af66fc99e Initial load duke parents: diff changeset	217
a61af66fc99e Initial load duke parents: diff changeset	218 jint int_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	219 void int_field_put(int offset, jint contents);
a61af66fc99e Initial load duke parents: diff changeset	220
a61af66fc99e Initial load duke parents: diff changeset	221 jshort short_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	222 void short_field_put(int offset, jshort contents);
a61af66fc99e Initial load duke parents: diff changeset	223
a61af66fc99e Initial load duke parents: diff changeset	224 jlong long_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	225 void long_field_put(int offset, jlong contents);
a61af66fc99e Initial load duke parents: diff changeset	226
a61af66fc99e Initial load duke parents: diff changeset	227 jfloat float_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	228 void float_field_put(int offset, jfloat contents);
a61af66fc99e Initial load duke parents: diff changeset	229
a61af66fc99e Initial load duke parents: diff changeset	230 jdouble double_field(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	231 void double_field_put(int offset, jdouble contents);
a61af66fc99e Initial load duke parents: diff changeset	232
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	233 address address_field(int offset) const;
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	234 void address_field_put(int offset, address contents);
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	235
0 a61af66fc99e Initial load duke parents: diff changeset	236 oop obj_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	237 void release_obj_field_put(int offset, oop value);
a61af66fc99e Initial load duke parents: diff changeset	238
a61af66fc99e Initial load duke parents: diff changeset	239 jbyte byte_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	240 void release_byte_field_put(int offset, jbyte contents);
a61af66fc99e Initial load duke parents: diff changeset	241
a61af66fc99e Initial load duke parents: diff changeset	242 jchar char_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	243 void release_char_field_put(int offset, jchar contents);
a61af66fc99e Initial load duke parents: diff changeset	244
a61af66fc99e Initial load duke parents: diff changeset	245 jboolean bool_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	246 void release_bool_field_put(int offset, jboolean contents);
a61af66fc99e Initial load duke parents: diff changeset	247
a61af66fc99e Initial load duke parents: diff changeset	248 jint int_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	249 void release_int_field_put(int offset, jint contents);
a61af66fc99e Initial load duke parents: diff changeset	250
a61af66fc99e Initial load duke parents: diff changeset	251 jshort short_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	252 void release_short_field_put(int offset, jshort contents);
a61af66fc99e Initial load duke parents: diff changeset	253
a61af66fc99e Initial load duke parents: diff changeset	254 jlong long_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	255 void release_long_field_put(int offset, jlong contents);
a61af66fc99e Initial load duke parents: diff changeset	256
a61af66fc99e Initial load duke parents: diff changeset	257 jfloat float_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	258 void release_float_field_put(int offset, jfloat contents);
a61af66fc99e Initial load duke parents: diff changeset	259
a61af66fc99e Initial load duke parents: diff changeset	260 jdouble double_field_acquire(int offset) const;
a61af66fc99e Initial load duke parents: diff changeset	261 void release_double_field_put(int offset, jdouble contents);
a61af66fc99e Initial load duke parents: diff changeset	262
710 e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 579 diff changeset	263 address address_field_acquire(int offset) const;
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 579 diff changeset	264 void release_address_field_put(int offset, address contents);
e5b0439ef4ae 6655638: dynamic languages need method handles jrose parents: 579 diff changeset	265
0 a61af66fc99e Initial load duke parents: diff changeset	266 // printing functions for VM debugging
a61af66fc99e Initial load duke parents: diff changeset	267 void print_on(outputStream* st) const; // First level print
a61af66fc99e Initial load duke parents: diff changeset	268 void print_value_on(outputStream* st) const; // Second level print.
a61af66fc99e Initial load duke parents: diff changeset	269 void print_address_on(outputStream* st) const; // Address printing
a61af66fc99e Initial load duke parents: diff changeset	270
a61af66fc99e Initial load duke parents: diff changeset	271 // printing on default output stream
a61af66fc99e Initial load duke parents: diff changeset	272 void print();
a61af66fc99e Initial load duke parents: diff changeset	273 void print_value();
a61af66fc99e Initial load duke parents: diff changeset	274 void print_address();
a61af66fc99e Initial load duke parents: diff changeset	275
a61af66fc99e Initial load duke parents: diff changeset	276 // return the print strings
a61af66fc99e Initial load duke parents: diff changeset	277 char* print_string();
a61af66fc99e Initial load duke parents: diff changeset	278 char* print_value_string();
a61af66fc99e Initial load duke parents: diff changeset	279
a61af66fc99e Initial load duke parents: diff changeset	280 // verification operations
a61af66fc99e Initial load duke parents: diff changeset	281 void verify_on(outputStream* st);
a61af66fc99e Initial load duke parents: diff changeset	282 void verify();
a61af66fc99e Initial load duke parents: diff changeset	283
a61af66fc99e Initial load duke parents: diff changeset	284 // locking operations
a61af66fc99e Initial load duke parents: diff changeset	285 bool is_locked() const;
a61af66fc99e Initial load duke parents: diff changeset	286 bool is_unlocked() const;
a61af66fc99e Initial load duke parents: diff changeset	287 bool has_bias_pattern() const;
a61af66fc99e Initial load duke parents: diff changeset	288
a61af66fc99e Initial load duke parents: diff changeset	289 // asserts
a61af66fc99e Initial load duke parents: diff changeset	290 bool is_oop(bool ignore_mark_word = false) const;
a61af66fc99e Initial load duke parents: diff changeset	291 bool is_oop_or_null(bool ignore_mark_word = false) const;
a61af66fc99e Initial load duke parents: diff changeset	292 #ifndef PRODUCT
a61af66fc99e Initial load duke parents: diff changeset	293 bool is_unlocked_oop() const;
a61af66fc99e Initial load duke parents: diff changeset	294 #endif
a61af66fc99e Initial load duke parents: diff changeset	295
a61af66fc99e Initial load duke parents: diff changeset	296 // garbage collection
a61af66fc99e Initial load duke parents: diff changeset	297 bool is_gc_marked() const;
a61af66fc99e Initial load duke parents: diff changeset	298 // Apply "MarkSweep::mark_and_push" to (the address of) every non-NULL
a61af66fc99e Initial load duke parents: diff changeset	299 // reference field in "this".
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	300 void follow_contents(void);
0 a61af66fc99e Initial load duke parents: diff changeset	301
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	302 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	303 // Parallel Scavenge
a61af66fc99e Initial load duke parents: diff changeset	304 void push_contents(PSPromotionManager* pm);
a61af66fc99e Initial load duke parents: diff changeset	305
a61af66fc99e Initial load duke parents: diff changeset	306 // Parallel Old
a61af66fc99e Initial load duke parents: diff changeset	307 void update_contents(ParCompactionManager* cm);
a61af66fc99e Initial load duke parents: diff changeset	308
a61af66fc99e Initial load duke parents: diff changeset	309 void follow_contents(ParCompactionManager* cm);
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	310 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	311
989 148e5441d916 6863023: need non-perm oops in code cache for JSR 292 jrose parents: 710 diff changeset	312 bool is_scavengable() const;
0 a61af66fc99e Initial load duke parents: diff changeset	313
a61af66fc99e Initial load duke parents: diff changeset	314 // Forward pointer operations for scavenge
a61af66fc99e Initial load duke parents: diff changeset	315 bool is_forwarded() const;
a61af66fc99e Initial load duke parents: diff changeset	316
a61af66fc99e Initial load duke parents: diff changeset	317 void forward_to(oop p);
a61af66fc99e Initial load duke parents: diff changeset	318 bool cas_forward_to(oop p, markOop compare);
a61af66fc99e Initial load duke parents: diff changeset	319
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	320 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	321 // Like "forward_to", but inserts the forwarding pointer atomically.
a61af66fc99e Initial load duke parents: diff changeset	322 // Exactly one thread succeeds in inserting the forwarding pointer, and
a61af66fc99e Initial load duke parents: diff changeset	323 // this call returns "NULL" for that thread; any other thread has the
a61af66fc99e Initial load duke parents: diff changeset	324 // value of the forwarding pointer returned and does not modify "this".
a61af66fc99e Initial load duke parents: diff changeset	325 oop forward_to_atomic(oop p);
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	326 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	327
a61af66fc99e Initial load duke parents: diff changeset	328 oop forwardee() const;
a61af66fc99e Initial load duke parents: diff changeset	329
a61af66fc99e Initial load duke parents: diff changeset	330 // Age of object during scavenge
6818 22b8d3d181d9 8000351: Tenuring threshold should be unsigned jwilhelm parents: 6725 diff changeset	331 uint age() const;
0 a61af66fc99e Initial load duke parents: diff changeset	332 void incr_age();
a61af66fc99e Initial load duke parents: diff changeset	333
a61af66fc99e Initial load duke parents: diff changeset	334 // Adjust all pointers in this object to point at it's forwarded location and
a61af66fc99e Initial load duke parents: diff changeset	335 // return the size of this oop. This is used by the MarkSweep collector.
a61af66fc99e Initial load duke parents: diff changeset	336 int adjust_pointers();
a61af66fc99e Initial load duke parents: diff changeset	337
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	338 #if INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	339 // Parallel old
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	340 void update_header(ParCompactionManager* cm);
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	341 #endif // INCLUDE_ALL_GCS
0 a61af66fc99e Initial load duke parents: diff changeset	342
a61af66fc99e Initial load duke parents: diff changeset	343 // mark-sweep support
a61af66fc99e Initial load duke parents: diff changeset	344 void follow_body(int begin, int end);
a61af66fc99e Initial load duke parents: diff changeset	345
a61af66fc99e Initial load duke parents: diff changeset	346 // Fast access to barrier set
a61af66fc99e Initial load duke parents: diff changeset	347 static BarrierSet* bs() { return _bs; }
a61af66fc99e Initial load duke parents: diff changeset	348 static void set_bs(BarrierSet* bs) { _bs = bs; }
a61af66fc99e Initial load duke parents: diff changeset	349
a61af66fc99e Initial load duke parents: diff changeset	350 // iterators, returns size of object
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	351 #define OOP_ITERATE_DECL(OopClosureType, nv_suffix) \
0 a61af66fc99e Initial load duke parents: diff changeset	352 int oop_iterate(OopClosureType* blk); \
a61af66fc99e Initial load duke parents: diff changeset	353 int oop_iterate(OopClosureType* blk, MemRegion mr); // Only in mr.
a61af66fc99e Initial load duke parents: diff changeset	354
a61af66fc99e Initial load duke parents: diff changeset	355 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_DECL)
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	356 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	357
8001 db9981fd3124 8005915: Unify SERIALGC and INCLUDE_ALTERNATE_GCS jprovino parents: 6818 diff changeset	358 #if INCLUDE_ALL_GCS
342 37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	359
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	360 #define OOP_ITERATE_BACKWARDS_DECL(OopClosureType, nv_suffix) \
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	361 int oop_iterate_backwards(OopClosureType* blk);
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	362
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	363 ALL_OOP_OOP_ITERATE_CLOSURES_1(OOP_ITERATE_BACKWARDS_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	364 ALL_OOP_OOP_ITERATE_CLOSURES_2(OOP_ITERATE_BACKWARDS_DECL)
37f87013dfd8 6711316: Open source the Garbage-First garbage collector ysr parents: 135 diff changeset	365 #endif
0 a61af66fc99e Initial load duke parents: diff changeset	366
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	367 int oop_iterate_no_header(OopClosure* bk);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	368 int oop_iterate_no_header(OopClosure* bk, MemRegion mr);
0 a61af66fc99e Initial load duke parents: diff changeset	369
a61af66fc99e Initial load duke parents: diff changeset	370 // identity hash; returns the identity hash key (computes it if necessary)
a61af66fc99e Initial load duke parents: diff changeset	371 // NOTE with the introduction of UseBiasedLocking that identity_hash() might reach a
a61af66fc99e Initial load duke parents: diff changeset	372 // safepoint if called on a biased object. Calling code must be aware of that.
a61af66fc99e Initial load duke parents: diff changeset	373 intptr_t identity_hash();
a61af66fc99e Initial load duke parents: diff changeset	374 intptr_t slow_identity_hash();
a61af66fc99e Initial load duke parents: diff changeset	375
6725 da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	376 // Alternate hashing code if string table is rehashed
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	377 unsigned int new_hash(jint seed);
da91efe96a93 6964458: Reimplement class meta-data storage to use native memory coleenp parents: 6008 diff changeset	378
0 a61af66fc99e Initial load duke parents: diff changeset	379 // marks are forwarded to stack when object is locked
a61af66fc99e Initial load duke parents: diff changeset	380 bool has_displaced_mark() const;
a61af66fc99e Initial load duke parents: diff changeset	381 markOop displaced_mark() const;
a61af66fc99e Initial load duke parents: diff changeset	382 void set_displaced_mark(markOop m);
a61af66fc99e Initial load duke parents: diff changeset	383
a61af66fc99e Initial load duke parents: diff changeset	384 // for code generation
a61af66fc99e Initial load duke parents: diff changeset	385 static int mark_offset_in_bytes() { return offset_of(oopDesc, _mark); }
113 ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	386 static int klass_offset_in_bytes() { return offset_of(oopDesc, _metadata._klass); }
ba764ed4b6f2 6420645: Create a vm that uses compressed oops for up to 32gb heapsizes coleenp parents: 0 diff changeset	387 static int klass_gap_offset_in_bytes();
0 a61af66fc99e Initial load duke parents: diff changeset	388 };
1972 f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	389
f95d63e2154a 6989984: Use standard include model for Hospot stefank parents: 1706 diff changeset	390 #endif // SHARE_VM_OOPS_OOP_HPP

Mercurial > hg > graal-compiler

annotate src/share/vm/oops/oop.hpp @ 10185:d50cc62e94ff