1 /* 2 * Copyright (c) 2018, 2021, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "asm/macroAssembler.inline.hpp" 27 #include "gc/shared/barrierSet.hpp" 28 #include "gc/shared/cardTable.hpp" 29 #include "gc/shared/cardTableBarrierSet.hpp" 30 #include "gc/shared/cardTableBarrierSetAssembler.hpp" 31 #include "gc/shared/gc_globals.hpp" 32 33 #define __ masm-> 34 35 #ifdef PRODUCT 36 #define BLOCK_COMMENT(str) /* nothing */ 37 #else 38 #define BLOCK_COMMENT(str) __ block_comment(str) 39 #endif 40 41 #define BIND(label) bind(label); BLOCK_COMMENT(#label ":") 42 43 #define TIMES_OOP (UseCompressedOops ? Address::times_4 : Address::times_8) 44 45 void CardTableBarrierSetAssembler::gen_write_ref_array_post_barrier(MacroAssembler* masm, DecoratorSet decorators, 46 Register addr, Register count, Register tmp) { 47 BarrierSet *bs = BarrierSet::barrier_set(); 48 CardTableBarrierSet* ctbs = barrier_set_cast<CardTableBarrierSet>(bs); 49 CardTable* ct = ctbs->card_table(); 50 intptr_t disp = (intptr_t) ct->byte_map_base(); 51 52 Label L_loop, L_done; 53 const Register end = count; 54 assert_different_registers(addr, end); 55 56 __ testl(count, count); 57 __ jcc(Assembler::zero, L_done); // zero count - nothing to do 58 59 60 #ifdef _LP64 61 __ leaq(end, Address(addr, count, TIMES_OOP, 0)); // end == addr+count*oop_size 62 __ subptr(end, BytesPerHeapOop); // end - 1 to make inclusive 63 __ shrptr(addr, CardTable::card_shift()); 64 __ shrptr(end, CardTable::card_shift()); 65 __ subptr(end, addr); // end --> cards count 66 67 __ mov64(tmp, disp); 68 __ addptr(addr, tmp); 69 __ BIND(L_loop); 70 __ movb(Address(addr, count, Address::times_1), 0); 71 __ decrement(count); 72 __ jcc(Assembler::greaterEqual, L_loop); 73 #else 74 __ lea(end, Address(addr, count, Address::times_ptr, -wordSize)); 75 __ shrptr(addr, CardTable::card_shift()); 76 __ shrptr(end, CardTable::card_shift()); 77 __ subptr(end, addr); // end --> count 78 __ BIND(L_loop); 79 Address cardtable(addr, count, Address::times_1, disp); 80 __ movb(cardtable, 0); 81 __ decrement(count); 82 __ jcc(Assembler::greaterEqual, L_loop); 83 #endif 84 85 __ BIND(L_done); 86 } 87 88 void CardTableBarrierSetAssembler::store_check(MacroAssembler* masm, Register obj, Address dst) { 89 // Does a store check for the oop in register obj. The content of 90 // register obj is destroyed afterwards. 91 BarrierSet* bs = BarrierSet::barrier_set(); 92 93 CardTableBarrierSet* ctbs = barrier_set_cast<CardTableBarrierSet>(bs); 94 CardTable* ct = ctbs->card_table(); 95 96 __ shrptr(obj, CardTable::card_shift()); 97 98 Address card_addr; 99 100 // The calculation for byte_map_base is as follows: 101 // byte_map_base = _byte_map - (uintptr_t(low_bound) >> card_shift); 102 // So this essentially converts an address to a displacement and it will 103 // never need to be relocated. On 64bit however the value may be too 104 // large for a 32bit displacement. 105 intptr_t byte_map_base = (intptr_t)ct->byte_map_base(); 106 if (__ is_simm32(byte_map_base)) { 107 card_addr = Address(noreg, obj, Address::times_1, byte_map_base); 108 } else { 109 // By doing it as an ExternalAddress 'byte_map_base' could be converted to a rip-relative 110 // displacement and done in a single instruction given favorable mapping and a 111 // smarter version of as_Address. However, 'ExternalAddress' generates a relocation 112 // entry and that entry is not properly handled by the relocation code. 113 AddressLiteral cardtable((address)byte_map_base, relocInfo::none); 114 Address index(noreg, obj, Address::times_1); 115 card_addr = __ as_Address(ArrayAddress(cardtable, index), rscratch1); 116 } 117 118 int dirty = CardTable::dirty_card_val(); 119 if (UseCondCardMark) { 120 Label L_already_dirty; 121 __ cmpb(card_addr, dirty); 122 __ jccb(Assembler::equal, L_already_dirty); 123 __ movb(card_addr, dirty); 124 __ bind(L_already_dirty); 125 } else { 126 __ movb(card_addr, dirty); 127 } 128 } 129 130 void CardTableBarrierSetAssembler::oop_store_at(MacroAssembler* masm, DecoratorSet decorators, BasicType type, 131 Address dst, Register val, Register tmp1, Register tmp2, Register tmp3) { 132 bool in_heap = (decorators & IN_HEAP) != 0; 133 134 bool is_array = (decorators & IS_ARRAY) != 0; 135 bool on_anonymous = (decorators & ON_UNKNOWN_OOP_REF) != 0; 136 bool precise = is_array || on_anonymous; 137 138 bool needs_post_barrier = val != noreg && in_heap; 139 140 BarrierSetAssembler::store_at(masm, decorators, type, dst, val, noreg, noreg, noreg); 141 if (needs_post_barrier) { 142 // flatten object address if needed 143 if (!precise || (dst.index() == noreg && dst.disp() == 0)) { 144 if (tmp3 != noreg) { 145 // Called by MacroAssembler::pack_inline_helper. We cannot corrupt the dst.base() register 146 __ movptr(tmp3, dst.base()); 147 store_check(masm, tmp3, dst); 148 } else { 149 // It's OK to corrupt the dst.base() register. 150 store_check(masm, dst.base(), dst); 151 } 152 } else { 153 __ lea(tmp1, dst); 154 store_check(masm, tmp1, dst); 155 } 156 } 157 } --- EOF ---