1 /*
  2  * Copyright (c) 2015, 2025, Oracle and/or its affiliates. All rights reserved.
  3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  4  *
  5  * This code is free software; you can redistribute it and/or modify it
  6  * under the terms of the GNU General Public License version 2 only, as
  7  * published by the Free Software Foundation.
  8  *
  9  * This code is distributed in the hope that it will be useful, but WITHOUT
 10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 12  * version 2 for more details (a copy is included in the LICENSE file that
 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 #ifndef SHARE_CLASSFILE_JAVACLASSES_INLINE_HPP
 26 #define SHARE_CLASSFILE_JAVACLASSES_INLINE_HPP
 27 
 28 #include "classfile/javaClasses.hpp"
 29 
 30 #include "memory/referenceType.hpp"
 31 #include "oops/access.inline.hpp"
 32 #include "oops/instanceKlass.inline.hpp"
 33 #include "oops/method.hpp"
 34 #include "oops/oop.inline.hpp"
 35 #include "oops/oopsHierarchy.hpp"
 36 #include "oops/typeArrayOop.inline.hpp"
 37 
 38 void java_lang_String::set_coder(oop string, jbyte coder) {
 39   string->byte_field_put(_coder_offset, coder);
 40 }
 41 
 42 void java_lang_String::set_value(oop string, typeArrayOop buffer) {
 43   string->obj_field_put(_value_offset, buffer);
 44 }
 45 
 46 bool java_lang_String::hash_is_set(oop java_string) {
 47   return java_string->int_field(_hash_offset) != 0 || java_string->bool_field(_hashIsZero_offset) != 0;
 48 }
 49 
 50 // Accessors
 51 bool java_lang_String::value_equals(typeArrayOop str_value1, typeArrayOop str_value2) {
 52   return ((str_value1 == str_value2) ||
 53           (str_value1->length() == str_value2->length() &&
 54            (!memcmp(str_value1->base(T_BYTE),
 55                     str_value2->base(T_BYTE),
 56                     str_value2->length() * sizeof(jbyte)))));
 57 }
 58 
 59 typeArrayOop java_lang_String::value(oop java_string) {
 60   assert(is_instance(java_string), "must be java_string");
 61   return (typeArrayOop) java_string->obj_field(_value_offset);
 62 }
 63 
 64 typeArrayOop java_lang_String::value_no_keepalive(oop java_string) {
 65   assert(is_instance(java_string), "must be java_string");
 66   return (typeArrayOop) java_string->obj_field_access<AS_NO_KEEPALIVE>(_value_offset);
 67 }
 68 
 69 bool java_lang_String::is_latin1(oop java_string) {
 70   assert(is_instance(java_string), "must be java_string");
 71   jbyte coder = java_string->byte_field(_coder_offset);
 72   assert(CompactStrings || coder == CODER_UTF16, "Must be UTF16 without CompactStrings");
 73   return coder == CODER_LATIN1;
 74 }
 75 
 76 uint8_t* java_lang_String::flags_addr(oop java_string) {
 77   assert(_initialized, "Must be initialized");
 78   assert(is_instance(java_string), "Must be java string");
 79   return java_string->field_addr<uint8_t>(_flags_offset);
 80 }
 81 
 82 bool java_lang_String::is_flag_set(oop java_string, uint8_t flag_mask) {
 83   return (AtomicAccess::load(flags_addr(java_string)) & flag_mask) != 0;
 84 }
 85 
 86 bool java_lang_String::deduplication_forbidden(oop java_string) {
 87   return is_flag_set(java_string, _deduplication_forbidden_mask);
 88 }
 89 
 90 bool java_lang_String::deduplication_requested(oop java_string) {
 91   return is_flag_set(java_string, _deduplication_requested_mask);
 92 }
 93 
 94 void java_lang_String::set_deduplication_forbidden(oop java_string) {
 95   test_and_set_flag(java_string, _deduplication_forbidden_mask);
 96 }
 97 
 98 bool java_lang_String::test_and_set_deduplication_requested(oop java_string) {
 99   return test_and_set_flag(java_string, _deduplication_requested_mask);
100 }
101 
102 int java_lang_String::length(oop java_string, typeArrayOop value) {
103   assert(_initialized, "Must be initialized");
104   assert(is_instance(java_string), "must be java_string");
105   assert(value_equals(value, java_lang_String::value(java_string)),
106          "value must be equal to java_lang_String::value(java_string)");
107   if (value == nullptr) {
108     return 0;
109   }
110   int arr_length = value->length();
111   if (!is_latin1(java_string)) {
112     assert((arr_length & 1) == 0, "should be even for UTF16 string");
113     arr_length >>= 1; // convert number of bytes to number of elements
114   }
115   return arr_length;
116 }
117 
118 int java_lang_String::length(oop java_string) {
119   assert(_initialized, "Must be initialized");
120   assert(is_instance(java_string), "must be java_string");
121   typeArrayOop value = java_lang_String::value_no_keepalive(java_string);
122   return length(java_string, value);
123 }
124 
125 bool java_lang_String::is_instance(oop obj) {
126   return obj != nullptr && obj->klass() == vmClasses::String_klass();
127 }
128 
129 // We need to be able to check if this is a string even when we are in an
130 // erroneous state where the klass is corrupted/can't be read safely.
131 // This happens when printing an oop during GC error reporting.
132 bool java_lang_String::is_instance_without_asserts(oop obj) {
133   return obj != nullptr && obj->klass_without_asserts() == vmClasses::String_klass();
134 }
135 
136 // Accessors
137 
138 oop java_lang_ref_Reference::weak_referent_no_keepalive(oop ref) {
139   assert(java_lang_ref_Reference::is_weak(ref) || java_lang_ref_Reference::is_soft(ref), "must be Weak or Soft Reference");
140   return ref->obj_field_access<ON_WEAK_OOP_REF | AS_NO_KEEPALIVE>(_referent_offset);
141 }
142 
143 oop java_lang_ref_Reference::weak_referent(oop ref) {
144   assert(java_lang_ref_Reference::is_weak(ref) || java_lang_ref_Reference::is_soft(ref), "must be Weak or Soft Reference");
145   return ref->obj_field_access<ON_WEAK_OOP_REF>(_referent_offset);
146 }
147 
148 oop java_lang_ref_Reference::phantom_referent_no_keepalive(oop ref) {
149   assert(java_lang_ref_Reference::is_phantom(ref), "must be Phantom Reference");
150   return ref->obj_field_access<ON_PHANTOM_OOP_REF | AS_NO_KEEPALIVE>(_referent_offset);
151 }
152 
153 oop java_lang_ref_Reference::unknown_referent_no_keepalive(oop ref) {
154   return ref->obj_field_access<ON_UNKNOWN_OOP_REF | AS_NO_KEEPALIVE>(_referent_offset);
155 }
156 
157 void java_lang_ref_Reference::clear_referent(oop ref) {
158   HeapAccess<ON_UNKNOWN_OOP_REF | AS_NO_KEEPALIVE>::oop_store_at(ref, _referent_offset, nullptr);
159 }
160 
161 void java_lang_ref_Reference::clear_referent_raw(oop ref) {
162   ref->obj_field_put_raw(_referent_offset, nullptr);
163 }
164 
165 HeapWord* java_lang_ref_Reference::referent_addr_raw(oop ref) {
166   return ref->field_addr<HeapWord>(_referent_offset);
167 }
168 
169 oop java_lang_ref_Reference::next(oop ref) {
170   return ref->obj_field(_next_offset);
171 }
172 
173 void java_lang_ref_Reference::set_next(oop ref, oop value) {
174   ref->obj_field_put(_next_offset, value);
175 }
176 
177 void java_lang_ref_Reference::set_next_raw(oop ref, oop value) {
178   ref->obj_field_put_raw(_next_offset, value);
179 }
180 
181 HeapWord* java_lang_ref_Reference::next_addr_raw(oop ref) {
182   return ref->field_addr<HeapWord>(_next_offset);
183 }
184 
185 oop java_lang_ref_Reference::discovered(oop ref) {
186   return ref->obj_field(_discovered_offset);
187 }
188 
189 void java_lang_ref_Reference::set_discovered(oop ref, oop value) {
190   ref->obj_field_put(_discovered_offset, value);
191 }
192 
193 void java_lang_ref_Reference::set_discovered_raw(oop ref, oop value) {
194   ref->obj_field_put_raw(_discovered_offset, value);
195 }
196 
197 HeapWord* java_lang_ref_Reference::discovered_addr_raw(oop ref) {
198   return ref->field_addr<HeapWord>(_discovered_offset);
199 }
200 
201 bool java_lang_ref_Reference::is_final(oop ref) {
202   return InstanceKlass::cast(ref->klass())->reference_type() == REF_FINAL;
203 }
204 
205 bool java_lang_ref_Reference::is_phantom(oop ref) {
206   return InstanceKlass::cast(ref->klass())->reference_type() == REF_PHANTOM;
207 }
208 
209 bool java_lang_ref_Reference::is_weak(oop ref) {
210   return InstanceKlass::cast(ref->klass())->reference_type() == REF_WEAK;
211 }
212 
213 bool java_lang_ref_Reference::is_soft(oop ref) {
214   return InstanceKlass::cast(ref->klass())->reference_type() == REF_SOFT;
215 }
216 
217 inline oop java_lang_Thread::continuation(oop java_thread) {
218   return java_thread->obj_field(_continuation_offset);
219 }
220 
221 inline int64_t java_lang_Thread::thread_id(oop java_thread) {
222   return java_thread->long_field(_tid_offset);
223 }
224 
225 inline oop java_lang_VirtualThread::vthread_scope() {
226   oop base = vmClasses::VirtualThread_klass()->static_field_base_raw();
227   return base->obj_field(static_vthread_scope_offset);
228 }
229 
230 inline ObjectWaiter* java_lang_VirtualThread::objectWaiter(oop vthread) {
231   return (ObjectWaiter*)vthread->address_field(_objectWaiter_offset);
232 }
233 
234 inline void java_lang_VirtualThread::set_objectWaiter(oop vthread, ObjectWaiter* value) {
235   vthread->address_field_put(_objectWaiter_offset, (address)value);
236 }
237 
238 #if INCLUDE_JFR
239 inline u2 java_lang_Thread::jfr_epoch(oop ref) {
240   return ref->short_field(_jfr_epoch_offset);
241 }
242 
243 inline void java_lang_Thread::set_jfr_epoch(oop ref, u2 epoch) {
244   ref->short_field_put(_jfr_epoch_offset, epoch);
245 }
246 #endif // INCLUDE_JFR
247 
248 
249 inline void java_lang_invoke_CallSite::set_target_volatile(oop site, oop target) {
250   site->obj_field_put_volatile(_target_offset, target);
251 }
252 
253 inline oop  java_lang_invoke_CallSite::target(oop site) {
254   return site->obj_field(_target_offset);
255 }
256 
257 inline void java_lang_invoke_CallSite::set_target(oop site, oop target) {
258   site->obj_field_put(_target_offset, target);
259 }
260 
261 inline bool java_lang_invoke_CallSite::is_instance(oop obj) {
262   return obj != nullptr && is_subclass(obj->klass());
263 }
264 
265 inline jboolean java_lang_invoke_ConstantCallSite::is_frozen(oop site) {
266   return site->bool_field(_is_frozen_offset);
267 }
268 
269 inline bool java_lang_invoke_ConstantCallSite::is_instance(oop obj) {
270   return obj != nullptr && is_subclass(obj->klass());
271 }
272 
273 inline bool java_lang_invoke_MemberName::is_instance(oop obj) {
274   return obj != nullptr && obj->klass() == vmClasses::MemberName_klass();
275 }
276 
277 inline bool java_lang_invoke_ResolvedMethodName::is_instance(oop obj) {
278   return obj != nullptr && obj->klass() == vmClasses::ResolvedMethodName_klass();
279 }
280 
281 inline bool java_lang_invoke_MethodType::is_instance(oop obj) {
282   return obj != nullptr && obj->klass() == vmClasses::MethodType_klass();
283 }
284 
285 inline bool java_lang_invoke_MethodHandle::is_instance(oop obj) {
286   return obj != nullptr && is_subclass(obj->klass());
287 }
288 
289 inline bool java_lang_Class::is_instance(oop obj) {
290   return obj != nullptr && obj->klass() == vmClasses::Class_klass();
291 }
292 
293 inline Klass* java_lang_Class::as_Klass(oop java_class) {
294   //%note memory_2
295   assert(java_lang_Class::is_instance(java_class), "must be a Class object");
296   Klass* k = ((Klass*)java_class->metadata_field(_klass_offset));
297   assert(k == nullptr || k->is_klass(), "type check");
298   return k;
299 }
300 
301 inline InstanceKlass* java_lang_Class::as_InstanceKlass(oop java_class) {
302   Klass* k = as_Klass(java_class);
303   assert(k == nullptr || k->is_instance_klass(), "type check");
304   return static_cast<InstanceKlass*>(k);
305 }
306 
307 inline bool java_lang_Class::is_primitive(oop java_class) {
308   // should assert:
309   // assert(java_lang_Class::is_instance(java_class), "must be a Class object");
310   bool is_primitive = (java_class->metadata_field(_klass_offset) == nullptr);
311 
312 #ifdef ASSERT
313   // The heapwalker walks through Classes that have had their Klass pointers removed, so can't assert this.
314   // assert(is_primitive == java_class->bool_field(_is_primitive_offset), "must match what we told Java");
315   if (java_class->bool_field(_is_primitive_offset)) {
316     Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
317     assert(k == nullptr || is_java_primitive(ArrayKlass::cast(k)->element_type()),
318         "Should be either the T_VOID primitive or a java primitive");
319   }
320 #endif
321 
322   return is_primitive;
323 }
324 
325 inline size_t java_lang_Class::oop_size(oop java_class) {
326   assert(_oop_size_offset != 0, "must be set");
327   int size = java_class->int_field(_oop_size_offset);
328   assert(size > 0, "Oop size must be greater than zero, not %d", size);
329   return size;
330 }
331 
332 inline bool java_lang_invoke_DirectMethodHandle::is_instance(oop obj) {
333   return obj != nullptr && is_subclass(obj->klass());
334 }
335 
336 inline bool java_lang_Module::is_instance(oop obj) {
337   return obj != nullptr && obj->klass() == vmClasses::Module_klass();
338 }
339 
340 inline int Backtrace::merge_bci_and_version(int bci, int version) {
341   // only store u2 for version, checking for overflow.
342   if (version > USHRT_MAX || version < 0) version = USHRT_MAX;
343   assert((u2)bci == bci, "bci should be short");
344   return build_int_from_shorts((u2)version, (u2)bci);
345 }
346 
347 inline int Backtrace::merge_mid_and_cpref(int mid, int cpref) {
348   // only store u2 for mid and cpref, checking for overflow.
349   assert((u2)mid == mid, "mid should be short");
350   assert((u2)cpref == cpref, "cpref should be short");
351   return build_int_from_shorts((u2)cpref, (u2)mid);
352 }
353 
354 inline int Backtrace::bci_at(unsigned int merged) {
355   return extract_high_short_from_int(merged);
356 }
357 
358 inline int Backtrace::version_at(unsigned int merged) {
359   return extract_low_short_from_int(merged);
360 }
361 
362 inline int Backtrace::mid_at(unsigned int merged) {
363   return extract_high_short_from_int(merged);
364 }
365 
366 inline int Backtrace::cpref_at(unsigned int merged) {
367   return extract_low_short_from_int(merged);
368 }
369 
370 inline int Backtrace::get_line_number(Method* method, int bci) {
371   int line_number = 0;
372   if (method->is_native()) {
373     // Negative value different from -1 below, enabling Java code in
374     // class java.lang.StackTraceElement to distinguish "native" from
375     // "no LineNumberTable".  JDK tests for -2.
376     line_number = -2;
377   } else {
378     // Returns -1 if no LineNumberTable, and otherwise actual line number
379     line_number = method->line_number_from_bci(bci);
380   }
381   return line_number;
382 }
383 
384 inline Symbol* Backtrace::get_source_file_name(InstanceKlass* holder, int version) {
385   // RedefineClasses() currently permits redefine operations to
386   // happen in parallel using a "last one wins" philosophy. That
387   // spec laxness allows the constant pool entry associated with
388   // the source_file_name_index for any older constant pool version
389   // to be unstable so we shouldn't try to use it.
390   if (holder->constants()->version() != version) {
391     return nullptr;
392   } else {
393     return holder->source_file_name();
394   }
395 }
396 
397 #endif // SHARE_CLASSFILE_JAVACLASSES_INLINE_HPP