163
164 template <typename T>
165 static T atomic_cmpxchg_in_heap_at(T new_value, oop base, ptrdiff_t offset, T compare_value) {
166 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
167 return Raw::oop_atomic_cmpxchg_at(new_value, base, offset, compare_value);
168 }
169
170 template <typename T>
171 static T atomic_xchg_in_heap(T new_value, T* addr) {
172 ShouldNotReachHere();
173 return Raw::atomic_xchg(new_value, addr);
174 }
175
176 template <typename T>
177 static T atomic_xchg_in_heap_at(T new_value, oop base, ptrdiff_t offset) {
178 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
179 return Raw::atomic_xchg_at(new_value, base, offset);
180 }
181
182 template <typename T>
183 static bool arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length) {
184 return Raw::arraycopy(src_obj, dst_obj, src, dst, length);
185 }
186
187 // Heap oop accesses. These accessors get resolved when
188 // IN_HEAP is set (e.g. when using the HeapAccess API), it is
189 // an oop_* overload, and the barrier strength is AS_NORMAL.
190 template <typename T>
191 static oop oop_load_in_heap(T* addr) {
192 ShouldNotReachHere();
193 oop value = Raw::template oop_load<oop>(addr);
194 keep_alive_if_weak(decorators, value);
195 return value;
196 }
197
198 static oop oop_load_in_heap_at(oop base, ptrdiff_t offset) {
199 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->read_barrier(base);
200 oop value = Raw::template oop_load_at<oop>(base, offset);
201 keep_alive_if_weak(AccessBarrierSupport::resolve_possibly_unknown_oop_ref_strength<decorators>(base, offset), value);
202 return value;
203 }
204
205 template <typename T>
217
218 template <typename T>
219 static oop oop_atomic_cmpxchg_in_heap(oop new_value, T* addr, oop compare_value);
220
221 static oop oop_atomic_cmpxchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset, oop compare_value) {
222 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
223 new_value = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->storeval_barrier(new_value);
224 return oop_atomic_cmpxchg_in_heap(new_value, AccessInternal::oop_field_addr<decorators>(base, offset), compare_value);
225 }
226
227 template <typename T>
228 static oop oop_atomic_xchg_in_heap(oop new_value, T* addr);
229
230 static oop oop_atomic_xchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset) {
231 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
232 new_value = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->storeval_barrier(new_value);
233 return oop_atomic_xchg_in_heap(new_value, AccessInternal::oop_field_addr<decorators>(base, offset));
234 }
235
236 template <typename T>
237 static bool oop_arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length) {
238 ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_ref_array_pre(dst, length, false);
239 bool success = Raw::oop_arraycopy(src_obj, dst_obj, src, dst, length);
240 ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_ref_array((HeapWord*) dst, length);
241 return success;
242 }
243
244 // Clone barrier support
245 static void clone_in_heap(oop src, oop dst, size_t size) {
246 src = arrayOop(((ShenandoahBarrierSet*) BarrierSet::barrier_set())->read_barrier(src));
247 dst = arrayOop(((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(dst));
248 Raw::clone(src, dst, size);
249 ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_region(MemRegion((HeapWord*) dst, size));
250 }
251
252 // Needed for loads on non-heap weak references
253 template <typename T>
254 static oop oop_load_not_in_heap(T* addr) {
255 oop value = Raw::oop_load_not_in_heap(addr);
256 keep_alive_if_weak(decorators, value);
257 return value;
258 }
259
260 };
261
262 };
|
163
164 template <typename T>
165 static T atomic_cmpxchg_in_heap_at(T new_value, oop base, ptrdiff_t offset, T compare_value) {
166 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
167 return Raw::oop_atomic_cmpxchg_at(new_value, base, offset, compare_value);
168 }
169
170 template <typename T>
171 static T atomic_xchg_in_heap(T new_value, T* addr) {
172 ShouldNotReachHere();
173 return Raw::atomic_xchg(new_value, addr);
174 }
175
176 template <typename T>
177 static T atomic_xchg_in_heap_at(T new_value, oop base, ptrdiff_t offset) {
178 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
179 return Raw::atomic_xchg_at(new_value, base, offset);
180 }
181
182 template <typename T>
183 static bool arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length);
184
185 // Heap oop accesses. These accessors get resolved when
186 // IN_HEAP is set (e.g. when using the HeapAccess API), it is
187 // an oop_* overload, and the barrier strength is AS_NORMAL.
188 template <typename T>
189 static oop oop_load_in_heap(T* addr) {
190 ShouldNotReachHere();
191 oop value = Raw::template oop_load<oop>(addr);
192 keep_alive_if_weak(decorators, value);
193 return value;
194 }
195
196 static oop oop_load_in_heap_at(oop base, ptrdiff_t offset) {
197 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->read_barrier(base);
198 oop value = Raw::template oop_load_at<oop>(base, offset);
199 keep_alive_if_weak(AccessBarrierSupport::resolve_possibly_unknown_oop_ref_strength<decorators>(base, offset), value);
200 return value;
201 }
202
203 template <typename T>
215
216 template <typename T>
217 static oop oop_atomic_cmpxchg_in_heap(oop new_value, T* addr, oop compare_value);
218
219 static oop oop_atomic_cmpxchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset, oop compare_value) {
220 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
221 new_value = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->storeval_barrier(new_value);
222 return oop_atomic_cmpxchg_in_heap(new_value, AccessInternal::oop_field_addr<decorators>(base, offset), compare_value);
223 }
224
225 template <typename T>
226 static oop oop_atomic_xchg_in_heap(oop new_value, T* addr);
227
228 static oop oop_atomic_xchg_in_heap_at(oop new_value, oop base, ptrdiff_t offset) {
229 base = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(base);
230 new_value = ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->storeval_barrier(new_value);
231 return oop_atomic_xchg_in_heap(new_value, AccessInternal::oop_field_addr<decorators>(base, offset));
232 }
233
234 template <typename T>
235 static bool oop_arraycopy_in_heap(arrayOop src_obj, arrayOop dst_obj, T* src, T* dst, size_t length);
236
237 // Clone barrier support
238 static void clone_in_heap(oop src, oop dst, size_t size) {
239 src = arrayOop(((ShenandoahBarrierSet*) BarrierSet::barrier_set())->read_barrier(src));
240 dst = arrayOop(((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_barrier(dst));
241 Raw::clone(src, dst, size);
242 ((ShenandoahBarrierSet*) BarrierSet::barrier_set())->write_region(MemRegion((HeapWord*) dst, size));
243 }
244
245 // Needed for loads on non-heap weak references
246 template <typename T>
247 static oop oop_load_not_in_heap(T* addr) {
248 oop value = Raw::oop_load_not_in_heap(addr);
249 keep_alive_if_weak(decorators, value);
250 return value;
251 }
252
253 };
254
255 };
|