2299 patch_end[-2] = (u_int64_t)prolog_ptr; |
2299 patch_end[-2] = (u_int64_t)prolog_ptr; |
2300 patch_end[-1] = calltype; |
2300 patch_end[-1] = calltype; |
2301 } |
2301 } |
2302 #endif |
2302 #endif |
2303 |
2303 |
|
2304 void MacroAssembler::push_call_clobbered_registers() { |
|
2305 push(RegSet::range(r0, r18) - RegSet::of(rscratch1, rscratch2), sp); |
|
2306 |
|
2307 // Push v0-v7, v16-v31. |
|
2308 for (int i = 30; i >= 0; i -= 2) { |
|
2309 if (i <= v7->encoding() || i >= v16->encoding()) { |
|
2310 stpd(as_FloatRegister(i), as_FloatRegister(i+1), |
|
2311 Address(pre(sp, -2 * wordSize))); |
|
2312 } |
|
2313 } |
|
2314 } |
|
2315 |
|
2316 void MacroAssembler::pop_call_clobbered_registers() { |
|
2317 |
|
2318 for (int i = 0; i < 32; i += 2) { |
|
2319 if (i <= v7->encoding() || i >= v16->encoding()) { |
|
2320 ldpd(as_FloatRegister(i), as_FloatRegister(i+1), |
|
2321 Address(post(sp, 2 * wordSize))); |
|
2322 } |
|
2323 } |
|
2324 |
|
2325 pop(RegSet::range(r0, r18) - RegSet::of(rscratch1, rscratch2), sp); |
|
2326 } |
|
2327 |
2304 void MacroAssembler::push_CPU_state(bool save_vectors) { |
2328 void MacroAssembler::push_CPU_state(bool save_vectors) { |
2305 push(0x3fffffff, sp); // integer registers except lr & sp |
2329 push(0x3fffffff, sp); // integer registers except lr & sp |
2306 |
2330 |
2307 if (!save_vectors) { |
2331 if (!save_vectors) { |
2308 for (int i = 30; i >= 0; i -= 2) |
2332 for (int i = 30; i >= 0; i -= 2) |
3097 |
3121 |
3098 lsr(obj, obj, CardTableModRefBS::card_shift); |
3122 lsr(obj, obj, CardTableModRefBS::card_shift); |
3099 |
3123 |
3100 assert(CardTableModRefBS::dirty_card_val() == 0, "must be"); |
3124 assert(CardTableModRefBS::dirty_card_val() == 0, "must be"); |
3101 |
3125 |
3102 { |
3126 load_byte_map_base(rscratch1); |
3103 ExternalAddress cardtable((address) ct->byte_map_base); |
|
3104 unsigned long offset; |
|
3105 adrp(rscratch1, cardtable, offset); |
|
3106 assert(offset == 0, "byte_map_base is misaligned"); |
|
3107 } |
|
3108 |
3127 |
3109 if (UseCondCardMark) { |
3128 if (UseCondCardMark) { |
3110 Label L_already_dirty; |
3129 Label L_already_dirty; |
3111 membar(StoreLoad); |
3130 membar(StoreLoad); |
3112 ldrb(rscratch2, Address(obj, rscratch1)); |
3131 ldrb(rscratch2, Address(obj, rscratch1)); |
3594 assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code"); |
3613 assert(sizeof(*ct->byte_map_base) == sizeof(jbyte), "adjust this code"); |
3595 const Register card_addr = tmp; |
3614 const Register card_addr = tmp; |
3596 |
3615 |
3597 lsr(card_addr, store_addr, CardTableModRefBS::card_shift); |
3616 lsr(card_addr, store_addr, CardTableModRefBS::card_shift); |
3598 |
3617 |
3599 unsigned long offset; |
|
3600 adrp(tmp2, cardtable, offset); |
|
3601 |
|
3602 // get the address of the card |
3618 // get the address of the card |
|
3619 load_byte_map_base(tmp2); |
3603 add(card_addr, card_addr, tmp2); |
3620 add(card_addr, card_addr, tmp2); |
3604 ldrb(tmp2, Address(card_addr, offset)); |
3621 ldrb(tmp2, Address(card_addr)); |
3605 cmpw(tmp2, (int)G1SATBCardTableModRefBS::g1_young_card_val()); |
3622 cmpw(tmp2, (int)G1SATBCardTableModRefBS::g1_young_card_val()); |
3606 br(Assembler::EQ, done); |
3623 br(Assembler::EQ, done); |
3607 |
3624 |
3608 assert((int)CardTableModRefBS::dirty_card_val() == 0, "must be 0"); |
3625 assert((int)CardTableModRefBS::dirty_card_val() == 0, "must be 0"); |
3609 |
3626 |
3610 membar(Assembler::StoreLoad); |
3627 membar(Assembler::StoreLoad); |
3611 |
3628 |
3612 ldrb(tmp2, Address(card_addr, offset)); |
3629 ldrb(tmp2, Address(card_addr)); |
3613 cbzw(tmp2, done); |
3630 cbzw(tmp2, done); |
3614 |
3631 |
3615 // storing a region crossing, non-NULL oop, card is clean. |
3632 // storing a region crossing, non-NULL oop, card is clean. |
3616 // dirty card and log. |
3633 // dirty card and log. |
3617 |
3634 |
3618 strb(zr, Address(card_addr, offset)); |
3635 strb(zr, Address(card_addr)); |
3619 |
3636 |
3620 ldr(rscratch1, queue_index); |
3637 ldr(rscratch1, queue_index); |
3621 cbz(rscratch1, runtime); |
3638 cbz(rscratch1, runtime); |
3622 sub(rscratch1, rscratch1, wordSize); |
3639 sub(rscratch1, rscratch1, wordSize); |
3623 str(rscratch1, queue_index); |
3640 str(rscratch1, queue_index); |
3969 unsigned long high_page = (unsigned long)(CodeCache::high_bound()-1) >> 12; |
3986 unsigned long high_page = (unsigned long)(CodeCache::high_bound()-1) >> 12; |
3970 unsigned long dest_page = (unsigned long)dest.target() >> 12; |
3987 unsigned long dest_page = (unsigned long)dest.target() >> 12; |
3971 long offset_low = dest_page - low_page; |
3988 long offset_low = dest_page - low_page; |
3972 long offset_high = dest_page - high_page; |
3989 long offset_high = dest_page - high_page; |
3973 |
3990 |
|
3991 assert(is_valid_AArch64_address(dest.target()), "bad address"); |
|
3992 assert(dest.getMode() == Address::literal, "ADRP must be applied to a literal address"); |
|
3993 |
3974 InstructionMark im(this); |
3994 InstructionMark im(this); |
3975 code_section()->relocate(inst_mark(), dest.rspec()); |
3995 code_section()->relocate(inst_mark(), dest.rspec()); |
3976 // 8143067: Ensure that the adrp can reach the dest from anywhere within |
3996 // 8143067: Ensure that the adrp can reach the dest from anywhere within |
3977 // the code cache so that if it is relocated we know it will still reach |
3997 // the code cache so that if it is relocated we know it will still reach |
3978 if (offset_high >= -(1<<20) && offset_low < (1<<20)) { |
3998 if (offset_high >= -(1<<20) && offset_low < (1<<20)) { |
3980 } else { |
4000 } else { |
3981 unsigned long pc_page = (unsigned long)pc() >> 12; |
4001 unsigned long pc_page = (unsigned long)pc() >> 12; |
3982 long offset = dest_page - pc_page; |
4002 long offset = dest_page - pc_page; |
3983 offset = (offset & ((1<<20)-1)) << 12; |
4003 offset = (offset & ((1<<20)-1)) << 12; |
3984 _adrp(reg1, pc()+offset); |
4004 _adrp(reg1, pc()+offset); |
3985 movk(reg1, ((unsigned long)dest.target() >> 32) & 0xffff, 32); |
4005 movk(reg1, (unsigned long)dest.target() >> 32, 32); |
3986 } |
4006 } |
3987 byte_offset = (unsigned long)dest.target() & 0xfff; |
4007 byte_offset = (unsigned long)dest.target() & 0xfff; |
|
4008 } |
|
4009 |
|
4010 void MacroAssembler::load_byte_map_base(Register reg) { |
|
4011 jbyte *byte_map_base = |
|
4012 ((CardTableModRefBS*)(Universe::heap()->barrier_set()))->byte_map_base; |
|
4013 |
|
4014 if (is_valid_AArch64_address((address)byte_map_base)) { |
|
4015 // Strictly speaking the byte_map_base isn't an address at all, |
|
4016 // and it might even be negative. |
|
4017 unsigned long offset; |
|
4018 adrp(reg, ExternalAddress((address)byte_map_base), offset); |
|
4019 assert(offset == 0, "misaligned card table base"); |
|
4020 } else { |
|
4021 mov(reg, (uint64_t)byte_map_base); |
|
4022 } |
3988 } |
4023 } |
3989 |
4024 |
3990 void MacroAssembler::build_frame(int framesize) { |
4025 void MacroAssembler::build_frame(int framesize) { |
3991 assert(framesize > 0, "framesize must be > 0"); |
4026 assert(framesize > 0, "framesize must be > 0"); |
3992 if (framesize < ((1 << 9) + 2 * wordSize)) { |
4027 if (framesize < ((1 << 9) + 2 * wordSize)) { |