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 }
|