195 Handle h_obj = basic_create(length, CHECK_NH);
196 typeArrayOop buffer = value(h_obj());
197 for (int index = 0; index < length; index++) {
198 buffer->char_at_put(index, unicode[index]);
199 }
200 return h_obj;
201 }
202
203 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {
204 Handle h_obj = create_from_unicode(unicode, length, CHECK_0);
205 return h_obj();
206 }
207
208 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
209 if (utf8_str == NULL) {
210 return Handle();
211 }
212 int length = UTF8::unicode_length(utf8_str);
213 Handle h_obj = basic_create(length, CHECK_NH);
214 if (length > 0) {
215 UTF8::convert_to_unicode(utf8_str, value(h_obj())->char_at_addr(0), length);
216 }
217 return h_obj;
218 }
219
220 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {
221 Handle h_obj = create_from_str(utf8_str, CHECK_0);
222 return h_obj();
223 }
224
225 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
226 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());
227 Handle h_obj = basic_create(length, CHECK_NH);
228 if (length > 0) {
229 UTF8::convert_to_unicode((char*)symbol->bytes(), value(h_obj())->char_at_addr(0), length);
230 }
231 return h_obj;
232 }
233
234 // Converts a C string to a Java String based on current encoding
235 Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {
236 assert(str != NULL, "bad arguments");
237
238 typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);
239 static to_java_string_fn_t _to_java_string_fn = NULL;
240
241 if (_to_java_string_fn == NULL) {
242 void *lib_handle = os::native_java_library();
243 _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, os::dll_lookup(lib_handle, "NewStringPlatform"));
244 if (_to_java_string_fn == NULL) {
245 fatal("NewStringPlatform missing");
246 }
247 }
248
249 jstring js = NULL;
330 length = java_lang_String::length(java_string);
331
332 jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length);
333 if (result != NULL) {
334 for (int index = 0; index < length; index++) {
335 result[index] = value->char_at(index + offset);
336 }
337 } else {
338 THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");
339 }
340 return result;
341 }
342
343 unsigned int java_lang_String::hash_code(oop java_string) {
344 int length = java_lang_String::length(java_string);
345 // Zero length string will hash to zero with String.hashCode() function.
346 if (length == 0) return 0;
347
348 typeArrayOop value = java_lang_String::value(java_string);
349 int offset = java_lang_String::offset(java_string);
350 return java_lang_String::hash_code(value->char_at_addr(offset), length);
351 }
352
353 char* java_lang_String::as_quoted_ascii(oop java_string) {
354 typeArrayOop value = java_lang_String::value(java_string);
355 int offset = java_lang_String::offset(java_string);
356 int length = java_lang_String::length(java_string);
357
358 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
359 if (base == NULL) return NULL;
360
361 int result_length = UNICODE::quoted_ascii_length(base, length) + 1;
362 char* result = NEW_RESOURCE_ARRAY(char, result_length);
363 UNICODE::as_quoted_ascii(base, length, result, result_length);
364 assert(result_length >= length + 1, "must not be shorter");
365 assert(result_length == (int)strlen(result) + 1, "must match");
366 return result;
367 }
368
369 unsigned int java_lang_String::hash_string(oop java_string) {
370 int length = java_lang_String::length(java_string);
371 // Zero length string doesn't hash necessarily hash to zero.
372 if (length == 0) {
373 return StringTable::hash_string(NULL, 0);
374 }
375
376 typeArrayOop value = java_lang_String::value(java_string);
377 int offset = java_lang_String::offset(java_string);
378 return StringTable::hash_string(value->char_at_addr(offset), length);
379 }
380
381 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
382 oop obj = java_string();
383 typeArrayOop value = java_lang_String::value(obj);
384 int offset = java_lang_String::offset(obj);
385 int length = java_lang_String::length(obj);
386 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
387 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
388 return sym;
389 }
390
391 Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
392 typeArrayOop value = java_lang_String::value(java_string);
393 int offset = java_lang_String::offset(java_string);
394 int length = java_lang_String::length(java_string);
395 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
396 return SymbolTable::probe_unicode(base, length);
397 }
398
399
400 int java_lang_String::utf8_length(oop java_string) {
401 typeArrayOop value = java_lang_String::value(java_string);
402 int offset = java_lang_String::offset(java_string);
403 int length = java_lang_String::length(java_string);
404 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
405 return UNICODE::utf8_length(position, length);
406 }
407
408 char* java_lang_String::as_utf8_string(oop java_string) {
409 typeArrayOop value = java_lang_String::value(java_string);
410 int offset = java_lang_String::offset(java_string);
411 int length = java_lang_String::length(java_string);
412 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
413 return UNICODE::as_utf8(position, length);
414 }
415
416 char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
417 typeArrayOop value = java_lang_String::value(java_string);
418 int offset = java_lang_String::offset(java_string);
419 int length = java_lang_String::length(java_string);
420 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
421 return UNICODE::as_utf8(position, length, buf, buflen);
422 }
423
424 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
425 typeArrayOop value = java_lang_String::value(java_string);
426 int offset = java_lang_String::offset(java_string);
427 int length = java_lang_String::length(java_string);
428 assert(start + len <= length, "just checking");
429 jchar* position = value->char_at_addr(offset + start);
430 return UNICODE::as_utf8(position, len);
431 }
432
433 char* java_lang_String::as_utf8_string(oop java_string, int start, int len, char* buf, int buflen) {
434 typeArrayOop value = java_lang_String::value(java_string);
435 int offset = java_lang_String::offset(java_string);
436 int length = java_lang_String::length(java_string);
437 assert(start + len <= length, "just checking");
438 jchar* position = value->char_at_addr(offset + start);
439 return UNICODE::as_utf8(position, len, buf, buflen);
440 }
441
442 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
443 assert(java_string->klass() == SystemDictionary::String_klass(),
444 "must be java_string");
445 typeArrayOop value = java_lang_String::value(java_string);
446 int offset = java_lang_String::offset(java_string);
447 int length = java_lang_String::length(java_string);
448 if (length != len) {
449 return false;
450 }
451 for (int i = 0; i < len; i++) {
452 if (value->char_at(i + offset) != chars[i]) {
453 return false;
454 }
455 }
456 return true;
457 }
458
459 bool java_lang_String::equals(oop str1, oop str2) {
460 assert(str1->klass() == SystemDictionary::String_klass(),
461 "must be java String");
462 assert(str2->klass() == SystemDictionary::String_klass(),
463 "must be java String");
464 typeArrayOop value1 = java_lang_String::value(str1);
465 int offset1 = java_lang_String::offset(str1);
846 #ifdef ASSERT
847 if (is_primitive) {
848 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
849 assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()),
850 "Should be either the T_VOID primitive or a java primitive");
851 }
852 #endif
853
854 return is_primitive;
855 }
856
857
858 BasicType java_lang_Class::primitive_type(oop java_class) {
859 assert(java_lang_Class::is_primitive(java_class), "just checking");
860 Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset));
861 BasicType type = T_VOID;
862 if (ak != NULL) {
863 // Note: create_basic_type_mirror above initializes ak to a non-null value.
864 type = ArrayKlass::cast(ak)->element_type();
865 } else {
866 assert(java_class == Universe::void_mirror(), "only valid non-array primitive");
867 }
868 assert(Universe::java_mirror(type) == java_class, "must be consistent");
869 return type;
870 }
871
872 BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) {
873 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
874 if (is_primitive(java_class)) {
875 if (reference_klass != NULL)
876 (*reference_klass) = NULL;
877 return primitive_type(java_class);
878 } else {
879 if (reference_klass != NULL)
880 (*reference_klass) = as_Klass(java_class);
881 return T_OBJECT;
882 }
883 }
884
885
886 oop java_lang_Class::primitive_mirror(BasicType t) {
887 oop mirror = Universe::java_mirror(t);
888 assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class");
3070 // Fill in values
3071 result->obj_field_put(_context_offset, context());
3072 result->obj_field_put(_privilegedContext_offset, privileged_context());
3073 result->bool_field_put(_isPrivileged_offset, isPrivileged);
3074 // whitelist AccessControlContexts created by the JVM if present
3075 if (_isAuthorized_offset != -1) {
3076 result->bool_field_put(_isAuthorized_offset, true);
3077 }
3078 return result;
3079 }
3080
3081
3082 // Support for java_lang_ClassLoader
3083
3084 bool java_lang_ClassLoader::offsets_computed = false;
3085 int java_lang_ClassLoader::_loader_data_offset = -1;
3086 int java_lang_ClassLoader::parallelCapable_offset = -1;
3087
3088 ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) {
3089 assert(loader != NULL && loader->is_oop(), "loader must be oop");
3090 return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset);
3091 }
3092
3093 ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) {
3094 return *java_lang_ClassLoader::loader_data_addr(loader);
3095 }
3096
3097 void java_lang_ClassLoader::compute_offsets() {
3098 assert(!offsets_computed, "offsets should be initialized only once");
3099 offsets_computed = true;
3100
3101 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
3102 Klass* k1 = SystemDictionary::ClassLoader_klass();
3103 compute_optional_offset(parallelCapable_offset,
3104 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
3105
3106 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3107 }
3108
3109 oop java_lang_ClassLoader::parent(oop loader) {
3110 assert(is_instance(loader), "loader must be oop");
3111 return loader->obj_field(parent_offset);
3112 }
3113
3114 bool java_lang_ClassLoader::isAncestor(oop loader, oop cl) {
3115 assert(is_instance(loader), "loader must be oop");
3116 assert(cl == NULL || is_instance(cl), "cl argument must be oop");
3117 oop acl = loader;
3118 debug_only(jint loop_count = 0);
3119 // This loop taken verbatim from ClassLoader.java:
3120 do {
3121 acl = parent(acl);
3122 if (cl == acl) {
3123 return true;
3124 }
3125 assert(++loop_count > 0, "loop_count overflow");
3126 } while (acl != NULL);
3127 return false;
3128 }
3129
|
195 Handle h_obj = basic_create(length, CHECK_NH);
196 typeArrayOop buffer = value(h_obj());
197 for (int index = 0; index < length; index++) {
198 buffer->char_at_put(index, unicode[index]);
199 }
200 return h_obj;
201 }
202
203 oop java_lang_String::create_oop_from_unicode(jchar* unicode, int length, TRAPS) {
204 Handle h_obj = create_from_unicode(unicode, length, CHECK_0);
205 return h_obj();
206 }
207
208 Handle java_lang_String::create_from_str(const char* utf8_str, TRAPS) {
209 if (utf8_str == NULL) {
210 return Handle();
211 }
212 int length = UTF8::unicode_length(utf8_str);
213 Handle h_obj = basic_create(length, CHECK_NH);
214 if (length > 0) {
215 typeArrayOop buffer = value(h_obj());
216 buffer = typeArrayOop(oopDesc::bs()->resolve_and_maybe_copy_oop(buffer));
217 UTF8::convert_to_unicode(utf8_str, buffer->char_at_addr(0), length);
218 }
219 return h_obj;
220 }
221
222 oop java_lang_String::create_oop_from_str(const char* utf8_str, TRAPS) {
223 Handle h_obj = create_from_str(utf8_str, CHECK_0);
224 return h_obj();
225 }
226
227 Handle java_lang_String::create_from_symbol(Symbol* symbol, TRAPS) {
228 int length = UTF8::unicode_length((char*)symbol->bytes(), symbol->utf8_length());
229 Handle h_obj = basic_create(length, CHECK_NH);
230 if (length > 0) {
231 typeArrayOop buffer = value(h_obj());
232 buffer = typeArrayOop(oopDesc::bs()->resolve_and_maybe_copy_oop(buffer));
233 UTF8::convert_to_unicode((char*)symbol->bytes(), buffer->char_at_addr(0), length);
234 }
235 return h_obj;
236 }
237
238 // Converts a C string to a Java String based on current encoding
239 Handle java_lang_String::create_from_platform_dependent_str(const char* str, TRAPS) {
240 assert(str != NULL, "bad arguments");
241
242 typedef jstring (*to_java_string_fn_t)(JNIEnv*, const char *);
243 static to_java_string_fn_t _to_java_string_fn = NULL;
244
245 if (_to_java_string_fn == NULL) {
246 void *lib_handle = os::native_java_library();
247 _to_java_string_fn = CAST_TO_FN_PTR(to_java_string_fn_t, os::dll_lookup(lib_handle, "NewStringPlatform"));
248 if (_to_java_string_fn == NULL) {
249 fatal("NewStringPlatform missing");
250 }
251 }
252
253 jstring js = NULL;
334 length = java_lang_String::length(java_string);
335
336 jchar* result = NEW_RESOURCE_ARRAY_RETURN_NULL(jchar, length);
337 if (result != NULL) {
338 for (int index = 0; index < length; index++) {
339 result[index] = value->char_at(index + offset);
340 }
341 } else {
342 THROW_MSG_0(vmSymbols::java_lang_OutOfMemoryError(), "could not allocate Unicode string");
343 }
344 return result;
345 }
346
347 unsigned int java_lang_String::hash_code(oop java_string) {
348 int length = java_lang_String::length(java_string);
349 // Zero length string will hash to zero with String.hashCode() function.
350 if (length == 0) return 0;
351
352 typeArrayOop value = java_lang_String::value(java_string);
353 int offset = java_lang_String::offset(java_string);
354 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
355 return java_lang_String::hash_code(value->char_at_addr(offset), length);
356 }
357
358 char* java_lang_String::as_quoted_ascii(oop java_string) {
359 typeArrayOop value = java_lang_String::value(java_string);
360 int offset = java_lang_String::offset(java_string);
361 int length = java_lang_String::length(java_string);
362
363 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
364 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
365 if (base == NULL) return NULL;
366
367 int result_length = UNICODE::quoted_ascii_length(base, length) + 1;
368 char* result = NEW_RESOURCE_ARRAY(char, result_length);
369 UNICODE::as_quoted_ascii(base, length, result, result_length);
370 assert(result_length >= length + 1, "must not be shorter");
371 assert(result_length == (int)strlen(result) + 1, "must match");
372 return result;
373 }
374
375 unsigned int java_lang_String::hash_string(oop java_string) {
376 int length = java_lang_String::length(java_string);
377 // Zero length string doesn't hash necessarily hash to zero.
378 if (length == 0) {
379 return StringTable::hash_string(NULL, 0);
380 }
381
382 typeArrayOop value = java_lang_String::value(java_string);
383 int offset = java_lang_String::offset(java_string);
384 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
385 return StringTable::hash_string(value->char_at_addr(offset), length);
386 }
387
388 Symbol* java_lang_String::as_symbol(Handle java_string, TRAPS) {
389 oop obj = java_string();
390 typeArrayOop value = java_lang_String::value(obj);
391 int offset = java_lang_String::offset(obj);
392 int length = java_lang_String::length(obj);
393 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
394 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
395 Symbol* sym = SymbolTable::lookup_unicode(base, length, THREAD);
396 return sym;
397 }
398
399 Symbol* java_lang_String::as_symbol_or_null(oop java_string) {
400 typeArrayOop value = java_lang_String::value(java_string);
401 int offset = java_lang_String::offset(java_string);
402 int length = java_lang_String::length(java_string);
403 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
404 jchar* base = (length == 0) ? NULL : value->char_at_addr(offset);
405 return SymbolTable::probe_unicode(base, length);
406 }
407
408
409 int java_lang_String::utf8_length(oop java_string) {
410 typeArrayOop value = java_lang_String::value(java_string);
411 int offset = java_lang_String::offset(java_string);
412 int length = java_lang_String::length(java_string);
413 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
414 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
415 return UNICODE::utf8_length(position, length);
416 }
417
418 char* java_lang_String::as_utf8_string(oop java_string) {
419 typeArrayOop value = java_lang_String::value(java_string);
420 int offset = java_lang_String::offset(java_string);
421 int length = java_lang_String::length(java_string);
422 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
423 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
424 return UNICODE::as_utf8(position, length);
425 }
426
427 char* java_lang_String::as_utf8_string(oop java_string, char* buf, int buflen) {
428 typeArrayOop value = java_lang_String::value(java_string);
429 int offset = java_lang_String::offset(java_string);
430 int length = java_lang_String::length(java_string);
431 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
432 jchar* position = (length == 0) ? NULL : value->char_at_addr(offset);
433 return UNICODE::as_utf8(position, length, buf, buflen);
434 }
435
436 char* java_lang_String::as_utf8_string(oop java_string, int start, int len) {
437 typeArrayOop value = java_lang_String::value(java_string);
438 int offset = java_lang_String::offset(java_string);
439 int length = java_lang_String::length(java_string);
440 assert(start + len <= length, "just checking");
441 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
442 jchar* position = value->char_at_addr(offset + start);
443 return UNICODE::as_utf8(position, len);
444 }
445
446 char* java_lang_String::as_utf8_string(oop java_string, int start, int len, char* buf, int buflen) {
447 typeArrayOop value = java_lang_String::value(java_string);
448 int offset = java_lang_String::offset(java_string);
449 int length = java_lang_String::length(java_string);
450 assert(start + len <= length, "just checking");
451 value = typeArrayOop(oopDesc::bs()->resolve_oop(value));
452 jchar* position = value->char_at_addr(offset + start);
453 return UNICODE::as_utf8(position, len, buf, buflen);
454 }
455
456 bool java_lang_String::equals(oop java_string, jchar* chars, int len) {
457 assert(java_string->klass() == SystemDictionary::String_klass(),
458 "must be java_string");
459 typeArrayOop value = java_lang_String::value(java_string);
460 if (ShenandoahVerifyReadsToFromSpace) {
461 value = (typeArrayOop) oopDesc::bs()->resolve_oop(value);
462 }
463 int offset = java_lang_String::offset(java_string);
464 int length = java_lang_String::length(java_string);
465 if (length != len) {
466 return false;
467 }
468 for (int i = 0; i < len; i++) {
469 if (value->char_at(i + offset) != chars[i]) {
470 return false;
471 }
472 }
473 return true;
474 }
475
476 bool java_lang_String::equals(oop str1, oop str2) {
477 assert(str1->klass() == SystemDictionary::String_klass(),
478 "must be java String");
479 assert(str2->klass() == SystemDictionary::String_klass(),
480 "must be java String");
481 typeArrayOop value1 = java_lang_String::value(str1);
482 int offset1 = java_lang_String::offset(str1);
863 #ifdef ASSERT
864 if (is_primitive) {
865 Klass* k = ((Klass*)java_class->metadata_field(_array_klass_offset));
866 assert(k == NULL || is_java_primitive(ArrayKlass::cast(k)->element_type()),
867 "Should be either the T_VOID primitive or a java primitive");
868 }
869 #endif
870
871 return is_primitive;
872 }
873
874
875 BasicType java_lang_Class::primitive_type(oop java_class) {
876 assert(java_lang_Class::is_primitive(java_class), "just checking");
877 Klass* ak = ((Klass*)java_class->metadata_field(_array_klass_offset));
878 BasicType type = T_VOID;
879 if (ak != NULL) {
880 // Note: create_basic_type_mirror above initializes ak to a non-null value.
881 type = ArrayKlass::cast(ak)->element_type();
882 } else {
883 assert(oopDesc::bs()->resolve_and_maybe_copy_oop(java_class) == oopDesc::bs()->resolve_and_maybe_copy_oop(Universe::void_mirror()), "only valid non-array primitive");
884 }
885 assert(oopDesc::bs()->resolve_and_maybe_copy_oop(Universe::java_mirror(type)) == oopDesc::bs()->resolve_and_maybe_copy_oop(java_class), "must be consistent");
886 return type;
887 }
888
889 BasicType java_lang_Class::as_BasicType(oop java_class, Klass** reference_klass) {
890 assert(java_lang_Class::is_instance(java_class), "must be a Class object");
891 if (is_primitive(java_class)) {
892 if (reference_klass != NULL)
893 (*reference_klass) = NULL;
894 return primitive_type(java_class);
895 } else {
896 if (reference_klass != NULL)
897 (*reference_klass) = as_Klass(java_class);
898 return T_OBJECT;
899 }
900 }
901
902
903 oop java_lang_Class::primitive_mirror(BasicType t) {
904 oop mirror = Universe::java_mirror(t);
905 assert(mirror != NULL && mirror->is_a(SystemDictionary::Class_klass()), "must be a Class");
3087 // Fill in values
3088 result->obj_field_put(_context_offset, context());
3089 result->obj_field_put(_privilegedContext_offset, privileged_context());
3090 result->bool_field_put(_isPrivileged_offset, isPrivileged);
3091 // whitelist AccessControlContexts created by the JVM if present
3092 if (_isAuthorized_offset != -1) {
3093 result->bool_field_put(_isAuthorized_offset, true);
3094 }
3095 return result;
3096 }
3097
3098
3099 // Support for java_lang_ClassLoader
3100
3101 bool java_lang_ClassLoader::offsets_computed = false;
3102 int java_lang_ClassLoader::_loader_data_offset = -1;
3103 int java_lang_ClassLoader::parallelCapable_offset = -1;
3104
3105 ClassLoaderData** java_lang_ClassLoader::loader_data_addr(oop loader) {
3106 assert(loader != NULL && loader->is_oop(), "loader must be oop");
3107 loader = oopDesc::bs()->resolve_and_maybe_copy_oop(loader);
3108 return (ClassLoaderData**) loader->address_field_addr(_loader_data_offset);
3109 }
3110
3111 ClassLoaderData* java_lang_ClassLoader::loader_data(oop loader) {
3112 return *java_lang_ClassLoader::loader_data_addr(loader);
3113 }
3114
3115 void java_lang_ClassLoader::compute_offsets() {
3116 assert(!offsets_computed, "offsets should be initialized only once");
3117 offsets_computed = true;
3118
3119 // The field indicating parallelCapable (parallelLockMap) is only present starting in 7,
3120 Klass* k1 = SystemDictionary::ClassLoader_klass();
3121 compute_optional_offset(parallelCapable_offset,
3122 k1, vmSymbols::parallelCapable_name(), vmSymbols::concurrenthashmap_signature());
3123
3124 CLASSLOADER_INJECTED_FIELDS(INJECTED_FIELD_COMPUTE_OFFSET);
3125 }
3126
3127 oop java_lang_ClassLoader::parent(oop loader) {
3128 if (ShenandoahVerifyReadsToFromSpace) {
3129 loader = oopDesc::bs()->resolve_oop(loader);
3130 }
3131 assert(is_instance(loader), "loader must be oop");
3132 return loader->obj_field(parent_offset);
3133 }
3134
3135 bool java_lang_ClassLoader::isAncestor(oop loader, oop cl) {
3136 assert(is_instance(loader), "loader must be oop");
3137 assert(cl == NULL || is_instance(cl), "cl argument must be oop");
3138 oop acl = loader;
3139 debug_only(jint loop_count = 0);
3140 // This loop taken verbatim from ClassLoader.java:
3141 do {
3142 acl = parent(acl);
3143 if (cl == acl) {
3144 return true;
3145 }
3146 assert(++loop_count > 0, "loop_count overflow");
3147 } while (acl != NULL);
3148 return false;
3149 }
3150
|