400 fatal("An exception should have been thrown above");
401 JRT_END
402
403 JRT_ENTRY(void, InterpreterRuntime::uninitialized_instance_value_field(JavaThread* thread, oopDesc* obj, int index))
404 instanceHandle obj_h(THREAD, (instanceOop)obj);
405 InstanceKlass* klass = InstanceKlass::cast(obj_h()->klass());
406 Klass* field_k = klass->get_value_field_klass_or_null(index);
407 assert(field_k != NULL, "Must have been initialized");
408 ValueKlass* field_vklass = ValueKlass::cast(field_k);
409 assert(field_vklass->is_initialized(), "Must have been initialized at this point");
410 instanceOop res = (instanceOop)field_vklass->default_value();
411 thread->set_vm_result(res);
412 JRT_END
413
414 JRT_ENTRY(void, InterpreterRuntime::write_flattened_value(JavaThread* thread, oopDesc* value, int offset, oopDesc* rcv))
415 assert(oopDesc::is_oop(value), "Sanity check");
416 assert(oopDesc::is_oop(rcv), "Sanity check");
417 assert(value->is_value(), "Sanity check");
418
419 ValueKlass* vklass = ValueKlass::cast(value->klass());
420 vklass->value_store(vklass->data_for_oop(value), ((char*)(oopDesc*)rcv) + offset, true, true);
421 JRT_END
422
423 JRT_ENTRY(void, InterpreterRuntime::read_flattened_field(JavaThread* thread, oopDesc* obj, int index, Klass* field_holder))
424 Handle obj_h(THREAD, obj);
425
426 assert(oopDesc::is_oop(obj), "Sanity check");
427
428 assert(field_holder->is_instance_klass(), "Sanity check");
429 InstanceKlass* klass = InstanceKlass::cast(field_holder);
430
431 assert(klass->field_is_flattened(index), "Sanity check");
432
433 ValueKlass* field_vklass = ValueKlass::cast(klass->get_value_field_klass(index));
434 assert(field_vklass->is_initialized(), "Must be initialized at this point");
435
436 // allocate instance
437 instanceOop res = field_vklass->allocate_instance(CHECK);
438 // copy value
439 field_vklass->value_store(((char*)(oopDesc*)obj_h()) + klass->field_offset(index),
440 field_vklass->data_for_oop(res), true, true);
441 thread->set_vm_result(res);
442 JRT_END
443
444 JRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))
445 oop obj = oopFactory::new_typeArray(type, size, CHECK);
446 thread->set_vm_result(obj);
447 JRT_END
448
449
450 JRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))
451 Klass* klass = pool->klass_at(index, CHECK);
452 bool is_qtype_desc = pool->tag_at(index).is_Qdescriptor_klass();
453 arrayOop obj;
454 if ((!klass->is_array_klass()) && is_qtype_desc) { // Logically creates elements, ensure klass init
455 klass->initialize(CHECK);
456 obj = oopFactory::new_valueArray(klass, size, CHECK);
457 } else {
458 obj = oopFactory::new_objArray(klass, size, CHECK);
459 }
460 thread->set_vm_result(obj);
461 JRT_END
462
463 JRT_ENTRY(void, InterpreterRuntime::value_array_load(JavaThread* thread, arrayOopDesc* array, int index))
464 Klass* klass = array->klass();
465 assert(klass->is_valueArray_klass(), "expected value array oop");
466
467 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass);
468 ValueKlass* vklass = vaklass->element_klass();
469 arrayHandle ah(THREAD, array);
470 instanceOop value_holder = vklass->allocate_instance(CHECK);
471 void* src = ((valueArrayOop)ah())->value_at_addr(index, vaklass->layout_helper());
472 vklass->value_store(src, vklass->data_for_oop(value_holder),
473 vaklass->element_byte_size(), true, false);
474 thread->set_vm_result(value_holder);
475 JRT_END
476
477 JRT_ENTRY(void, InterpreterRuntime::value_array_store(JavaThread* thread, void* val, arrayOopDesc* array, int index))
478 assert(val != NULL, "can't store null into flat array");
479 Klass* klass = array->klass();
480 assert(klass->is_valueArray_klass(), "expected value array");
481 assert(ArrayKlass::cast(klass)->element_klass() == ((oop)val)->klass(), "Store type incorrect");
482
483 valueArrayOop varray = (valueArrayOop)array;
484 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass);
485 ValueKlass* vklass = vaklass->element_klass();
486 const int lh = vaklass->layout_helper();
487 vklass->value_store(vklass->data_for_oop((oop)val), varray->value_at_addr(index, lh),
488 vaklass->element_byte_size(), true, false);
489 JRT_END
490
491 JRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address))
492 // We may want to pass in more arguments - could make this slightly faster
493 LastFrameAccessor last_frame(thread);
494 ConstantPool* constants = last_frame.method()->constants();
495 int i = last_frame.get_index_u2(Bytecodes::_multianewarray);
496 Klass* klass = constants->klass_at(i, CHECK);
497 bool is_qtype = klass->name()->is_Q_array_signature();
498 int nof_dims = last_frame.number_of_dimensions();
499 assert(klass->is_klass(), "not a class");
500 assert(nof_dims >= 1, "multianewarray rank must be nonzero");
501
502 if (is_qtype) { // Logically creates elements, ensure klass init
503 klass->initialize(CHECK);
504 }
505
506 // We must create an array of jints to pass to multi_allocate.
507 ResourceMark rm(thread);
508 const int small_dims = 10;
|
400 fatal("An exception should have been thrown above");
401 JRT_END
402
403 JRT_ENTRY(void, InterpreterRuntime::uninitialized_instance_value_field(JavaThread* thread, oopDesc* obj, int index))
404 instanceHandle obj_h(THREAD, (instanceOop)obj);
405 InstanceKlass* klass = InstanceKlass::cast(obj_h()->klass());
406 Klass* field_k = klass->get_value_field_klass_or_null(index);
407 assert(field_k != NULL, "Must have been initialized");
408 ValueKlass* field_vklass = ValueKlass::cast(field_k);
409 assert(field_vklass->is_initialized(), "Must have been initialized at this point");
410 instanceOop res = (instanceOop)field_vklass->default_value();
411 thread->set_vm_result(res);
412 JRT_END
413
414 JRT_ENTRY(void, InterpreterRuntime::write_flattened_value(JavaThread* thread, oopDesc* value, int offset, oopDesc* rcv))
415 assert(oopDesc::is_oop(value), "Sanity check");
416 assert(oopDesc::is_oop(rcv), "Sanity check");
417 assert(value->is_value(), "Sanity check");
418
419 ValueKlass* vklass = ValueKlass::cast(value->klass());
420 if (!vklass->is_empty_value()) {
421 vklass->value_store(vklass->data_for_oop(value), ((char*)(oopDesc*)rcv) + offset, true, true);
422 }
423 JRT_END
424
425 JRT_ENTRY(void, InterpreterRuntime::read_flattened_field(JavaThread* thread, oopDesc* obj, int index, Klass* field_holder))
426 Handle obj_h(THREAD, obj);
427
428 assert(oopDesc::is_oop(obj), "Sanity check");
429
430 assert(field_holder->is_instance_klass(), "Sanity check");
431 InstanceKlass* klass = InstanceKlass::cast(field_holder);
432
433 assert(klass->field_is_flattened(index), "Sanity check");
434
435 ValueKlass* field_vklass = ValueKlass::cast(klass->get_value_field_klass(index));
436 assert(field_vklass->is_initialized(), "Must be initialized at this point");
437
438 instanceOop res = NULL;
439 if (field_vklass->is_empty_value()) {
440 res = (instanceOop)field_vklass->default_value();
441 } else {
442 // allocate instance
443 res = field_vklass->allocate_instance(CHECK);
444 // copy value
445 field_vklass->value_store(((char*)(oopDesc*)obj_h()) + klass->field_offset(index),
446 field_vklass->data_for_oop(res), true, true);
447 }
448 assert(res != NULL, "Must be set in one of two paths above");
449 thread->set_vm_result(res);
450 JRT_END
451
452 JRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size))
453 oop obj = oopFactory::new_typeArray(type, size, CHECK);
454 thread->set_vm_result(obj);
455 JRT_END
456
457
458 JRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size))
459 Klass* klass = pool->klass_at(index, CHECK);
460 bool is_qtype_desc = pool->tag_at(index).is_Qdescriptor_klass();
461 arrayOop obj;
462 if ((!klass->is_array_klass()) && is_qtype_desc) { // Logically creates elements, ensure klass init
463 klass->initialize(CHECK);
464 obj = oopFactory::new_valueArray(klass, size, CHECK);
465 } else {
466 obj = oopFactory::new_objArray(klass, size, CHECK);
467 }
468 thread->set_vm_result(obj);
469 JRT_END
470
471 JRT_ENTRY(void, InterpreterRuntime::value_array_load(JavaThread* thread, arrayOopDesc* array, int index))
472 Klass* klass = array->klass();
473 assert(klass->is_valueArray_klass(), "expected value array oop");
474
475 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass);
476 ValueKlass* vklass = vaklass->element_klass();
477 arrayHandle ah(THREAD, array);
478 instanceOop value_holder = NULL;
479 if (vklass->is_empty_value()) {
480 value_holder = (instanceOop)vklass->default_value();
481 } else {
482 value_holder = vklass->allocate_instance(CHECK);
483 void* src = ((valueArrayOop)ah())->value_at_addr(index, vaklass->layout_helper());
484 vklass->value_store(src, vklass->data_for_oop(value_holder),
485 vaklass->element_byte_size(), true, false);
486 }
487 assert(value_holder != NULL, "Must be set in one of two paths above");
488 thread->set_vm_result(value_holder);
489 JRT_END
490
491 JRT_ENTRY(void, InterpreterRuntime::value_array_store(JavaThread* thread, void* val, arrayOopDesc* array, int index))
492 assert(val != NULL, "can't store null into flat array");
493 Klass* klass = array->klass();
494 assert(klass->is_valueArray_klass(), "expected value array");
495 assert(ArrayKlass::cast(klass)->element_klass() == ((oop)val)->klass(), "Store type incorrect");
496
497 valueArrayOop varray = (valueArrayOop)array;
498 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass);
499 ValueKlass* vklass = vaklass->element_klass();
500 if (!vklass->is_empty_value()) {
501 const int lh = vaklass->layout_helper();
502 vklass->value_store(vklass->data_for_oop((oop)val), varray->value_at_addr(index, lh),
503 vaklass->element_byte_size(), true, false);
504 }
505 JRT_END
506
507 JRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address))
508 // We may want to pass in more arguments - could make this slightly faster
509 LastFrameAccessor last_frame(thread);
510 ConstantPool* constants = last_frame.method()->constants();
511 int i = last_frame.get_index_u2(Bytecodes::_multianewarray);
512 Klass* klass = constants->klass_at(i, CHECK);
513 bool is_qtype = klass->name()->is_Q_array_signature();
514 int nof_dims = last_frame.number_of_dimensions();
515 assert(klass->is_klass(), "not a class");
516 assert(nof_dims >= 1, "multianewarray rank must be nonzero");
517
518 if (is_qtype) { // Logically creates elements, ensure klass init
519 klass->initialize(CHECK);
520 }
521
522 // We must create an array of jints to pass to multi_allocate.
523 ResourceMark rm(thread);
524 const int small_dims = 10;
|