3054 patch_bytecode(Bytecodes::_fast_agetfield, bc, rbx);
3055 }
3056 __ jmp(Done);
3057 } else {
3058 if (is_static) {
3059 __ load_heap_oop(rax, field);
3060 Label isFlattenable, uninitialized;
3061 // Issue below if the static field has not been initialized yet
3062 __ test_field_is_flattenable(flags2, rscratch1, isFlattenable);
3063 // Not flattenable case
3064 __ push(atos);
3065 __ jmp(Done);
3066 // Flattenable case, must not return null even if uninitialized
3067 __ bind(isFlattenable);
3068 __ testptr(rax, rax);
3069 __ jcc(Assembler::zero, uninitialized);
3070 __ push(atos);
3071 __ jmp(Done);
3072 __ bind(uninitialized);
3073 __ andl(flags2, ConstantPoolCacheEntry::field_index_mask);
3074 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_static_value_field),
3075 obj, flags2);
3076 __ verify_oop(rax);
3077 __ push(atos);
3078 __ jmp(Done);
3079 } else {
3080 Label isFlattened, nonnull, isFlattenable, rewriteFlattenable;
3081 __ test_field_is_flattenable(flags2, rscratch1, isFlattenable);
3082 // Non-flattenable field case, also covers the object case
3083 pop_and_check_object(obj);
3084 __ load_heap_oop(rax, field);
3085 __ push(atos);
3086 if (rc == may_rewrite) {
3087 patch_bytecode(Bytecodes::_fast_agetfield, bc, rbx);
3088 }
3089 __ jmp(Done);
3090 __ bind(isFlattenable);
3091 __ test_field_is_flattened(flags2, rscratch1, isFlattened);
3092 // Non-flattened field case
3093 pop_and_check_object(obj);
3094 __ load_heap_oop(rax, field);
3095 __ testptr(rax, rax);
3096 __ jcc(Assembler::notZero, nonnull);
3097 __ andl(flags2, ConstantPoolCacheEntry::field_index_mask);
3098 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_instance_value_field),
3099 obj, flags2);
3100 __ bind(nonnull);
3101 __ verify_oop(rax);
3102 __ push(atos);
3103 __ jmp(rewriteFlattenable);
3104 __ bind(isFlattened);
3105 __ andl(flags2, ConstantPoolCacheEntry::field_index_mask);
3106 pop_and_check_object(rax);
3107 __ read_flattened_field(rcx, flags2, rbx, rax);
3108 __ verify_oop(rax);
3109 __ push(atos);
3110 __ bind(rewriteFlattenable);
3111 if (rc == may_rewrite) {
3112 patch_bytecode(Bytecodes::_fast_qgetfield, bc, rbx);
3113 }
3114 __ jmp(Done);
3115 }
3116 }
3117
3118 __ bind(notObj);
3119
3797 //
3798 __ movptr(rdx, Address(rcx, rbx, Address::times_ptr,
3799 in_bytes(ConstantPoolCache::base_offset() +
3800 ConstantPoolCacheEntry::f2_offset())));
3801
3802 // rax: object
3803 __ verify_oop(rax);
3804 __ null_check(rax);
3805 Address field(rax, rdx, Address::times_1);
3806
3807 // access field
3808 switch (bytecode()) {
3809 case Bytecodes::_fast_qgetfield:
3810 {
3811 Label isFlattened, nonnull, Done;
3812 __ movptr(rscratch1, Address(rcx, rbx, Address::times_ptr,
3813 in_bytes(ConstantPoolCache::base_offset() +
3814 ConstantPoolCacheEntry::flags_offset())));
3815 __ test_field_is_flattened(rscratch1, rscratch2, isFlattened);
3816 // Non-flattened field case
3817 __ movptr(rscratch1, rax);
3818 __ load_heap_oop(rax, field);
3819 __ testptr(rax, rax);
3820 __ jcc(Assembler::notZero, nonnull);
3821 __ movptr(rax, rscratch1);
3822 __ movl(rcx, Address(rcx, rbx, Address::times_ptr,
3823 in_bytes(ConstantPoolCache::base_offset() +
3824 ConstantPoolCacheEntry::flags_offset())));
3825 __ andl(rcx, ConstantPoolCacheEntry::field_index_mask);
3826 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_instance_value_field),
3827 rax, rcx);
3828 __ bind(nonnull);
3829 __ verify_oop(rax);
3830 __ jmp(Done);
3831 __ bind(isFlattened);
3832 __ push(rdx); // save offset
3833 __ movl(rdx, Address(rcx, rbx, Address::times_ptr,
3834 in_bytes(ConstantPoolCache::base_offset() +
3835 ConstantPoolCacheEntry::flags_offset())));
3836 __ andl(rdx, ConstantPoolCacheEntry::field_index_mask);
3837 __ movptr(rcx, Address(rcx, rbx, Address::times_ptr,
3838 in_bytes(ConstantPoolCache::base_offset() +
3839 ConstantPoolCacheEntry::f1_offset())));
3840 __ pop(rbx); // restore offset
3841 __ read_flattened_field(rcx, rdx, rbx, rax);
3842 __ bind(Done);
3843 __ verify_oop(rax);
3844 }
3845 break;
3846 case Bytecodes::_fast_agetfield:
3847 do_oop_load(_masm, field, rax);
|
3054 patch_bytecode(Bytecodes::_fast_agetfield, bc, rbx);
3055 }
3056 __ jmp(Done);
3057 } else {
3058 if (is_static) {
3059 __ load_heap_oop(rax, field);
3060 Label isFlattenable, uninitialized;
3061 // Issue below if the static field has not been initialized yet
3062 __ test_field_is_flattenable(flags2, rscratch1, isFlattenable);
3063 // Not flattenable case
3064 __ push(atos);
3065 __ jmp(Done);
3066 // Flattenable case, must not return null even if uninitialized
3067 __ bind(isFlattenable);
3068 __ testptr(rax, rax);
3069 __ jcc(Assembler::zero, uninitialized);
3070 __ push(atos);
3071 __ jmp(Done);
3072 __ bind(uninitialized);
3073 __ andl(flags2, ConstantPoolCacheEntry::field_index_mask);
3074 #ifdef _LP64
3075 Label slow_case, finish;
3076 __ cmpb(Address(rcx, InstanceKlass::init_state_offset()), InstanceKlass::fully_initialized);
3077 __ jcc(Assembler::notEqual, slow_case);
3078 __ get_default_value_oop(rcx, off, rax);
3079 __ jmp(finish);
3080 __ bind(slow_case);
3081 #endif // LP64
3082 __ call_VM(rax, CAST_FROM_FN_PTR(address, InterpreterRuntime::uninitialized_static_value_field),
3083 obj, flags2);
3084 #ifdef _LP64
3085 __ bind(finish);
3086 #endif // _LP64
3087 __ verify_oop(rax);
3088 __ push(atos);
3089 __ jmp(Done);
3090 } else {
3091 Label isFlattened, nonnull, isFlattenable, rewriteFlattenable;
3092 __ test_field_is_flattenable(flags2, rscratch1, isFlattenable);
3093 // Non-flattenable field case, also covers the object case
3094 pop_and_check_object(obj);
3095 __ load_heap_oop(rax, field);
3096 __ push(atos);
3097 if (rc == may_rewrite) {
3098 patch_bytecode(Bytecodes::_fast_agetfield, bc, rbx);
3099 }
3100 __ jmp(Done);
3101 __ bind(isFlattenable);
3102 __ test_field_is_flattened(flags2, rscratch1, isFlattened);
3103 // Non-flattened field case
3104 __ movptr(rax, rcx); // small dance required to preserve the klass_holder somewhere
3105 pop_and_check_object(obj);
3106 __ push(rax);
3107 __ load_heap_oop(rax, field);
3108 __ pop(rcx);
3109 __ testptr(rax, rax);
3110 __ jcc(Assembler::notZero, nonnull);
3111 __ andl(flags2, ConstantPoolCacheEntry::field_index_mask);
3112 __ get_value_field_klass(rcx, flags2, rbx);
3113 __ get_default_value_oop(rbx, rcx, rax);
3114 __ bind(nonnull);
3115 __ verify_oop(rax);
3116 __ push(atos);
3117 __ jmp(rewriteFlattenable);
3118 __ bind(isFlattened);
3119 __ andl(flags2, ConstantPoolCacheEntry::field_index_mask);
3120 pop_and_check_object(rax);
3121 __ read_flattened_field(rcx, flags2, rbx, rax);
3122 __ verify_oop(rax);
3123 __ push(atos);
3124 __ bind(rewriteFlattenable);
3125 if (rc == may_rewrite) {
3126 patch_bytecode(Bytecodes::_fast_qgetfield, bc, rbx);
3127 }
3128 __ jmp(Done);
3129 }
3130 }
3131
3132 __ bind(notObj);
3133
3811 //
3812 __ movptr(rdx, Address(rcx, rbx, Address::times_ptr,
3813 in_bytes(ConstantPoolCache::base_offset() +
3814 ConstantPoolCacheEntry::f2_offset())));
3815
3816 // rax: object
3817 __ verify_oop(rax);
3818 __ null_check(rax);
3819 Address field(rax, rdx, Address::times_1);
3820
3821 // access field
3822 switch (bytecode()) {
3823 case Bytecodes::_fast_qgetfield:
3824 {
3825 Label isFlattened, nonnull, Done;
3826 __ movptr(rscratch1, Address(rcx, rbx, Address::times_ptr,
3827 in_bytes(ConstantPoolCache::base_offset() +
3828 ConstantPoolCacheEntry::flags_offset())));
3829 __ test_field_is_flattened(rscratch1, rscratch2, isFlattened);
3830 // Non-flattened field case
3831 __ load_heap_oop(rax, field);
3832 __ testptr(rax, rax);
3833 __ jcc(Assembler::notZero, nonnull);
3834 __ movl(rdx, Address(rcx, rbx, Address::times_ptr,
3835 in_bytes(ConstantPoolCache::base_offset() +
3836 ConstantPoolCacheEntry::flags_offset())));
3837 __ andl(rdx, ConstantPoolCacheEntry::field_index_mask);
3838 __ movptr(rcx, Address(rcx, rbx, Address::times_ptr,
3839 in_bytes(ConstantPoolCache::base_offset() +
3840 ConstantPoolCacheEntry::f1_offset())));
3841 __ get_value_field_klass(rcx, rdx, rbx);
3842 __ get_default_value_oop(rbx, rcx, rax);
3843 __ bind(nonnull);
3844 __ verify_oop(rax);
3845 __ jmp(Done);
3846 __ bind(isFlattened);
3847 __ push(rdx); // save offset
3848 __ movl(rdx, Address(rcx, rbx, Address::times_ptr,
3849 in_bytes(ConstantPoolCache::base_offset() +
3850 ConstantPoolCacheEntry::flags_offset())));
3851 __ andl(rdx, ConstantPoolCacheEntry::field_index_mask);
3852 __ movptr(rcx, Address(rcx, rbx, Address::times_ptr,
3853 in_bytes(ConstantPoolCache::base_offset() +
3854 ConstantPoolCacheEntry::f1_offset())));
3855 __ pop(rbx); // restore offset
3856 __ read_flattened_field(rcx, rdx, rbx, rax);
3857 __ bind(Done);
3858 __ verify_oop(rax);
3859 }
3860 break;
3861 case Bytecodes::_fast_agetfield:
3862 do_oop_load(_masm, field, rax);
|