< prev index next >

src/share/vm/classfile/javaClasses.cpp

Print this page
rev 8961 : [mq]: diff-shenandoah.patch


 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 


< prev index next >