420 421 ValueKlass* field_vklass = ValueKlass::cast(klass->get_value_field_klass(index)); 422 assert(field_vklass->is_initialized(), "Must be initialized at this point"); 423 424 // allocate instance 425 instanceOop res = field_vklass->allocate_instance(CHECK); 426 // copy value 427 field_vklass->value_store(((char*)(oopDesc*)obj_h()) + klass->field_offset(index), 428 field_vklass->data_for_oop(res), true, true); 429 thread->set_vm_result(res); 430 IRT_END 431 432 IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size)) 433 oop obj = oopFactory::new_typeArray(type, size, CHECK); 434 thread->set_vm_result(obj); 435 IRT_END 436 437 438 IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size)) 439 Klass* klass = pool->klass_at(index, CHECK); 440 if (klass->is_value()) { // Logically creates elements, ensure klass init 441 klass->initialize(CHECK); 442 } 443 arrayOop obj = oopFactory::new_array(klass, size, CHECK); 444 thread->set_vm_result(obj); 445 IRT_END 446 447 IRT_ENTRY(void, InterpreterRuntime::value_array_load(JavaThread* thread, arrayOopDesc* array, int index)) 448 Klass* klass = array->klass(); 449 assert(klass->is_valueArray_klass(), "expected value array oop"); 450 451 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass); 452 ValueKlass* vklass = vaklass->element_klass(); 453 arrayHandle ah(THREAD, array); 454 instanceOop value_holder = vklass->allocate_instance(CHECK); 455 void* src = ((valueArrayOop)ah())->value_at_addr(index, vaklass->layout_helper()); 456 vklass->value_store(src, vklass->data_for_oop(value_holder), 457 vaklass->element_byte_size(), true, false); 458 thread->set_vm_result(value_holder); 459 IRT_END 460 461 IRT_ENTRY(void, InterpreterRuntime::value_array_store(JavaThread* thread, void* val, arrayOopDesc* array, int index)) 462 assert(val != NULL, "can't store null into flat array"); 463 Klass* klass = array->klass(); 464 assert(klass->is_valueArray_klass(), "expected value array"); 465 assert(ArrayKlass::cast(klass)->element_klass() == ((oop)val)->klass(), "Store type incorrect"); 466 467 valueArrayOop varray = (valueArrayOop)array; 468 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass); 469 ValueKlass* vklass = vaklass->element_klass(); 470 const int lh = vaklass->layout_helper(); 471 vklass->value_store(vklass->data_for_oop((oop)val), varray->value_at_addr(index, lh), 472 vaklass->element_byte_size(), true, false); 473 IRT_END 474 475 IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address)) 476 // We may want to pass in more arguments - could make this slightly faster 477 LastFrameAccessor last_frame(thread); 478 ConstantPool* constants = last_frame.method()->constants(); 479 int i = last_frame.get_index_u2(Bytecodes::_multianewarray); 480 Klass* klass = constants->klass_at(i, CHECK); 481 int nof_dims = last_frame.number_of_dimensions(); 482 assert(klass->is_klass(), "not a class"); 483 assert(nof_dims >= 1, "multianewarray rank must be nonzero"); 484 485 if (klass->is_value()) { // Logically creates elements, ensure klass init 486 klass->initialize(CHECK); 487 } 488 489 // We must create an array of jints to pass to multi_allocate. 490 ResourceMark rm(thread); 491 const int small_dims = 10; 492 jint dim_array[small_dims]; 493 jint *dims = &dim_array[0]; 494 if (nof_dims > small_dims) { 495 dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims); 496 } 497 for (int index = 0; index < nof_dims; index++) { 498 // offset from first_size_address is addressed as local[index] 499 int n = Interpreter::local_offset_in_bytes(index)/jintSize; 500 dims[index] = first_size_address[n]; 501 } 502 oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK); 503 thread->set_vm_result(obj); 504 IRT_END 505 | 420 421 ValueKlass* field_vklass = ValueKlass::cast(klass->get_value_field_klass(index)); 422 assert(field_vklass->is_initialized(), "Must be initialized at this point"); 423 424 // allocate instance 425 instanceOop res = field_vklass->allocate_instance(CHECK); 426 // copy value 427 field_vklass->value_store(((char*)(oopDesc*)obj_h()) + klass->field_offset(index), 428 field_vklass->data_for_oop(res), true, true); 429 thread->set_vm_result(res); 430 IRT_END 431 432 IRT_ENTRY(void, InterpreterRuntime::newarray(JavaThread* thread, BasicType type, jint size)) 433 oop obj = oopFactory::new_typeArray(type, size, CHECK); 434 thread->set_vm_result(obj); 435 IRT_END 436 437 438 IRT_ENTRY(void, InterpreterRuntime::anewarray(JavaThread* thread, ConstantPool* pool, int index, jint size)) 439 Klass* klass = pool->klass_at(index, CHECK); 440 bool is_qtype_desc = pool->tag_at(index).is_Qdescriptor_klass(); 441 arrayOop obj; 442 if ((!klass->is_array_klass()) && is_qtype_desc) { // Logically creates elements, ensure klass init 443 klass->initialize(CHECK); 444 obj = oopFactory::new_valueArray(klass, size, CHECK); 445 } else { 446 obj = oopFactory::new_objArray(klass, size, CHECK); 447 } 448 thread->set_vm_result(obj); 449 IRT_END 450 451 IRT_ENTRY(void, InterpreterRuntime::value_array_load(JavaThread* thread, arrayOopDesc* array, int index)) 452 Klass* klass = array->klass(); 453 assert(klass->is_valueArray_klass(), "expected value array oop"); 454 455 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass); 456 ValueKlass* vklass = vaklass->element_klass(); 457 arrayHandle ah(THREAD, array); 458 instanceOop value_holder = vklass->allocate_instance(CHECK); 459 void* src = ((valueArrayOop)ah())->value_at_addr(index, vaklass->layout_helper()); 460 vklass->value_store(src, vklass->data_for_oop(value_holder), 461 vaklass->element_byte_size(), true, false); 462 thread->set_vm_result(value_holder); 463 IRT_END 464 465 IRT_ENTRY(void, InterpreterRuntime::value_array_store(JavaThread* thread, void* val, arrayOopDesc* array, int index)) 466 assert(val != NULL, "can't store null into flat array"); 467 Klass* klass = array->klass(); 468 assert(klass->is_valueArray_klass(), "expected value array"); 469 assert(ArrayKlass::cast(klass)->element_klass() == ((oop)val)->klass(), "Store type incorrect"); 470 471 valueArrayOop varray = (valueArrayOop)array; 472 ValueArrayKlass* vaklass = ValueArrayKlass::cast(klass); 473 ValueKlass* vklass = vaklass->element_klass(); 474 const int lh = vaklass->layout_helper(); 475 vklass->value_store(vklass->data_for_oop((oop)val), varray->value_at_addr(index, lh), 476 vaklass->element_byte_size(), true, false); 477 IRT_END 478 479 IRT_ENTRY(void, InterpreterRuntime::multianewarray(JavaThread* thread, jint* first_size_address)) 480 // We may want to pass in more arguments - could make this slightly faster 481 LastFrameAccessor last_frame(thread); 482 ConstantPool* constants = last_frame.method()->constants(); 483 int i = last_frame.get_index_u2(Bytecodes::_multianewarray); 484 Klass* klass = constants->klass_at(i, CHECK); 485 bool is_qtype = constants->tag_at(i).is_Qdescriptor_klass(); 486 int nof_dims = last_frame.number_of_dimensions(); 487 assert(klass->is_klass(), "not a class"); 488 assert(nof_dims >= 1, "multianewarray rank must be nonzero"); 489 490 if (is_qtype) { // Logically creates elements, ensure klass init 491 klass->initialize(CHECK); 492 } 493 494 // We must create an array of jints to pass to multi_allocate. 495 ResourceMark rm(thread); 496 const int small_dims = 10; 497 jint dim_array[small_dims]; 498 jint *dims = &dim_array[0]; 499 if (nof_dims > small_dims) { 500 dims = (jint*) NEW_RESOURCE_ARRAY(jint, nof_dims); 501 } 502 for (int index = 0; index < nof_dims; index++) { 503 // offset from first_size_address is addressed as local[index] 504 int n = Interpreter::local_offset_in_bytes(index)/jintSize; 505 dims[index] = first_size_address[n]; 506 } 507 oop obj = ArrayKlass::cast(klass)->multi_allocate(nof_dims, dims, CHECK); 508 thread->set_vm_result(obj); 509 IRT_END 510 |