13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/altHashing.hpp"
27 #include "classfile/javaClasses.inline.hpp"
28 #include "gc/shared/collectedHeap.inline.hpp"
29 #include "gc/shared/gc_globals.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "memory/universe.hpp"
32 #include "oops/access.inline.hpp"
33 #include "oops/compressedOops.inline.hpp"
34 #include "oops/oop.inline.hpp"
35 #include "oops/verifyOopClosure.hpp"
36 #include "runtime/handles.inline.hpp"
37 #include "runtime/javaThread.hpp"
38 #include "runtime/synchronizer.hpp"
39 #include "utilities/macros.hpp"
40
41 void oopDesc::print_on(outputStream* st) const {
42 if (*((juint*)this) == badHeapWordVal) {
43 st->print_cr("BAD WORD");
44 } else if (*((juint*)this) == badMetaWordVal) {
45 st->print_cr("BAD META WORD");
46 } else {
47 klass()->oop_print_on(cast_to_oop(this), st);
48 }
49 }
50
51 void oopDesc::print_address_on(outputStream* st) const {
52 st->print("{" PTR_FORMAT "}", p2i(this));
53
54 }
55
56 void oopDesc::print_name_on(outputStream* st) const {
138
139 VerifyOopClosure VerifyOopClosure::verify_oop;
140
141 template <class T> void VerifyOopClosure::do_oop_work(T* p) {
142 oop obj = RawAccess<>::oop_load(p);
143 guarantee(oopDesc::is_oop_or_null(obj), "invalid oop: " PTR_FORMAT, p2i(obj));
144 }
145
146 void VerifyOopClosure::do_oop(oop* p) { VerifyOopClosure::do_oop_work(p); }
147 void VerifyOopClosure::do_oop(narrowOop* p) { VerifyOopClosure::do_oop_work(p); }
148
149 // type test operations that doesn't require inclusion of oop.inline.hpp.
150 bool oopDesc::is_instance_noinline() const { return is_instance(); }
151 bool oopDesc::is_instanceRef_noinline() const { return is_instanceRef(); }
152 bool oopDesc::is_stackChunk_noinline() const { return is_stackChunk(); }
153 bool oopDesc::is_array_noinline() const { return is_array(); }
154 bool oopDesc::is_objArray_noinline() const { return is_objArray(); }
155 bool oopDesc::is_typeArray_noinline() const { return is_typeArray(); }
156
157 bool oopDesc::has_klass_gap() {
158 // Only has a klass gap when compressed class pointers are used.
159 return UseCompressedClassPointers;
160 }
161
162 #if INCLUDE_CDS_JAVA_HEAP
163 void oopDesc::set_narrow_klass(narrowKlass nk) {
164 assert(DumpSharedSpaces, "Used by CDS only. Do not abuse!");
165 assert(UseCompressedClassPointers, "must be");
166 _metadata._compressed_klass = nk;
167 }
168 #endif
169
170 void* oopDesc::load_klass_raw(oop obj) {
171 if (UseCompressedClassPointers) {
172 narrowKlass narrow_klass = obj->_metadata._compressed_klass;
173 if (narrow_klass == 0) return nullptr;
174 return (void*)CompressedKlassPointers::decode_raw(narrow_klass);
175 } else {
176 return obj->_metadata._klass;
177 }
178 }
179
180 void* oopDesc::load_oop_raw(oop obj, int offset) {
181 uintptr_t addr = (uintptr_t)(void*)obj + (uint)offset;
182 if (UseCompressedOops) {
183 narrowOop narrow_oop = *(narrowOop*)addr;
184 if (CompressedOops::is_null(narrow_oop)) return nullptr;
185 return (void*)CompressedOops::decode_raw(narrow_oop);
186 } else {
187 return *(void**)addr;
188 }
189 }
190
191 oop oopDesc::obj_field_acquire(int offset) const { return HeapAccess<MO_ACQUIRE>::oop_load_at(as_oop(), offset); }
192
193 void oopDesc::obj_field_put_raw(int offset, oop value) { RawAccess<>::oop_store_at(as_oop(), offset, value); }
194 void oopDesc::release_obj_field_put(int offset, oop value) { HeapAccess<MO_RELEASE>::oop_store_at(as_oop(), offset, value); }
195 void oopDesc::obj_field_put_volatile(int offset, oop value) { HeapAccess<MO_SEQ_CST>::oop_store_at(as_oop(), offset, value); }
196
197 address oopDesc::address_field(int offset) const { return *field_addr<address>(offset); }
|
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/altHashing.hpp"
27 #include "classfile/javaClasses.inline.hpp"
28 #include "gc/shared/collectedHeap.inline.hpp"
29 #include "gc/shared/gc_globals.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "memory/universe.hpp"
32 #include "oops/access.inline.hpp"
33 #include "oops/compressedKlass.inline.hpp"
34 #include "oops/compressedOops.inline.hpp"
35 #include "oops/oop.inline.hpp"
36 #include "oops/verifyOopClosure.hpp"
37 #include "runtime/handles.inline.hpp"
38 #include "runtime/interfaceSupport.inline.hpp"
39 #include "runtime/javaThread.hpp"
40 #include "runtime/synchronizer.hpp"
41 #include "utilities/macros.hpp"
42
43 void oopDesc::print_on(outputStream* st) const {
44 if (*((juint*)this) == badHeapWordVal) {
45 st->print_cr("BAD WORD");
46 } else if (*((juint*)this) == badMetaWordVal) {
47 st->print_cr("BAD META WORD");
48 } else {
49 klass()->oop_print_on(cast_to_oop(this), st);
50 }
51 }
52
53 void oopDesc::print_address_on(outputStream* st) const {
54 st->print("{" PTR_FORMAT "}", p2i(this));
55
56 }
57
58 void oopDesc::print_name_on(outputStream* st) const {
140
141 VerifyOopClosure VerifyOopClosure::verify_oop;
142
143 template <class T> void VerifyOopClosure::do_oop_work(T* p) {
144 oop obj = RawAccess<>::oop_load(p);
145 guarantee(oopDesc::is_oop_or_null(obj), "invalid oop: " PTR_FORMAT, p2i(obj));
146 }
147
148 void VerifyOopClosure::do_oop(oop* p) { VerifyOopClosure::do_oop_work(p); }
149 void VerifyOopClosure::do_oop(narrowOop* p) { VerifyOopClosure::do_oop_work(p); }
150
151 // type test operations that doesn't require inclusion of oop.inline.hpp.
152 bool oopDesc::is_instance_noinline() const { return is_instance(); }
153 bool oopDesc::is_instanceRef_noinline() const { return is_instanceRef(); }
154 bool oopDesc::is_stackChunk_noinline() const { return is_stackChunk(); }
155 bool oopDesc::is_array_noinline() const { return is_array(); }
156 bool oopDesc::is_objArray_noinline() const { return is_objArray(); }
157 bool oopDesc::is_typeArray_noinline() const { return is_typeArray(); }
158
159 bool oopDesc::has_klass_gap() {
160 // Only has a klass gap when compressed class pointers are used, but
161 // only if not using compact headers..
162 return UseCompressedClassPointers && !UseCompactObjectHeaders;
163 }
164
165 #if INCLUDE_CDS_JAVA_HEAP
166 void oopDesc::set_narrow_klass(narrowKlass nk) {
167 assert(DumpSharedSpaces, "Used by CDS only. Do not abuse!");
168 assert(UseCompressedClassPointers, "must be");
169 if (UseCompactObjectHeaders) {
170 set_mark(mark().set_narrow_klass(nk));
171 } else {
172 _metadata._compressed_klass = nk;
173 }
174 }
175 #endif
176
177 void* oopDesc::load_klass_raw(oop obj) {
178 // TODO: Remove method altogether and replace with calls to obj->klass() ?
179 // OTOH, we may eventually get rid of locking in header, and then no
180 // longer have to deal with that anymore.
181 #ifdef _LP64
182 return obj->klass();
183 #else
184 return obj->_metadata._klass;
185 #endif
186 }
187
188 void* oopDesc::load_oop_raw(oop obj, int offset) {
189 uintptr_t addr = (uintptr_t)(void*)obj + (uint)offset;
190 if (UseCompressedOops) {
191 narrowOop narrow_oop = *(narrowOop*)addr;
192 if (CompressedOops::is_null(narrow_oop)) return nullptr;
193 return (void*)CompressedOops::decode_raw(narrow_oop);
194 } else {
195 return *(void**)addr;
196 }
197 }
198
199 oop oopDesc::obj_field_acquire(int offset) const { return HeapAccess<MO_ACQUIRE>::oop_load_at(as_oop(), offset); }
200
201 void oopDesc::obj_field_put_raw(int offset, oop value) { RawAccess<>::oop_store_at(as_oop(), offset, value); }
202 void oopDesc::release_obj_field_put(int offset, oop value) { HeapAccess<MO_RELEASE>::oop_store_at(as_oop(), offset, value); }
203 void oopDesc::obj_field_put_volatile(int offset, oop value) { HeapAccess<MO_SEQ_CST>::oop_store_at(as_oop(), offset, value); }
204
205 address oopDesc::address_field(int offset) const { return *field_addr<address>(offset); }
|