1 /*
  2  * Copyright (c) 2017, 2025, 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 "accessBackend.inline.hpp"
 26 #include "gc/shared/collectedHeap.hpp"
 27 #include "oops/oop.inline.hpp"
 28 #include "runtime/javaThread.inline.hpp"
 29 #include "runtime/mutexLocker.hpp"
 30 #include "utilities/copy.hpp"
 31 #include "utilities/debug.hpp"
 32 #include "utilities/vmError.hpp"
 33 
 34 #if defined(TARGET_COMPILER_gcc)
 35 #define HIDDEN __attribute__ ((visibility ("hidden")))
 36 #else
 37 #define HIDDEN
 38 #endif
 39 
 40 namespace AccessInternal {
 41 // These forward copying calls to Copy without exposing the Copy type in headers unnecessarily
 42 
 43   void arraycopy_arrayof_conjoint_oops(void* src, void* dst, size_t length) {
 44     Copy::arrayof_conjoint_oops(reinterpret_cast<HeapWord*>(src),
 45                                 reinterpret_cast<HeapWord*>(dst), length);
 46   }
 47 
 48   void arraycopy_conjoint_oops(oop* src, oop* dst, size_t length) {
 49     Copy::conjoint_oops_atomic(src, dst, length);
 50   }
 51 
 52   void arraycopy_conjoint_oops(narrowOop* src, narrowOop* dst, size_t length) {
 53     Copy::conjoint_oops_atomic(src, dst, length);
 54   }
 55 
 56   void arraycopy_disjoint_words(void* src, void* dst, size_t length) {
 57     Copy::disjoint_words(reinterpret_cast<HeapWord*>(src),
 58                          reinterpret_cast<HeapWord*>(dst), length);
 59   }
 60 
 61   void arraycopy_disjoint_words_atomic(void* src, void* dst, size_t length) {
 62     Copy::disjoint_words_atomic(reinterpret_cast<HeapWord*>(src),
 63                                 reinterpret_cast<HeapWord*>(dst), length);
 64   }
 65 
 66   template<> HIDDEN
 67   void arraycopy_conjoint<jboolean>(jboolean* src, jboolean* dst, size_t length) {
 68     Copy::conjoint_jbytes(reinterpret_cast<jbyte*>(src), reinterpret_cast<jbyte*>(dst), length);
 69   }
 70 
 71   template<> HIDDEN
 72   void arraycopy_conjoint<jbyte>(jbyte* src, jbyte* dst, size_t length) {
 73     Copy::conjoint_jbytes(src, dst, length);
 74   }
 75 
 76   template<> HIDDEN
 77   void arraycopy_conjoint<jchar>(jchar* src, jchar* dst, size_t length) {
 78     Copy::conjoint_jshorts_atomic(reinterpret_cast<jshort*>(src), reinterpret_cast<jshort*>(dst), length);
 79   }
 80 
 81   template<> HIDDEN
 82   void arraycopy_conjoint<jshort>(jshort* src, jshort* dst, size_t length) {
 83     Copy::conjoint_jshorts_atomic(src, dst, length);
 84   }
 85 
 86   template<> HIDDEN
 87   void arraycopy_conjoint<jint>(jint* src, jint* dst, size_t length) {
 88     Copy::conjoint_jints_atomic(src, dst, length);
 89   }
 90 
 91   template<> HIDDEN
 92   void arraycopy_conjoint<jfloat>(jfloat* src, jfloat* dst, size_t length) {
 93     Copy::conjoint_jints_atomic(reinterpret_cast<jint*>(src), reinterpret_cast<jint*>(dst), length);
 94   }
 95 
 96   template<> HIDDEN
 97   void arraycopy_conjoint<jlong>(jlong* src, jlong* dst, size_t length) {
 98     Copy::conjoint_jlongs_atomic(src, dst, length);
 99   }
100 
101   template<> HIDDEN
102   void arraycopy_conjoint<jdouble>(jdouble* src, jdouble* dst, size_t length) {
103     Copy::conjoint_jlongs_atomic(reinterpret_cast<jlong*>(src), reinterpret_cast<jlong*>(dst), length);
104   }
105 
106   template<> HIDDEN
107   void arraycopy_arrayof_conjoint<jbyte>(jbyte* src, jbyte* dst, size_t length) {
108     Copy::arrayof_conjoint_jbytes(reinterpret_cast<HeapWord*>(src),
109                                   reinterpret_cast<HeapWord*>(dst),
110                                   length);
111   }
112 
113   template<> HIDDEN
114   void arraycopy_arrayof_conjoint<jshort>(jshort* src, jshort* dst, size_t length) {
115     Copy::arrayof_conjoint_jshorts(reinterpret_cast<HeapWord*>(src),
116                                    reinterpret_cast<HeapWord*>(dst),
117                                    length);
118   }
119 
120   template<> HIDDEN
121   void arraycopy_arrayof_conjoint<jint>(jint* src, jint* dst, size_t length) {
122     Copy::arrayof_conjoint_jints(reinterpret_cast<HeapWord*>(src),
123                                  reinterpret_cast<HeapWord*>(dst),
124                                  length);
125   }
126 
127   template<> HIDDEN
128   void arraycopy_arrayof_conjoint<jlong>(jlong* src, jlong* dst, size_t length) {
129     Copy::arrayof_conjoint_jlongs(reinterpret_cast<HeapWord*>(src),
130                                   reinterpret_cast<HeapWord*>(dst),
131                                   length);
132   }
133 
134   template<> HIDDEN
135   void arraycopy_conjoint<void>(void* src, void* dst, size_t length) {
136     Copy::conjoint_jbytes(reinterpret_cast<jbyte*>(src),
137                           reinterpret_cast<jbyte*>(dst),
138                           length);
139   }
140 
141   template<> HIDDEN
142   void arraycopy_conjoint_atomic<jbyte>(jbyte* src, jbyte* dst, size_t length) {
143     Copy::conjoint_jbytes_atomic(src, dst, length);
144   }
145 
146   template<> HIDDEN
147   void arraycopy_conjoint_atomic<jshort>(jshort* src, jshort* dst, size_t length) {
148     Copy::conjoint_jshorts_atomic(src, dst, length);
149   }
150 
151   template<> HIDDEN
152   void arraycopy_conjoint_atomic<jint>(jint* src, jint* dst, size_t length) {
153     Copy::conjoint_jints_atomic(src, dst, length);
154   }
155 
156   template<> HIDDEN
157   void arraycopy_conjoint_atomic<jlong>(jlong* src, jlong* dst, size_t length) {
158     Copy::conjoint_jlongs_atomic(src, dst, length);
159   }
160 
161   template<> HIDDEN
162   void arraycopy_conjoint_atomic<void>(void* src, void* dst, size_t length) {
163     Copy::conjoint_memory_atomic(src, dst, length);
164   }
165 
166   void value_copy_internal(void* src, void* dst, size_t length) {
167     Copy::copy_value_content(src, dst, length);
168   }
169 
170 #ifdef ASSERT
171   void check_access_thread_state() {
172     if (VMError::is_error_reported() || DebuggingContext::is_enabled()) {
173       return;
174     }
175 
176     Thread* thread = Thread::current();
177     if (!thread->is_Java_thread()) {
178       return;
179     }
180 
181     JavaThread* java_thread = JavaThread::cast(thread);
182     JavaThreadState state = java_thread->thread_state();
183     assert(state == _thread_in_vm || state == _thread_in_Java || state == _thread_new,
184            "Wrong thread state for accesses: %d", (int)state);
185   }
186 #endif
187 }