1 /* 2 * Copyright (c) 2017, 2022, 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 #ifndef SHARE_OOPS_ACCESSBACKEND_HPP 26 #define SHARE_OOPS_ACCESSBACKEND_HPP 27 28 #include "gc/shared/barrierSetConfig.hpp" 29 #include "memory/allocation.hpp" 30 #include "metaprogramming/enableIf.hpp" 31 #include "oops/accessDecorators.hpp" 32 #include "oops/oopsHierarchy.hpp" 33 #include "runtime/globals.hpp" 34 #include "utilities/debug.hpp" 35 #include "utilities/globalDefinitions.hpp" 36 37 #include <type_traits> 38 39 // This metafunction returns either oop or narrowOop depending on whether 40 // an access needs to use compressed oops or not. 41 template <DecoratorSet decorators> 42 struct HeapOopType: AllStatic { 43 static const bool needs_oop_compress = HasDecorator<decorators, INTERNAL_CONVERT_COMPRESSED_OOP>::value && 44 HasDecorator<decorators, INTERNAL_RT_USE_COMPRESSED_OOPS>::value; 45 using type = std::conditional_t<needs_oop_compress, narrowOop, oop>; 46 }; 47 48 namespace AccessInternal { 49 enum BarrierType { 50 BARRIER_STORE, 51 BARRIER_STORE_AT, 52 BARRIER_LOAD, 53 BARRIER_LOAD_AT, 54 BARRIER_ATOMIC_CMPXCHG, 55 BARRIER_ATOMIC_CMPXCHG_AT, 56 BARRIER_ATOMIC_XCHG, 57 BARRIER_ATOMIC_XCHG_AT, 58 BARRIER_ARRAYCOPY, 59 BARRIER_CLONE 60 }; 61 62 template <DecoratorSet decorators, typename T> 63 struct MustConvertCompressedOop: public std::integral_constant<bool, 64 HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value && 65 std::is_same<typename HeapOopType<decorators>::type, narrowOop>::value && 66 std::is_same<T, oop>::value> {}; 67 68 // This metafunction returns an appropriate oop type if the value is oop-like 69 // and otherwise returns the same type T. 70 template <DecoratorSet decorators, typename T> 71 struct EncodedType: AllStatic { 72 using type = std::conditional_t<HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value, 73 typename HeapOopType<decorators>::type, 74 T>; 75 }; 76 77 template <DecoratorSet decorators> 78 inline typename HeapOopType<decorators>::type* 79 oop_field_addr(oop base, ptrdiff_t byte_offset) { 80 return reinterpret_cast<typename HeapOopType<decorators>::type*>( 81 reinterpret_cast<intptr_t>((void*)base) + byte_offset); 82 } 83 84 template <DecoratorSet decorators, typename T> 85 struct AccessFunctionTypes { 86 typedef T (*load_at_func_t)(oop base, ptrdiff_t offset); 87 typedef void (*store_at_func_t)(oop base, ptrdiff_t offset, T value); 88 typedef T (*atomic_cmpxchg_at_func_t)(oop base, ptrdiff_t offset, T compare_value, T new_value); 89 typedef T (*atomic_xchg_at_func_t)(oop base, ptrdiff_t offset, T new_value); 90 91 typedef T (*load_func_t)(void* addr); 92 typedef void (*store_func_t)(void* addr, T value); 93 typedef T (*atomic_cmpxchg_func_t)(void* addr, T compare_value, T new_value); 94 typedef T (*atomic_xchg_func_t)(void* addr, T new_value); 95 96 typedef bool (*arraycopy_func_t)(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 97 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 98 size_t length); 99 typedef void (*clone_func_t)(oop src, oop dst, size_t size); 100 }; 101 102 template <DecoratorSet decorators> 103 struct AccessFunctionTypes<decorators, void> { 104 typedef bool (*arraycopy_func_t)(arrayOop src_obj, size_t src_offset_in_bytes, void* src, 105 arrayOop dst_obj, size_t dst_offset_in_bytes, void* dst, 106 size_t length); 107 }; 108 109 template <DecoratorSet decorators, typename T, BarrierType barrier> struct AccessFunction {}; 110 111 #define ACCESS_GENERATE_ACCESS_FUNCTION(bt, func) \ 112 template <DecoratorSet decorators, typename T> \ 113 struct AccessFunction<decorators, T, bt>: AllStatic{ \ 114 typedef typename AccessFunctionTypes<decorators, T>::func type; \ 115 } 116 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_STORE, store_func_t); 117 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_STORE_AT, store_at_func_t); 118 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_LOAD, load_func_t); 119 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_LOAD_AT, load_at_func_t); 120 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_ATOMIC_CMPXCHG, atomic_cmpxchg_func_t); 121 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_ATOMIC_CMPXCHG_AT, atomic_cmpxchg_at_func_t); 122 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_ATOMIC_XCHG, atomic_xchg_func_t); 123 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_ATOMIC_XCHG_AT, atomic_xchg_at_func_t); 124 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_ARRAYCOPY, arraycopy_func_t); 125 ACCESS_GENERATE_ACCESS_FUNCTION(BARRIER_CLONE, clone_func_t); 126 #undef ACCESS_GENERATE_ACCESS_FUNCTION 127 128 template <DecoratorSet decorators, typename T, BarrierType barrier_type> 129 typename AccessFunction<decorators, T, barrier_type>::type resolve_barrier(); 130 131 template <DecoratorSet decorators, typename T, BarrierType barrier_type> 132 typename AccessFunction<decorators, T, barrier_type>::type resolve_oop_barrier(); 133 134 void* field_addr(oop base, ptrdiff_t offset); 135 136 // Forward calls to Copy:: in the cpp file to reduce dependencies and allow 137 // faster build times, given how frequently included access is. 138 void arraycopy_arrayof_conjoint_oops(void* src, void* dst, size_t length); 139 void arraycopy_conjoint_oops(oop* src, oop* dst, size_t length); 140 void arraycopy_conjoint_oops(narrowOop* src, narrowOop* dst, size_t length); 141 142 void arraycopy_disjoint_words(void* src, void* dst, size_t length); 143 void arraycopy_disjoint_words_atomic(void* src, void* dst, size_t length); 144 145 template<typename T> 146 void arraycopy_conjoint(T* src, T* dst, size_t length); 147 template<typename T> 148 void arraycopy_arrayof_conjoint(T* src, T* dst, size_t length); 149 template<typename T> 150 void arraycopy_conjoint_atomic(T* src, T* dst, size_t length); 151 } 152 153 // This mask specifies what decorators are relevant for raw accesses. When passing 154 // accesses to the raw layer, irrelevant decorators are removed. 155 const DecoratorSet RAW_DECORATOR_MASK = INTERNAL_DECORATOR_MASK | MO_DECORATOR_MASK | 156 ARRAYCOPY_DECORATOR_MASK | IS_NOT_NULL; 157 158 // The RawAccessBarrier performs raw accesses with additional knowledge of 159 // memory ordering, so that OrderAccess/Atomic is called when necessary. 160 // It additionally handles compressed oops, and hence is not completely "raw" 161 // strictly speaking. 162 template <DecoratorSet decorators> 163 class RawAccessBarrier: public AllStatic { 164 protected: 165 static inline void* field_addr(oop base, ptrdiff_t byte_offset) { 166 return AccessInternal::field_addr(base, byte_offset); 167 } 168 169 protected: 170 // Only encode if INTERNAL_VALUE_IS_OOP 171 template <DecoratorSet idecorators, typename T> 172 static inline typename EnableIf< 173 AccessInternal::MustConvertCompressedOop<idecorators, T>::value, 174 typename HeapOopType<idecorators>::type>::type 175 encode_internal(T value); 176 177 template <DecoratorSet idecorators, typename T> 178 static inline typename EnableIf< 179 !AccessInternal::MustConvertCompressedOop<idecorators, T>::value, T>::type 180 encode_internal(T value) { 181 return value; 182 } 183 184 template <typename T> 185 static inline typename AccessInternal::EncodedType<decorators, T>::type 186 encode(T value) { 187 return encode_internal<decorators, T>(value); 188 } 189 190 // Only decode if INTERNAL_VALUE_IS_OOP 191 template <DecoratorSet idecorators, typename T> 192 static inline typename EnableIf< 193 AccessInternal::MustConvertCompressedOop<idecorators, T>::value, T>::type 194 decode_internal(typename HeapOopType<idecorators>::type value); 195 196 template <DecoratorSet idecorators, typename T> 197 static inline typename EnableIf< 198 !AccessInternal::MustConvertCompressedOop<idecorators, T>::value, T>::type 199 decode_internal(T value) { 200 return value; 201 } 202 203 template <typename T> 204 static inline T decode(typename AccessInternal::EncodedType<decorators, T>::type value) { 205 return decode_internal<decorators, T>(value); 206 } 207 208 protected: 209 template <DecoratorSet ds, typename T> 210 static typename EnableIf< 211 HasDecorator<ds, MO_SEQ_CST>::value, T>::type 212 load_internal(void* addr); 213 214 template <DecoratorSet ds, typename T> 215 static typename EnableIf< 216 HasDecorator<ds, MO_ACQUIRE>::value, T>::type 217 load_internal(void* addr); 218 219 template <DecoratorSet ds, typename T> 220 static typename EnableIf< 221 HasDecorator<ds, MO_RELAXED>::value, T>::type 222 load_internal(void* addr); 223 224 template <DecoratorSet ds, typename T> 225 static inline typename EnableIf< 226 HasDecorator<ds, MO_UNORDERED>::value, T>::type 227 load_internal(void* addr) { 228 return *reinterpret_cast<T*>(addr); 229 } 230 231 template <DecoratorSet ds, typename T> 232 static typename EnableIf< 233 HasDecorator<ds, MO_SEQ_CST>::value>::type 234 store_internal(void* addr, T value); 235 236 template <DecoratorSet ds, typename T> 237 static typename EnableIf< 238 HasDecorator<ds, MO_RELEASE>::value>::type 239 store_internal(void* addr, T value); 240 241 template <DecoratorSet ds, typename T> 242 static typename EnableIf< 243 HasDecorator<ds, MO_RELAXED>::value>::type 244 store_internal(void* addr, T value); 245 246 template <DecoratorSet ds, typename T> 247 static inline typename EnableIf< 248 HasDecorator<ds, MO_UNORDERED>::value>::type 249 store_internal(void* addr, T value) { 250 *reinterpret_cast<T*>(addr) = value; 251 } 252 253 template <DecoratorSet ds, typename T> 254 static typename EnableIf< 255 HasDecorator<ds, MO_SEQ_CST>::value, T>::type 256 atomic_cmpxchg_internal(void* addr, T compare_value, T new_value); 257 258 template <DecoratorSet ds, typename T> 259 static typename EnableIf< 260 HasDecorator<ds, MO_RELAXED>::value, T>::type 261 atomic_cmpxchg_internal(void* addr, T compare_value, T new_value); 262 263 template <DecoratorSet ds, typename T> 264 static typename EnableIf< 265 HasDecorator<ds, MO_SEQ_CST>::value, T>::type 266 atomic_xchg_internal(void* addr, T new_value); 267 268 public: 269 template <typename T> 270 static inline void store(void* addr, T value) { 271 store_internal<decorators>(addr, value); 272 } 273 274 template <typename T> 275 static inline T load(void* addr) { 276 return load_internal<decorators, T>(addr); 277 } 278 279 template <typename T> 280 static inline T atomic_cmpxchg(void* addr, T compare_value, T new_value) { 281 return atomic_cmpxchg_internal<decorators>(addr, compare_value, new_value); 282 } 283 284 template <typename T> 285 static inline T atomic_xchg(void* addr, T new_value) { 286 return atomic_xchg_internal<decorators>(addr, new_value); 287 } 288 289 template <typename T> 290 static bool arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 291 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 292 size_t length); 293 294 template <typename T> 295 static void oop_store(void* addr, T value); 296 template <typename T> 297 static void oop_store_at(oop base, ptrdiff_t offset, T value); 298 299 template <typename T> 300 static T oop_load(void* addr); 301 template <typename T> 302 static T oop_load_at(oop base, ptrdiff_t offset); 303 304 template <typename T> 305 static T oop_atomic_cmpxchg(void* addr, T compare_value, T new_value); 306 template <typename T> 307 static T oop_atomic_cmpxchg_at(oop base, ptrdiff_t offset, T compare_value, T new_value); 308 309 template <typename T> 310 static T oop_atomic_xchg(void* addr, T new_value); 311 template <typename T> 312 static T oop_atomic_xchg_at(oop base, ptrdiff_t offset, T new_value); 313 314 template <typename T> 315 static void store_at(oop base, ptrdiff_t offset, T value) { 316 store(field_addr(base, offset), value); 317 } 318 319 template <typename T> 320 static T load_at(oop base, ptrdiff_t offset) { 321 return load<T>(field_addr(base, offset)); 322 } 323 324 template <typename T> 325 static T atomic_cmpxchg_at(oop base, ptrdiff_t offset, T compare_value, T new_value) { 326 return atomic_cmpxchg(field_addr(base, offset), compare_value, new_value); 327 } 328 329 template <typename T> 330 static T atomic_xchg_at(oop base, ptrdiff_t offset, T new_value) { 331 return atomic_xchg(field_addr(base, offset), new_value); 332 } 333 334 template <typename T> 335 static bool oop_arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 336 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 337 size_t length); 338 339 static void clone(oop src, oop dst, size_t size); 340 }; 341 342 namespace AccessInternal { 343 DEBUG_ONLY(void check_access_thread_state()); 344 #define assert_access_thread_state() DEBUG_ONLY(check_access_thread_state()) 345 } 346 347 // Below is the implementation of the first 4 steps of the template pipeline: 348 // * Step 1: Set default decorators and decay types. This step gets rid of CV qualifiers 349 // and sets default decorators to sensible values. 350 // * Step 2: Reduce types. This step makes sure there is only a single T type and not 351 // multiple types. The P type of the address and T type of the value must 352 // match. 353 // * Step 3: Pre-runtime dispatch. This step checks whether a runtime call can be 354 // avoided, and in that case avoids it (calling raw accesses or 355 // primitive accesses in a build that does not require primitive GC barriers) 356 // * Step 4: Runtime-dispatch. This step performs a runtime dispatch to the corresponding 357 // BarrierSet::AccessBarrier accessor that attaches GC-required barriers 358 // to the access. 359 360 namespace AccessInternal { 361 template <typename T> 362 struct OopOrNarrowOopInternal: AllStatic { 363 typedef oop type; 364 }; 365 366 template <> 367 struct OopOrNarrowOopInternal<narrowOop>: AllStatic { 368 typedef narrowOop type; 369 }; 370 371 // This metafunction returns a canonicalized oop/narrowOop type for a passed 372 // in oop-like types passed in from oop_* overloads where the user has sworn 373 // that the passed in values should be oop-like (e.g. oop, oopDesc*, arrayOop, 374 // narrowOoop, instanceOopDesc*, and random other things). 375 // In the oop_* overloads, it must hold that if the passed in type T is not 376 // narrowOop, then it by contract has to be one of many oop-like types implicitly 377 // convertible to oop, and hence returns oop as the canonical oop type. 378 // If it turns out it was not, then the implicit conversion to oop will fail 379 // to compile, as desired. 380 template <typename T> 381 struct OopOrNarrowOop: AllStatic { 382 typedef typename OopOrNarrowOopInternal<std::decay_t<T>>::type type; 383 }; 384 385 inline void* field_addr(oop base, ptrdiff_t byte_offset) { 386 return reinterpret_cast<void*>(reinterpret_cast<intptr_t>((void*)base) + byte_offset); 387 } 388 // Step 4: Runtime dispatch 389 // The RuntimeDispatch class is responsible for performing a runtime dispatch of the 390 // accessor. This is required when the access either depends on whether compressed oops 391 // is being used, or it depends on which GC implementation was chosen (e.g. requires GC 392 // barriers). The way it works is that a function pointer initially pointing to an 393 // accessor resolution function gets called for each access. Upon first invocation, 394 // it resolves which accessor to be used in future invocations and patches the 395 // function pointer to this new accessor. 396 397 template <DecoratorSet decorators, typename T, BarrierType type> 398 struct RuntimeDispatch: AllStatic {}; 399 400 template <DecoratorSet decorators, typename T> 401 struct RuntimeDispatch<decorators, T, BARRIER_STORE>: AllStatic { 402 typedef typename AccessFunction<decorators, T, BARRIER_STORE>::type func_t; 403 static func_t _store_func; 404 405 static void store_init(void* addr, T value); 406 407 static inline void store(void* addr, T value) { 408 assert_access_thread_state(); 409 _store_func(addr, value); 410 } 411 }; 412 413 template <DecoratorSet decorators, typename T> 414 struct RuntimeDispatch<decorators, T, BARRIER_STORE_AT>: AllStatic { 415 typedef typename AccessFunction<decorators, T, BARRIER_STORE_AT>::type func_t; 416 static func_t _store_at_func; 417 418 static void store_at_init(oop base, ptrdiff_t offset, T value); 419 420 static inline void store_at(oop base, ptrdiff_t offset, T value) { 421 assert_access_thread_state(); 422 _store_at_func(base, offset, value); 423 } 424 }; 425 426 template <DecoratorSet decorators, typename T> 427 struct RuntimeDispatch<decorators, T, BARRIER_LOAD>: AllStatic { 428 typedef typename AccessFunction<decorators, T, BARRIER_LOAD>::type func_t; 429 static func_t _load_func; 430 431 static T load_init(void* addr); 432 433 static inline T load(void* addr) { 434 assert_access_thread_state(); 435 return _load_func(addr); 436 } 437 }; 438 439 template <DecoratorSet decorators, typename T> 440 struct RuntimeDispatch<decorators, T, BARRIER_LOAD_AT>: AllStatic { 441 typedef typename AccessFunction<decorators, T, BARRIER_LOAD_AT>::type func_t; 442 static func_t _load_at_func; 443 444 static T load_at_init(oop base, ptrdiff_t offset); 445 446 static inline T load_at(oop base, ptrdiff_t offset) { 447 assert_access_thread_state(); 448 return _load_at_func(base, offset); 449 } 450 }; 451 452 template <DecoratorSet decorators, typename T> 453 struct RuntimeDispatch<decorators, T, BARRIER_ATOMIC_CMPXCHG>: AllStatic { 454 typedef typename AccessFunction<decorators, T, BARRIER_ATOMIC_CMPXCHG>::type func_t; 455 static func_t _atomic_cmpxchg_func; 456 457 static T atomic_cmpxchg_init(void* addr, T compare_value, T new_value); 458 459 static inline T atomic_cmpxchg(void* addr, T compare_value, T new_value) { 460 assert_access_thread_state(); 461 return _atomic_cmpxchg_func(addr, compare_value, new_value); 462 } 463 }; 464 465 template <DecoratorSet decorators, typename T> 466 struct RuntimeDispatch<decorators, T, BARRIER_ATOMIC_CMPXCHG_AT>: AllStatic { 467 typedef typename AccessFunction<decorators, T, BARRIER_ATOMIC_CMPXCHG_AT>::type func_t; 468 static func_t _atomic_cmpxchg_at_func; 469 470 static T atomic_cmpxchg_at_init(oop base, ptrdiff_t offset, T compare_value, T new_value); 471 472 static inline T atomic_cmpxchg_at(oop base, ptrdiff_t offset, T compare_value, T new_value) { 473 assert_access_thread_state(); 474 return _atomic_cmpxchg_at_func(base, offset, compare_value, new_value); 475 } 476 }; 477 478 template <DecoratorSet decorators, typename T> 479 struct RuntimeDispatch<decorators, T, BARRIER_ATOMIC_XCHG>: AllStatic { 480 typedef typename AccessFunction<decorators, T, BARRIER_ATOMIC_XCHG>::type func_t; 481 static func_t _atomic_xchg_func; 482 483 static T atomic_xchg_init(void* addr, T new_value); 484 485 static inline T atomic_xchg(void* addr, T new_value) { 486 assert_access_thread_state(); 487 return _atomic_xchg_func(addr, new_value); 488 } 489 }; 490 491 template <DecoratorSet decorators, typename T> 492 struct RuntimeDispatch<decorators, T, BARRIER_ATOMIC_XCHG_AT>: AllStatic { 493 typedef typename AccessFunction<decorators, T, BARRIER_ATOMIC_XCHG_AT>::type func_t; 494 static func_t _atomic_xchg_at_func; 495 496 static T atomic_xchg_at_init(oop base, ptrdiff_t offset, T new_value); 497 498 static inline T atomic_xchg_at(oop base, ptrdiff_t offset, T new_value) { 499 assert_access_thread_state(); 500 return _atomic_xchg_at_func(base, offset, new_value); 501 } 502 }; 503 504 template <DecoratorSet decorators, typename T> 505 struct RuntimeDispatch<decorators, T, BARRIER_ARRAYCOPY>: AllStatic { 506 typedef typename AccessFunction<decorators, T, BARRIER_ARRAYCOPY>::type func_t; 507 static func_t _arraycopy_func; 508 509 static bool arraycopy_init(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 510 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 511 size_t length); 512 513 static inline bool arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 514 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 515 size_t length) { 516 assert_access_thread_state(); 517 return _arraycopy_func(src_obj, src_offset_in_bytes, src_raw, 518 dst_obj, dst_offset_in_bytes, dst_raw, 519 length); 520 } 521 }; 522 523 template <DecoratorSet decorators, typename T> 524 struct RuntimeDispatch<decorators, T, BARRIER_CLONE>: AllStatic { 525 typedef typename AccessFunction<decorators, T, BARRIER_CLONE>::type func_t; 526 static func_t _clone_func; 527 528 static void clone_init(oop src, oop dst, size_t size); 529 530 static inline void clone(oop src, oop dst, size_t size) { 531 assert_access_thread_state(); 532 _clone_func(src, dst, size); 533 } 534 }; 535 536 // Initialize the function pointers to point to the resolving function. 537 template <DecoratorSet decorators, typename T> 538 typename AccessFunction<decorators, T, BARRIER_STORE>::type 539 RuntimeDispatch<decorators, T, BARRIER_STORE>::_store_func = &store_init; 540 541 template <DecoratorSet decorators, typename T> 542 typename AccessFunction<decorators, T, BARRIER_STORE_AT>::type 543 RuntimeDispatch<decorators, T, BARRIER_STORE_AT>::_store_at_func = &store_at_init; 544 545 template <DecoratorSet decorators, typename T> 546 typename AccessFunction<decorators, T, BARRIER_LOAD>::type 547 RuntimeDispatch<decorators, T, BARRIER_LOAD>::_load_func = &load_init; 548 549 template <DecoratorSet decorators, typename T> 550 typename AccessFunction<decorators, T, BARRIER_LOAD_AT>::type 551 RuntimeDispatch<decorators, T, BARRIER_LOAD_AT>::_load_at_func = &load_at_init; 552 553 template <DecoratorSet decorators, typename T> 554 typename AccessFunction<decorators, T, BARRIER_ATOMIC_CMPXCHG>::type 555 RuntimeDispatch<decorators, T, BARRIER_ATOMIC_CMPXCHG>::_atomic_cmpxchg_func = &atomic_cmpxchg_init; 556 557 template <DecoratorSet decorators, typename T> 558 typename AccessFunction<decorators, T, BARRIER_ATOMIC_CMPXCHG_AT>::type 559 RuntimeDispatch<decorators, T, BARRIER_ATOMIC_CMPXCHG_AT>::_atomic_cmpxchg_at_func = &atomic_cmpxchg_at_init; 560 561 template <DecoratorSet decorators, typename T> 562 typename AccessFunction<decorators, T, BARRIER_ATOMIC_XCHG>::type 563 RuntimeDispatch<decorators, T, BARRIER_ATOMIC_XCHG>::_atomic_xchg_func = &atomic_xchg_init; 564 565 template <DecoratorSet decorators, typename T> 566 typename AccessFunction<decorators, T, BARRIER_ATOMIC_XCHG_AT>::type 567 RuntimeDispatch<decorators, T, BARRIER_ATOMIC_XCHG_AT>::_atomic_xchg_at_func = &atomic_xchg_at_init; 568 569 template <DecoratorSet decorators, typename T> 570 typename AccessFunction<decorators, T, BARRIER_ARRAYCOPY>::type 571 RuntimeDispatch<decorators, T, BARRIER_ARRAYCOPY>::_arraycopy_func = &arraycopy_init; 572 573 template <DecoratorSet decorators, typename T> 574 typename AccessFunction<decorators, T, BARRIER_CLONE>::type 575 RuntimeDispatch<decorators, T, BARRIER_CLONE>::_clone_func = &clone_init; 576 577 // Step 3: Pre-runtime dispatching. 578 // The PreRuntimeDispatch class is responsible for filtering the barrier strength 579 // decorators. That is, for AS_RAW, it hardwires the accesses without a runtime 580 // dispatch point. Otherwise it goes through a runtime check if hardwiring was 581 // not possible. 582 struct PreRuntimeDispatch: AllStatic { 583 template<DecoratorSet decorators> 584 struct CanHardwireRaw: public std::integral_constant< 585 bool, 586 !HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value || // primitive access 587 !HasDecorator<decorators, INTERNAL_CONVERT_COMPRESSED_OOP>::value || // don't care about compressed oops (oop* address) 588 HasDecorator<decorators, INTERNAL_RT_USE_COMPRESSED_OOPS>::value> // we can infer we use compressed oops (narrowOop* address) 589 {}; 590 591 static const DecoratorSet convert_compressed_oops = INTERNAL_RT_USE_COMPRESSED_OOPS | INTERNAL_CONVERT_COMPRESSED_OOP; 592 593 template<DecoratorSet decorators> 594 static bool is_hardwired_primitive() { 595 return !HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value; 596 } 597 598 template <DecoratorSet decorators, typename T> 599 inline static typename EnableIf< 600 HasDecorator<decorators, AS_RAW>::value && CanHardwireRaw<decorators>::value>::type 601 store(void* addr, T value) { 602 typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw; 603 if (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value) { 604 Raw::oop_store(addr, value); 605 } else { 606 Raw::store(addr, value); 607 } 608 } 609 610 template <DecoratorSet decorators, typename T> 611 inline static typename EnableIf< 612 HasDecorator<decorators, AS_RAW>::value && !CanHardwireRaw<decorators>::value>::type 613 store(void* addr, T value) { 614 if (UseCompressedOops) { 615 const DecoratorSet expanded_decorators = decorators | convert_compressed_oops; 616 PreRuntimeDispatch::store<expanded_decorators>(addr, value); 617 } else { 618 const DecoratorSet expanded_decorators = decorators & ~convert_compressed_oops; 619 PreRuntimeDispatch::store<expanded_decorators>(addr, value); 620 } 621 } 622 623 template <DecoratorSet decorators, typename T> 624 inline static typename EnableIf< 625 !HasDecorator<decorators, AS_RAW>::value>::type 626 store(void* addr, T value) { 627 if (is_hardwired_primitive<decorators>()) { 628 const DecoratorSet expanded_decorators = decorators | AS_RAW; 629 PreRuntimeDispatch::store<expanded_decorators>(addr, value); 630 } else { 631 RuntimeDispatch<decorators, T, BARRIER_STORE>::store(addr, value); 632 } 633 } 634 635 template <DecoratorSet decorators, typename T> 636 inline static typename EnableIf< 637 HasDecorator<decorators, AS_RAW>::value>::type 638 store_at(oop base, ptrdiff_t offset, T value) { 639 store<decorators>(field_addr(base, offset), value); 640 } 641 642 template <DecoratorSet decorators, typename T> 643 inline static typename EnableIf< 644 !HasDecorator<decorators, AS_RAW>::value>::type 645 store_at(oop base, ptrdiff_t offset, T value) { 646 if (is_hardwired_primitive<decorators>()) { 647 const DecoratorSet expanded_decorators = decorators | AS_RAW; 648 PreRuntimeDispatch::store_at<expanded_decorators>(base, offset, value); 649 } else { 650 RuntimeDispatch<decorators, T, BARRIER_STORE_AT>::store_at(base, offset, value); 651 } 652 } 653 654 template <DecoratorSet decorators, typename T> 655 inline static typename EnableIf< 656 HasDecorator<decorators, AS_RAW>::value && CanHardwireRaw<decorators>::value, T>::type 657 load(void* addr) { 658 typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw; 659 if (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value) { 660 return Raw::template oop_load<T>(addr); 661 } else { 662 return Raw::template load<T>(addr); 663 } 664 } 665 666 template <DecoratorSet decorators, typename T> 667 inline static typename EnableIf< 668 HasDecorator<decorators, AS_RAW>::value && !CanHardwireRaw<decorators>::value, T>::type 669 load(void* addr) { 670 if (UseCompressedOops) { 671 const DecoratorSet expanded_decorators = decorators | convert_compressed_oops; 672 return PreRuntimeDispatch::load<expanded_decorators, T>(addr); 673 } else { 674 const DecoratorSet expanded_decorators = decorators & ~convert_compressed_oops; 675 return PreRuntimeDispatch::load<expanded_decorators, T>(addr); 676 } 677 } 678 679 template <DecoratorSet decorators, typename T> 680 inline static typename EnableIf< 681 !HasDecorator<decorators, AS_RAW>::value, T>::type 682 load(void* addr) { 683 if (is_hardwired_primitive<decorators>()) { 684 const DecoratorSet expanded_decorators = decorators | AS_RAW; 685 return PreRuntimeDispatch::load<expanded_decorators, T>(addr); 686 } else { 687 return RuntimeDispatch<decorators, T, BARRIER_LOAD>::load(addr); 688 } 689 } 690 691 template <DecoratorSet decorators, typename T> 692 inline static typename EnableIf< 693 HasDecorator<decorators, AS_RAW>::value, T>::type 694 load_at(oop base, ptrdiff_t offset) { 695 return load<decorators, T>(field_addr(base, offset)); 696 } 697 698 template <DecoratorSet decorators, typename T> 699 inline static typename EnableIf< 700 !HasDecorator<decorators, AS_RAW>::value, T>::type 701 load_at(oop base, ptrdiff_t offset) { 702 if (is_hardwired_primitive<decorators>()) { 703 const DecoratorSet expanded_decorators = decorators | AS_RAW; 704 return PreRuntimeDispatch::load_at<expanded_decorators, T>(base, offset); 705 } else { 706 return RuntimeDispatch<decorators, T, BARRIER_LOAD_AT>::load_at(base, offset); 707 } 708 } 709 710 template <DecoratorSet decorators, typename T> 711 inline static typename EnableIf< 712 HasDecorator<decorators, AS_RAW>::value && CanHardwireRaw<decorators>::value, T>::type 713 atomic_cmpxchg(void* addr, T compare_value, T new_value) { 714 typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw; 715 if (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value) { 716 return Raw::oop_atomic_cmpxchg(addr, compare_value, new_value); 717 } else { 718 return Raw::atomic_cmpxchg(addr, compare_value, new_value); 719 } 720 } 721 722 template <DecoratorSet decorators, typename T> 723 inline static typename EnableIf< 724 HasDecorator<decorators, AS_RAW>::value && !CanHardwireRaw<decorators>::value, T>::type 725 atomic_cmpxchg(void* addr, T compare_value, T new_value) { 726 if (UseCompressedOops) { 727 const DecoratorSet expanded_decorators = decorators | convert_compressed_oops; 728 return PreRuntimeDispatch::atomic_cmpxchg<expanded_decorators>(addr, compare_value, new_value); 729 } else { 730 const DecoratorSet expanded_decorators = decorators & ~convert_compressed_oops; 731 return PreRuntimeDispatch::atomic_cmpxchg<expanded_decorators>(addr, compare_value, new_value); 732 } 733 } 734 735 template <DecoratorSet decorators, typename T> 736 inline static typename EnableIf< 737 !HasDecorator<decorators, AS_RAW>::value, T>::type 738 atomic_cmpxchg(void* addr, T compare_value, T new_value) { 739 if (is_hardwired_primitive<decorators>()) { 740 const DecoratorSet expanded_decorators = decorators | AS_RAW; 741 return PreRuntimeDispatch::atomic_cmpxchg<expanded_decorators>(addr, compare_value, new_value); 742 } else { 743 return RuntimeDispatch<decorators, T, BARRIER_ATOMIC_CMPXCHG>::atomic_cmpxchg(addr, compare_value, new_value); 744 } 745 } 746 747 template <DecoratorSet decorators, typename T> 748 inline static typename EnableIf< 749 HasDecorator<decorators, AS_RAW>::value, T>::type 750 atomic_cmpxchg_at(oop base, ptrdiff_t offset, T compare_value, T new_value) { 751 return atomic_cmpxchg<decorators>(field_addr(base, offset), compare_value, new_value); 752 } 753 754 template <DecoratorSet decorators, typename T> 755 inline static typename EnableIf< 756 !HasDecorator<decorators, AS_RAW>::value, T>::type 757 atomic_cmpxchg_at(oop base, ptrdiff_t offset, T compare_value, T new_value) { 758 if (is_hardwired_primitive<decorators>()) { 759 const DecoratorSet expanded_decorators = decorators | AS_RAW; 760 return PreRuntimeDispatch::atomic_cmpxchg_at<expanded_decorators>(base, offset, compare_value, new_value); 761 } else { 762 return RuntimeDispatch<decorators, T, BARRIER_ATOMIC_CMPXCHG_AT>::atomic_cmpxchg_at(base, offset, compare_value, new_value); 763 } 764 } 765 766 template <DecoratorSet decorators, typename T> 767 inline static typename EnableIf< 768 HasDecorator<decorators, AS_RAW>::value && CanHardwireRaw<decorators>::value, T>::type 769 atomic_xchg(void* addr, T new_value) { 770 typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw; 771 if (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value) { 772 return Raw::oop_atomic_xchg(addr, new_value); 773 } else { 774 return Raw::atomic_xchg(addr, new_value); 775 } 776 } 777 778 template <DecoratorSet decorators, typename T> 779 inline static typename EnableIf< 780 HasDecorator<decorators, AS_RAW>::value && !CanHardwireRaw<decorators>::value, T>::type 781 atomic_xchg(void* addr, T new_value) { 782 if (UseCompressedOops) { 783 const DecoratorSet expanded_decorators = decorators | convert_compressed_oops; 784 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 785 } else { 786 const DecoratorSet expanded_decorators = decorators & ~convert_compressed_oops; 787 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 788 } 789 } 790 791 template <DecoratorSet decorators, typename T> 792 inline static typename EnableIf< 793 !HasDecorator<decorators, AS_RAW>::value, T>::type 794 atomic_xchg(void* addr, T new_value) { 795 if (is_hardwired_primitive<decorators>()) { 796 const DecoratorSet expanded_decorators = decorators | AS_RAW; 797 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 798 } else { 799 return RuntimeDispatch<decorators, T, BARRIER_ATOMIC_XCHG>::atomic_xchg(addr, new_value); 800 } 801 } 802 803 template <DecoratorSet decorators, typename T> 804 inline static typename EnableIf< 805 HasDecorator<decorators, AS_RAW>::value, T>::type 806 atomic_xchg_at(oop base, ptrdiff_t offset, T new_value) { 807 return atomic_xchg<decorators>(field_addr(base, offset), new_value); 808 } 809 810 template <DecoratorSet decorators, typename T> 811 inline static typename EnableIf< 812 !HasDecorator<decorators, AS_RAW>::value, T>::type 813 atomic_xchg_at(oop base, ptrdiff_t offset, T new_value) { 814 if (is_hardwired_primitive<decorators>()) { 815 const DecoratorSet expanded_decorators = decorators | AS_RAW; 816 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(base, offset, new_value); 817 } else { 818 return RuntimeDispatch<decorators, T, BARRIER_ATOMIC_XCHG_AT>::atomic_xchg_at(base, offset, new_value); 819 } 820 } 821 822 template <DecoratorSet decorators, typename T> 823 inline static typename EnableIf< 824 HasDecorator<decorators, AS_RAW>::value && CanHardwireRaw<decorators>::value, bool>::type 825 arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 826 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 827 size_t length) { 828 typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw; 829 if (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value) { 830 return Raw::oop_arraycopy(src_obj, src_offset_in_bytes, src_raw, 831 dst_obj, dst_offset_in_bytes, dst_raw, 832 length); 833 } else { 834 return Raw::arraycopy(src_obj, src_offset_in_bytes, src_raw, 835 dst_obj, dst_offset_in_bytes, dst_raw, 836 length); 837 } 838 } 839 840 template <DecoratorSet decorators, typename T> 841 inline static typename EnableIf< 842 HasDecorator<decorators, AS_RAW>::value && !CanHardwireRaw<decorators>::value, bool>::type 843 arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 844 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 845 size_t length) { 846 if (UseCompressedOops) { 847 const DecoratorSet expanded_decorators = decorators | convert_compressed_oops; 848 return PreRuntimeDispatch::arraycopy<expanded_decorators>(src_obj, src_offset_in_bytes, src_raw, 849 dst_obj, dst_offset_in_bytes, dst_raw, 850 length); 851 } else { 852 const DecoratorSet expanded_decorators = decorators & ~convert_compressed_oops; 853 return PreRuntimeDispatch::arraycopy<expanded_decorators>(src_obj, src_offset_in_bytes, src_raw, 854 dst_obj, dst_offset_in_bytes, dst_raw, 855 length); 856 } 857 } 858 859 template <DecoratorSet decorators, typename T> 860 inline static typename EnableIf< 861 !HasDecorator<decorators, AS_RAW>::value, bool>::type 862 arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 863 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 864 size_t length) { 865 if (is_hardwired_primitive<decorators>()) { 866 const DecoratorSet expanded_decorators = decorators | AS_RAW; 867 return PreRuntimeDispatch::arraycopy<expanded_decorators>(src_obj, src_offset_in_bytes, src_raw, 868 dst_obj, dst_offset_in_bytes, dst_raw, 869 length); 870 } else { 871 return RuntimeDispatch<decorators, T, BARRIER_ARRAYCOPY>::arraycopy(src_obj, src_offset_in_bytes, src_raw, 872 dst_obj, dst_offset_in_bytes, dst_raw, 873 length); 874 } 875 } 876 877 template <DecoratorSet decorators> 878 inline static typename EnableIf< 879 HasDecorator<decorators, AS_RAW>::value>::type 880 clone(oop src, oop dst, size_t size) { 881 typedef RawAccessBarrier<decorators & RAW_DECORATOR_MASK> Raw; 882 Raw::clone(src, dst, size); 883 } 884 885 template <DecoratorSet decorators> 886 inline static typename EnableIf< 887 !HasDecorator<decorators, AS_RAW>::value>::type 888 clone(oop src, oop dst, size_t size) { 889 RuntimeDispatch<decorators, oop, BARRIER_CLONE>::clone(src, dst, size); 890 } 891 }; 892 893 // Step 2: Reduce types. 894 // Enforce that for non-oop types, T and P have to be strictly the same. 895 // P is the type of the address and T is the type of the values. 896 // As for oop types, it is allow to send T in {narrowOop, oop} and 897 // P in {narrowOop, oop, HeapWord*}. The following rules apply according to 898 // the subsequent table. (columns are P, rows are T) 899 // | | HeapWord | oop | narrowOop | 900 // | oop | rt-comp | hw-none | hw-comp | 901 // | narrowOop | x | x | hw-none | 902 // 903 // x means not allowed 904 // rt-comp means it must be checked at runtime whether the oop is compressed. 905 // hw-none means it is statically known the oop will not be compressed. 906 // hw-comp means it is statically known the oop will be compressed. 907 908 template <DecoratorSet decorators, typename T> 909 inline void store_reduce_types(T* addr, T value) { 910 PreRuntimeDispatch::store<decorators>(addr, value); 911 } 912 913 template <DecoratorSet decorators> 914 inline void store_reduce_types(narrowOop* addr, oop value) { 915 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 916 INTERNAL_RT_USE_COMPRESSED_OOPS; 917 PreRuntimeDispatch::store<expanded_decorators>(addr, value); 918 } 919 920 template <DecoratorSet decorators> 921 inline void store_reduce_types(narrowOop* addr, narrowOop value) { 922 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 923 INTERNAL_RT_USE_COMPRESSED_OOPS; 924 PreRuntimeDispatch::store<expanded_decorators>(addr, value); 925 } 926 927 template <DecoratorSet decorators> 928 inline void store_reduce_types(HeapWord* addr, oop value) { 929 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP; 930 PreRuntimeDispatch::store<expanded_decorators>(addr, value); 931 } 932 933 template <DecoratorSet decorators, typename T> 934 inline T atomic_cmpxchg_reduce_types(T* addr, T compare_value, T new_value) { 935 return PreRuntimeDispatch::atomic_cmpxchg<decorators>(addr, compare_value, new_value); 936 } 937 938 template <DecoratorSet decorators> 939 inline oop atomic_cmpxchg_reduce_types(narrowOop* addr, oop compare_value, oop new_value) { 940 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 941 INTERNAL_RT_USE_COMPRESSED_OOPS; 942 return PreRuntimeDispatch::atomic_cmpxchg<expanded_decorators>(addr, compare_value, new_value); 943 } 944 945 template <DecoratorSet decorators> 946 inline narrowOop atomic_cmpxchg_reduce_types(narrowOop* addr, narrowOop compare_value, narrowOop new_value) { 947 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 948 INTERNAL_RT_USE_COMPRESSED_OOPS; 949 return PreRuntimeDispatch::atomic_cmpxchg<expanded_decorators>(addr, compare_value, new_value); 950 } 951 952 template <DecoratorSet decorators> 953 inline oop atomic_cmpxchg_reduce_types(HeapWord* addr, 954 oop compare_value, 955 oop new_value) { 956 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP; 957 return PreRuntimeDispatch::atomic_cmpxchg<expanded_decorators>(addr, compare_value, new_value); 958 } 959 960 template <DecoratorSet decorators, typename T> 961 inline T atomic_xchg_reduce_types(T* addr, T new_value) { 962 const DecoratorSet expanded_decorators = decorators; 963 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 964 } 965 966 template <DecoratorSet decorators> 967 inline oop atomic_xchg_reduce_types(narrowOop* addr, oop new_value) { 968 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 969 INTERNAL_RT_USE_COMPRESSED_OOPS; 970 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 971 } 972 973 template <DecoratorSet decorators> 974 inline narrowOop atomic_xchg_reduce_types(narrowOop* addr, narrowOop new_value) { 975 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 976 INTERNAL_RT_USE_COMPRESSED_OOPS; 977 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 978 } 979 980 template <DecoratorSet decorators> 981 inline oop atomic_xchg_reduce_types(HeapWord* addr, oop new_value) { 982 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP; 983 return PreRuntimeDispatch::atomic_xchg<expanded_decorators>(addr, new_value); 984 } 985 986 template <DecoratorSet decorators, typename T> 987 inline T load_reduce_types(T* addr) { 988 return PreRuntimeDispatch::load<decorators, T>(addr); 989 } 990 991 template <DecoratorSet decorators, typename T> 992 inline typename OopOrNarrowOop<T>::type load_reduce_types(narrowOop* addr) { 993 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 994 INTERNAL_RT_USE_COMPRESSED_OOPS; 995 return PreRuntimeDispatch::load<expanded_decorators, typename OopOrNarrowOop<T>::type>(addr); 996 } 997 998 template <DecoratorSet decorators, typename T> 999 inline oop load_reduce_types(HeapWord* addr) { 1000 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP; 1001 return PreRuntimeDispatch::load<expanded_decorators, oop>(addr); 1002 } 1003 1004 template <DecoratorSet decorators, typename T> 1005 inline bool arraycopy_reduce_types(arrayOop src_obj, size_t src_offset_in_bytes, T* src_raw, 1006 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 1007 size_t length) { 1008 return PreRuntimeDispatch::arraycopy<decorators>(src_obj, src_offset_in_bytes, src_raw, 1009 dst_obj, dst_offset_in_bytes, dst_raw, 1010 length); 1011 } 1012 1013 template <DecoratorSet decorators> 1014 inline bool arraycopy_reduce_types(arrayOop src_obj, size_t src_offset_in_bytes, HeapWord* src_raw, 1015 arrayOop dst_obj, size_t dst_offset_in_bytes, HeapWord* dst_raw, 1016 size_t length) { 1017 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP; 1018 return PreRuntimeDispatch::arraycopy<expanded_decorators>(src_obj, src_offset_in_bytes, src_raw, 1019 dst_obj, dst_offset_in_bytes, dst_raw, 1020 length); 1021 } 1022 1023 template <DecoratorSet decorators> 1024 inline bool arraycopy_reduce_types(arrayOop src_obj, size_t src_offset_in_bytes, narrowOop* src_raw, 1025 arrayOop dst_obj, size_t dst_offset_in_bytes, narrowOop* dst_raw, 1026 size_t length) { 1027 const DecoratorSet expanded_decorators = decorators | INTERNAL_CONVERT_COMPRESSED_OOP | 1028 INTERNAL_RT_USE_COMPRESSED_OOPS; 1029 return PreRuntimeDispatch::arraycopy<expanded_decorators>(src_obj, src_offset_in_bytes, src_raw, 1030 dst_obj, dst_offset_in_bytes, dst_raw, 1031 length); 1032 } 1033 1034 // Step 1: Set default decorators. This step remembers if a type was volatile 1035 // and then sets the MO_RELAXED decorator by default. Otherwise, a default 1036 // memory ordering is set for the access, and the implied decorator rules 1037 // are applied to select sensible defaults for decorators that have not been 1038 // explicitly set. For example, default object referent strength is set to strong. 1039 // This step also decays the types passed in (e.g. getting rid of CV qualifiers 1040 // and references from the types). This step also perform some type verification 1041 // that the passed in types make sense. 1042 1043 template <DecoratorSet decorators, typename T> 1044 static void verify_types(){ 1045 // If this fails to compile, then you have sent in something that is 1046 // not recognized as a valid primitive type to a primitive Access function. 1047 STATIC_ASSERT((HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value || // oops have already been validated 1048 (std::is_pointer<T>::value || std::is_integral<T>::value) || 1049 std::is_floating_point<T>::value)); // not allowed primitive type 1050 } 1051 1052 template <DecoratorSet decorators, typename P, typename T> 1053 inline void store(P* addr, T value) { 1054 verify_types<decorators, T>(); 1055 using DecayedP = std::decay_t<P>; 1056 using DecayedT = std::decay_t<T>; 1057 DecayedT decayed_value = value; 1058 // If a volatile address is passed in but no memory ordering decorator, 1059 // set the memory ordering to MO_RELAXED by default. 1060 const DecoratorSet expanded_decorators = DecoratorFixup< 1061 (std::is_volatile<P>::value && !HasDecorator<decorators, MO_DECORATOR_MASK>::value) ? 1062 (MO_RELAXED | decorators) : decorators>::value; 1063 store_reduce_types<expanded_decorators>(const_cast<DecayedP*>(addr), decayed_value); 1064 } 1065 1066 template <DecoratorSet decorators, typename T> 1067 inline void store_at(oop base, ptrdiff_t offset, T value) { 1068 verify_types<decorators, T>(); 1069 using DecayedT = std::decay_t<T>; 1070 DecayedT decayed_value = value; 1071 const DecoratorSet expanded_decorators = DecoratorFixup<decorators | 1072 (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value ? 1073 INTERNAL_CONVERT_COMPRESSED_OOP : DECORATORS_NONE)>::value; 1074 PreRuntimeDispatch::store_at<expanded_decorators>(base, offset, decayed_value); 1075 } 1076 1077 template <DecoratorSet decorators, typename P, typename T> 1078 inline T load(P* addr) { 1079 verify_types<decorators, T>(); 1080 using DecayedP = std::decay_t<P>; 1081 using DecayedT = std::conditional_t<HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value, 1082 typename OopOrNarrowOop<T>::type, 1083 std::decay_t<T>>; 1084 // If a volatile address is passed in but no memory ordering decorator, 1085 // set the memory ordering to MO_RELAXED by default. 1086 const DecoratorSet expanded_decorators = DecoratorFixup< 1087 (std::is_volatile<P>::value && !HasDecorator<decorators, MO_DECORATOR_MASK>::value) ? 1088 (MO_RELAXED | decorators) : decorators>::value; 1089 return load_reduce_types<expanded_decorators, DecayedT>(const_cast<DecayedP*>(addr)); 1090 } 1091 1092 template <DecoratorSet decorators, typename T> 1093 inline T load_at(oop base, ptrdiff_t offset) { 1094 verify_types<decorators, T>(); 1095 using DecayedT = std::conditional_t<HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value, 1096 typename OopOrNarrowOop<T>::type, 1097 std::decay_t<T>>; 1098 // Expand the decorators (figure out sensible defaults) 1099 // Potentially remember if we need compressed oop awareness 1100 const DecoratorSet expanded_decorators = DecoratorFixup<decorators | 1101 (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value ? 1102 INTERNAL_CONVERT_COMPRESSED_OOP : DECORATORS_NONE)>::value; 1103 return PreRuntimeDispatch::load_at<expanded_decorators, DecayedT>(base, offset); 1104 } 1105 1106 template <DecoratorSet decorators, typename P, typename T> 1107 inline T atomic_cmpxchg(P* addr, T compare_value, T new_value) { 1108 verify_types<decorators, T>(); 1109 using DecayedP = std::decay_t<P>; 1110 using DecayedT = std::decay_t<T>; 1111 DecayedT new_decayed_value = new_value; 1112 DecayedT compare_decayed_value = compare_value; 1113 const DecoratorSet expanded_decorators = DecoratorFixup< 1114 (!HasDecorator<decorators, MO_DECORATOR_MASK>::value) ? 1115 (MO_SEQ_CST | decorators) : decorators>::value; 1116 return atomic_cmpxchg_reduce_types<expanded_decorators>(const_cast<DecayedP*>(addr), 1117 compare_decayed_value, 1118 new_decayed_value); 1119 } 1120 1121 template <DecoratorSet decorators, typename T> 1122 inline T atomic_cmpxchg_at(oop base, ptrdiff_t offset, T compare_value, T new_value) { 1123 verify_types<decorators, T>(); 1124 using DecayedT = std::decay_t<T>; 1125 DecayedT new_decayed_value = new_value; 1126 DecayedT compare_decayed_value = compare_value; 1127 // Determine default memory ordering 1128 const DecoratorSet expanded_decorators = DecoratorFixup< 1129 (!HasDecorator<decorators, MO_DECORATOR_MASK>::value) ? 1130 (MO_SEQ_CST | decorators) : decorators>::value; 1131 // Potentially remember that we need compressed oop awareness 1132 const DecoratorSet final_decorators = expanded_decorators | 1133 (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value ? 1134 INTERNAL_CONVERT_COMPRESSED_OOP : DECORATORS_NONE); 1135 return PreRuntimeDispatch::atomic_cmpxchg_at<final_decorators>(base, offset, compare_decayed_value, 1136 new_decayed_value); 1137 } 1138 1139 template <DecoratorSet decorators, typename P, typename T> 1140 inline T atomic_xchg(P* addr, T new_value) { 1141 verify_types<decorators, T>(); 1142 using DecayedP = std::decay_t<P>; 1143 using DecayedT = std::decay_t<T>; 1144 DecayedT new_decayed_value = new_value; 1145 // atomic_xchg is only available in SEQ_CST flavour. 1146 const DecoratorSet expanded_decorators = DecoratorFixup<decorators | MO_SEQ_CST>::value; 1147 return atomic_xchg_reduce_types<expanded_decorators>(const_cast<DecayedP*>(addr), 1148 new_decayed_value); 1149 } 1150 1151 template <DecoratorSet decorators, typename T> 1152 inline T atomic_xchg_at(oop base, ptrdiff_t offset, T new_value) { 1153 verify_types<decorators, T>(); 1154 using DecayedT = std::decay_t<T>; 1155 DecayedT new_decayed_value = new_value; 1156 // atomic_xchg is only available in SEQ_CST flavour. 1157 const DecoratorSet expanded_decorators = DecoratorFixup<decorators | MO_SEQ_CST | 1158 (HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value ? 1159 INTERNAL_CONVERT_COMPRESSED_OOP : DECORATORS_NONE)>::value; 1160 return PreRuntimeDispatch::atomic_xchg_at<expanded_decorators>(base, offset, new_decayed_value); 1161 } 1162 1163 template <DecoratorSet decorators, typename T> 1164 inline bool arraycopy(arrayOop src_obj, size_t src_offset_in_bytes, const T* src_raw, 1165 arrayOop dst_obj, size_t dst_offset_in_bytes, T* dst_raw, 1166 size_t length) { 1167 STATIC_ASSERT((HasDecorator<decorators, INTERNAL_VALUE_IS_OOP>::value || 1168 (std::is_same<T, void>::value || std::is_integral<T>::value) || 1169 std::is_floating_point<T>::value)); // arraycopy allows type erased void elements 1170 using DecayedT = std::decay_t<T>; 1171 const DecoratorSet expanded_decorators = DecoratorFixup<decorators | IS_ARRAY | IN_HEAP>::value; 1172 return arraycopy_reduce_types<expanded_decorators>(src_obj, src_offset_in_bytes, const_cast<DecayedT*>(src_raw), 1173 dst_obj, dst_offset_in_bytes, const_cast<DecayedT*>(dst_raw), 1174 length); 1175 } 1176 1177 template <DecoratorSet decorators> 1178 inline void clone(oop src, oop dst, size_t size) { 1179 const DecoratorSet expanded_decorators = DecoratorFixup<decorators>::value; 1180 PreRuntimeDispatch::clone<expanded_decorators>(src, dst, size); 1181 } 1182 1183 // Infer the type that should be returned from an Access::oop_load. 1184 template <typename P, DecoratorSet decorators> 1185 class OopLoadProxy: public StackObj { 1186 private: 1187 P *const _addr; 1188 public: 1189 explicit OopLoadProxy(P* addr) : _addr(addr) {} 1190 1191 inline operator oop() { 1192 return load<decorators | INTERNAL_VALUE_IS_OOP, P, oop>(_addr); 1193 } 1194 1195 inline operator narrowOop() { 1196 return load<decorators | INTERNAL_VALUE_IS_OOP, P, narrowOop>(_addr); 1197 } 1198 1199 template <typename T> 1200 inline bool operator ==(const T& other) const { 1201 return load<decorators | INTERNAL_VALUE_IS_OOP, P, T>(_addr) == other; 1202 } 1203 1204 template <typename T> 1205 inline bool operator !=(const T& other) const { 1206 return load<decorators | INTERNAL_VALUE_IS_OOP, P, T>(_addr) != other; 1207 } 1208 1209 inline bool operator ==(std::nullptr_t) const { 1210 return load<decorators | INTERNAL_VALUE_IS_OOP, P, oop>(_addr) == nullptr; 1211 } 1212 1213 inline bool operator !=(std::nullptr_t) const { 1214 return load<decorators | INTERNAL_VALUE_IS_OOP, P, oop>(_addr) != nullptr; 1215 } 1216 }; 1217 1218 // Infer the type that should be returned from an Access::load_at. 1219 template <DecoratorSet decorators> 1220 class LoadAtProxy: public StackObj { 1221 private: 1222 const oop _base; 1223 const ptrdiff_t _offset; 1224 public: 1225 LoadAtProxy(oop base, ptrdiff_t offset) : _base(base), _offset(offset) {} 1226 1227 template <typename T> 1228 inline operator T() const { 1229 return load_at<decorators, T>(_base, _offset); 1230 } 1231 1232 template <typename T> 1233 inline bool operator ==(const T& other) const { return load_at<decorators, T>(_base, _offset) == other; } 1234 1235 template <typename T> 1236 inline bool operator !=(const T& other) const { return load_at<decorators, T>(_base, _offset) != other; } 1237 }; 1238 1239 // Infer the type that should be returned from an Access::oop_load_at. 1240 template <DecoratorSet decorators> 1241 class OopLoadAtProxy: public StackObj { 1242 private: 1243 const oop _base; 1244 const ptrdiff_t _offset; 1245 public: 1246 OopLoadAtProxy(oop base, ptrdiff_t offset) : _base(base), _offset(offset) {} 1247 1248 inline operator oop() const { 1249 return load_at<decorators | INTERNAL_VALUE_IS_OOP, oop>(_base, _offset); 1250 } 1251 1252 inline operator narrowOop() const { 1253 return load_at<decorators | INTERNAL_VALUE_IS_OOP, narrowOop>(_base, _offset); 1254 } 1255 1256 template <typename T> 1257 inline bool operator ==(const T& other) const { 1258 return load_at<decorators | INTERNAL_VALUE_IS_OOP, T>(_base, _offset) == other; 1259 } 1260 1261 template <typename T> 1262 inline bool operator !=(const T& other) const { 1263 return load_at<decorators | INTERNAL_VALUE_IS_OOP, T>(_base, _offset) != other; 1264 } 1265 }; 1266 } 1267 1268 #endif // SHARE_OOPS_ACCESSBACKEND_HPP --- EOF ---