< prev index next >

src/hotspot/cpu/aarch64/templateTable_aarch64.cpp

Print this page

 335   const int tags_offset = Array<u1>::base_offset_in_bytes();
 336 
 337   // get type
 338   __ add(r3, r1, tags_offset);
 339   __ lea(r3, Address(r0, r3));
 340   __ ldarb(r3, r3);
 341 
 342   // unresolved class - get the resolved class
 343   __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClass);
 344   __ br(Assembler::EQ, call_ldc);
 345 
 346   // unresolved class in error state - call into runtime to throw the error
 347   // from the first resolution attempt
 348   __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClassInError);
 349   __ br(Assembler::EQ, call_ldc);
 350 
 351   // resolved class - need to call vm to get java mirror of the class
 352   __ cmp(r3, (u1)JVM_CONSTANT_Class);
 353   __ br(Assembler::NE, notClass);
 354 












 355   __ bind(call_ldc);
 356   __ mov(c_rarg1, is_ldc_wide(type) ? 1 : 0);
 357   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);
 358   __ push_ptr(r0);
 359   __ verify_oop(r0);
 360   __ b(Done);
 361 
 362   __ bind(notClass);
 363   __ cmp(r3, (u1)JVM_CONSTANT_Float);
 364   __ br(Assembler::NE, notFloat);
 365   // ftos
 366   __ adds(r1, r2, r1, Assembler::LSL, 3);
 367   __ ldrs(v0, Address(r1, base_offset));
 368   __ push_f();
 369   __ b(Done);
 370 
 371   __ bind(notFloat);
 372 
 373   __ cmp(r3, (u1)JVM_CONSTANT_Integer);
 374   __ br(Assembler::NE, notInt);

2296   // Update registers with resolved info
2297   __ load_method_entry(Rcache, index);
2298   // n.b. unlike x86 Rcache is now rcpool plus the indexed offset
2299   // so all clients ofthis method must be modified accordingly
2300   __ bind(resolved);
2301 
2302   // Class initialization barrier for static methods
2303   if (VM_Version::supports_fast_class_init_checks() && bytecode() == Bytecodes::_invokestatic) {
2304     __ ldr(temp, Address(Rcache, in_bytes(ResolvedMethodEntry::method_offset())));
2305     __ load_method_holder(temp, temp);
2306     __ clinit_barrier(temp, rscratch1, nullptr, &clinit_barrier_slow);
2307   }
2308 }
2309 
2310 void TemplateTable::resolve_cache_and_index_for_field(int byte_no,
2311                                             Register Rcache,
2312                                             Register index) {
2313   const Register temp = r19;
2314   assert_different_registers(Rcache, index, temp);
2315 
2316   Label resolved;
2317 
2318   Bytecodes::Code code = bytecode();
2319   switch (code) {
2320   case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break;
2321   case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break;
2322   default: break;
2323   }
2324 
2325   assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
2326   __ load_field_entry(Rcache, index);
2327   if (byte_no == f1_byte) {
2328     __ lea(temp, Address(Rcache, in_bytes(ResolvedFieldEntry::get_code_offset())));
2329   } else {
2330     __ lea(temp, Address(Rcache, in_bytes(ResolvedFieldEntry::put_code_offset())));
2331   }
2332   // Load-acquire the bytecode to match store-release in ResolvedFieldEntry::fill_in()
2333   __ ldarb(temp, temp);
2334   __ subs(zr, temp, (int) code);  // have we resolved this bytecode?
2335   __ br(Assembler::EQ, resolved);
2336 
2337   // resolve first time through

2338   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
2339   __ mov(temp, (int) code);
2340   __ call_VM(noreg, entry, temp);
2341 
2342   // Update registers with resolved info
2343   __ load_field_entry(Rcache, index);
2344   __ bind(resolved);







2345 }
2346 
2347 void TemplateTable::load_resolved_field_entry(Register obj,
2348                                               Register cache,
2349                                               Register tos_state,
2350                                               Register offset,
2351                                               Register flags,
2352                                               bool is_static = false) {
2353   assert_different_registers(cache, tos_state, flags, offset);
2354 
2355   // Field offset
2356   __ load_sized_value(offset, Address(cache, in_bytes(ResolvedFieldEntry::field_offset_offset())), sizeof(int), true /*is_signed*/);
2357 
2358   // Flags
2359   __ load_unsigned_byte(flags, Address(cache, in_bytes(ResolvedFieldEntry::flags_offset())));
2360 
2361   // TOS state
2362   if (tos_state != noreg) {
2363     __ load_unsigned_byte(tos_state, Address(cache, in_bytes(ResolvedFieldEntry::type_offset())));
2364   }

 335   const int tags_offset = Array<u1>::base_offset_in_bytes();
 336 
 337   // get type
 338   __ add(r3, r1, tags_offset);
 339   __ lea(r3, Address(r0, r3));
 340   __ ldarb(r3, r3);
 341 
 342   // unresolved class - get the resolved class
 343   __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClass);
 344   __ br(Assembler::EQ, call_ldc);
 345 
 346   // unresolved class in error state - call into runtime to throw the error
 347   // from the first resolution attempt
 348   __ cmp(r3, (u1)JVM_CONSTANT_UnresolvedClassInError);
 349   __ br(Assembler::EQ, call_ldc);
 350 
 351   // resolved class - need to call vm to get java mirror of the class
 352   __ cmp(r3, (u1)JVM_CONSTANT_Class);
 353   __ br(Assembler::NE, notClass);
 354 
 355   __ load_resolved_klass_at_offset(r2, r1, r3, rscratch1); // kills r3=tag
 356 
 357   __ cmp(r3, zr); // resolved_klass ?= null
 358   __ br(Assembler::EQ, call_ldc);
 359 
 360   const int mirror_offset = in_bytes(Klass::java_mirror_offset());
 361   __ ldr(r3, Address(r3, mirror_offset));
 362   __ resolve_oop_handle(r3, rscratch1, rscratch2);
 363   __ push_ptr(r3);
 364 
 365   __ b(Done);
 366 
 367   __ bind(call_ldc);
 368   __ mov(c_rarg1, is_ldc_wide(type) ? 1 : 0);
 369   call_VM(r0, CAST_FROM_FN_PTR(address, InterpreterRuntime::ldc), c_rarg1);
 370   __ push_ptr(r0);
 371   __ verify_oop(r0);
 372   __ b(Done);
 373 
 374   __ bind(notClass);
 375   __ cmp(r3, (u1)JVM_CONSTANT_Float);
 376   __ br(Assembler::NE, notFloat);
 377   // ftos
 378   __ adds(r1, r2, r1, Assembler::LSL, 3);
 379   __ ldrs(v0, Address(r1, base_offset));
 380   __ push_f();
 381   __ b(Done);
 382 
 383   __ bind(notFloat);
 384 
 385   __ cmp(r3, (u1)JVM_CONSTANT_Integer);
 386   __ br(Assembler::NE, notInt);

2308   // Update registers with resolved info
2309   __ load_method_entry(Rcache, index);
2310   // n.b. unlike x86 Rcache is now rcpool plus the indexed offset
2311   // so all clients ofthis method must be modified accordingly
2312   __ bind(resolved);
2313 
2314   // Class initialization barrier for static methods
2315   if (VM_Version::supports_fast_class_init_checks() && bytecode() == Bytecodes::_invokestatic) {
2316     __ ldr(temp, Address(Rcache, in_bytes(ResolvedMethodEntry::method_offset())));
2317     __ load_method_holder(temp, temp);
2318     __ clinit_barrier(temp, rscratch1, nullptr, &clinit_barrier_slow);
2319   }
2320 }
2321 
2322 void TemplateTable::resolve_cache_and_index_for_field(int byte_no,
2323                                             Register Rcache,
2324                                             Register index) {
2325   const Register temp = r19;
2326   assert_different_registers(Rcache, index, temp);
2327 
2328   Label resolved, clinit_barrier_slow;
2329 
2330   Bytecodes::Code code = bytecode();
2331   switch (code) {
2332   case Bytecodes::_nofast_getfield: code = Bytecodes::_getfield; break;
2333   case Bytecodes::_nofast_putfield: code = Bytecodes::_putfield; break;
2334   default: break;
2335   }
2336 
2337   assert(byte_no == f1_byte || byte_no == f2_byte, "byte_no out of range");
2338   __ load_field_entry(Rcache, index);
2339   if (byte_no == f1_byte) {
2340     __ lea(temp, Address(Rcache, in_bytes(ResolvedFieldEntry::get_code_offset())));
2341   } else {
2342     __ lea(temp, Address(Rcache, in_bytes(ResolvedFieldEntry::put_code_offset())));
2343   }
2344   // Load-acquire the bytecode to match store-release in ResolvedFieldEntry::fill_in()
2345   __ ldarb(temp, temp);
2346   __ subs(zr, temp, (int) code);  // have we resolved this bytecode?
2347   __ br(Assembler::EQ, resolved);
2348 
2349   // resolve first time through
2350   __ bind(clinit_barrier_slow);
2351   address entry = CAST_FROM_FN_PTR(address, InterpreterRuntime::resolve_from_cache);
2352   __ mov(temp, (int) code);
2353   __ call_VM(noreg, entry, temp);
2354 
2355   // Update registers with resolved info
2356   __ load_field_entry(Rcache, index);
2357   __ bind(resolved);
2358 
2359   // Class initialization barrier for static fields
2360   if (VM_Version::supports_fast_class_init_checks() &&
2361       (bytecode() == Bytecodes::_getstatic || bytecode() == Bytecodes::_putstatic)) {
2362     __ ldr(temp, Address(Rcache, ResolvedFieldEntry::field_holder_offset()));
2363     __ clinit_barrier(temp, rscratch1, nullptr, &clinit_barrier_slow);
2364   }
2365 }
2366 
2367 void TemplateTable::load_resolved_field_entry(Register obj,
2368                                               Register cache,
2369                                               Register tos_state,
2370                                               Register offset,
2371                                               Register flags,
2372                                               bool is_static = false) {
2373   assert_different_registers(cache, tos_state, flags, offset);
2374 
2375   // Field offset
2376   __ load_sized_value(offset, Address(cache, in_bytes(ResolvedFieldEntry::field_offset_offset())), sizeof(int), true /*is_signed*/);
2377 
2378   // Flags
2379   __ load_unsigned_byte(flags, Address(cache, in_bytes(ResolvedFieldEntry::flags_offset())));
2380 
2381   // TOS state
2382   if (tos_state != noreg) {
2383     __ load_unsigned_byte(tos_state, Address(cache, in_bytes(ResolvedFieldEntry::type_offset())));
2384   }
< prev index next >