309 case T_LONG:
310 typeArrayOop(a)->long_at_put(index, value->j);
311 break;
312 default:
313 THROW(vmSymbols::java_lang_IllegalArgumentException());
314 }
315 }
316 }
317
318 static Klass* basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) {
319 assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking");
320 BasicType type = java_lang_Class::primitive_type(basic_type_mirror);
321 if (type == T_VOID) {
322 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
323 }
324 else {
325 return Universe::typeArrayKlassObj(type);
326 }
327 }
328
329 #ifdef ASSERT
330 static oop basic_type_arrayklass_to_mirror(Klass* basic_type_arrayklass, TRAPS) {
331 BasicType type = TypeArrayKlass::cast(basic_type_arrayklass)->element_type();
332 return Universe::java_mirror(type);
333 }
334 #endif
335
336 arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
337 if (element_mirror == NULL) {
338 THROW_0(vmSymbols::java_lang_NullPointerException());
339 }
340 if (length < 0) {
341 THROW_MSG_0(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", length));
342 }
343 if (java_lang_Class::is_primitive(element_mirror)) {
344 Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
345 return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
346 } else {
347 Klass* k = java_lang_Class::as_Klass(element_mirror);
348 if (k->is_array_klass() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
349 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
350 }
351 return oopFactory::new_objArray(k, length, THREAD);
352 }
353 }
354
355
378 Klass* klass;
379 int dim = len;
380 if (java_lang_Class::is_primitive(element_mirror)) {
381 klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
382 } else {
383 klass = java_lang_Class::as_Klass(element_mirror);
384 if (klass->is_array_klass()) {
385 int k_dim = ArrayKlass::cast(klass)->dimension();
386 if (k_dim + len > MAX_DIM) {
387 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
388 }
389 dim += k_dim;
390 }
391 }
392 klass = klass->array_klass(dim, CHECK_NULL);
393 oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, CHECK_NULL);
394 assert(obj->is_array(), "just checking");
395 return arrayOop(obj);
396 }
397
398
399 oop Reflection::array_component_type(oop mirror, TRAPS) {
400 if (java_lang_Class::is_primitive(mirror)) {
401 return NULL;
402 }
403
404 Klass* klass = java_lang_Class::as_Klass(mirror);
405 if (!klass->is_array_klass()) {
406 return NULL;
407 }
408
409 oop result = java_lang_Class::component_mirror(mirror);
410 #ifdef ASSERT
411 oop result2 = NULL;
412 if (ArrayKlass::cast(klass)->dimension() == 1) {
413 if (klass->is_typeArray_klass()) {
414 result2 = basic_type_arrayklass_to_mirror(klass, CHECK_NULL);
415 } else {
416 result2 = ObjArrayKlass::cast(klass)->element_klass()->java_mirror();
417 }
418 } else {
419 Klass* lower_dim = ArrayKlass::cast(klass)->lower_dimension();
420 assert(lower_dim->is_array_klass(), "just checking");
421 result2 = lower_dim->java_mirror();
422 }
423 assert(oopDesc::equals(result, result2), "results must be consistent");
424 #endif //ASSERT
425 return result;
426 }
427
428 static bool under_unsafe_anonymous_host(const InstanceKlass* ik, const InstanceKlass* unsafe_anonymous_host) {
429 DEBUG_ONLY(int inf_loop_check = 1000 * 1000 * 1000);
430 for (;;) {
431 const InstanceKlass* hc = ik->unsafe_anonymous_host();
432 if (hc == NULL) return false;
433 if (hc == unsafe_anonymous_host) return true;
434 ik = hc;
435
436 // There's no way to make a host class loop short of patching memory.
437 // Therefore there cannot be a loop here unless there's another bug.
438 // Still, let's check for it.
439 assert(--inf_loop_check > 0, "no unsafe_anonymous_host loop");
440 }
441 }
442
443 static bool can_relax_access_check_for(const Klass* accessor,
444 const Klass* accessee,
445 bool classloader_only) {
446
|
309 case T_LONG:
310 typeArrayOop(a)->long_at_put(index, value->j);
311 break;
312 default:
313 THROW(vmSymbols::java_lang_IllegalArgumentException());
314 }
315 }
316 }
317
318 static Klass* basic_type_mirror_to_arrayklass(oop basic_type_mirror, TRAPS) {
319 assert(java_lang_Class::is_primitive(basic_type_mirror), "just checking");
320 BasicType type = java_lang_Class::primitive_type(basic_type_mirror);
321 if (type == T_VOID) {
322 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
323 }
324 else {
325 return Universe::typeArrayKlassObj(type);
326 }
327 }
328
329 arrayOop Reflection::reflect_new_array(oop element_mirror, jint length, TRAPS) {
330 if (element_mirror == NULL) {
331 THROW_0(vmSymbols::java_lang_NullPointerException());
332 }
333 if (length < 0) {
334 THROW_MSG_0(vmSymbols::java_lang_NegativeArraySizeException(), err_msg("%d", length));
335 }
336 if (java_lang_Class::is_primitive(element_mirror)) {
337 Klass* tak = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
338 return TypeArrayKlass::cast(tak)->allocate(length, THREAD);
339 } else {
340 Klass* k = java_lang_Class::as_Klass(element_mirror);
341 if (k->is_array_klass() && ArrayKlass::cast(k)->dimension() >= MAX_DIM) {
342 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
343 }
344 return oopFactory::new_objArray(k, length, THREAD);
345 }
346 }
347
348
371 Klass* klass;
372 int dim = len;
373 if (java_lang_Class::is_primitive(element_mirror)) {
374 klass = basic_type_mirror_to_arrayklass(element_mirror, CHECK_NULL);
375 } else {
376 klass = java_lang_Class::as_Klass(element_mirror);
377 if (klass->is_array_klass()) {
378 int k_dim = ArrayKlass::cast(klass)->dimension();
379 if (k_dim + len > MAX_DIM) {
380 THROW_0(vmSymbols::java_lang_IllegalArgumentException());
381 }
382 dim += k_dim;
383 }
384 }
385 klass = klass->array_klass(dim, CHECK_NULL);
386 oop obj = ArrayKlass::cast(klass)->multi_allocate(len, dimensions, CHECK_NULL);
387 assert(obj->is_array(), "just checking");
388 return arrayOop(obj);
389 }
390
391
392 static bool under_unsafe_anonymous_host(const InstanceKlass* ik, const InstanceKlass* unsafe_anonymous_host) {
393 DEBUG_ONLY(int inf_loop_check = 1000 * 1000 * 1000);
394 for (;;) {
395 const InstanceKlass* hc = ik->unsafe_anonymous_host();
396 if (hc == NULL) return false;
397 if (hc == unsafe_anonymous_host) return true;
398 ik = hc;
399
400 // There's no way to make a host class loop short of patching memory.
401 // Therefore there cannot be a loop here unless there's another bug.
402 // Still, let's check for it.
403 assert(--inf_loop_check > 0, "no unsafe_anonymous_host loop");
404 }
405 }
406
407 static bool can_relax_access_check_for(const Klass* accessor,
408 const Klass* accessee,
409 bool classloader_only) {
410
|