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

annotate src/share/vm/oops/oop.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	db9981fd3124

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

Mercurial > hg > truffle

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