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