1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <android-base/logging.h>
18
19 #include "art_method-inl.h"
20 #include "base/casts.h"
21 #include "entrypoints/entrypoint_utils-inl.h"
22 #include "indirect_reference_table.h"
23 #include "mirror/object-inl.h"
24 #include "thread-inl.h"
25 #include "verify_object.h"
26
27 namespace art {
28
29 static_assert(sizeof(IRTSegmentState) == sizeof(uint32_t), "IRTSegmentState size unexpected");
30 static_assert(std::is_trivial<IRTSegmentState>::value, "IRTSegmentState not trivial");
31
32 static inline void GoToRunnableFast(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_);
33
ReadBarrierJni(mirror::CompressedReference<mirror::Object> * handle_on_stack,Thread * self ATTRIBUTE_UNUSED)34 extern void ReadBarrierJni(mirror::CompressedReference<mirror::Object>* handle_on_stack,
35 Thread* self ATTRIBUTE_UNUSED) {
36 DCHECK(kUseReadBarrier);
37 if (kUseBakerReadBarrier) {
38 DCHECK(handle_on_stack->AsMirrorPtr() != nullptr)
39 << "The class of a static jni call must not be null";
40 // Check the mark bit and return early if it's already marked.
41 if (LIKELY(handle_on_stack->AsMirrorPtr()->GetMarkBit() != 0)) {
42 return;
43 }
44 }
45 // Call the read barrier and update the handle.
46 mirror::Object* to_ref = ReadBarrier::BarrierForRoot(handle_on_stack);
47 handle_on_stack->Assign(to_ref);
48 }
49
50 // Called on entry to fast JNI, push a new local reference table only.
JniMethodFastStart(Thread * self)51 extern uint32_t JniMethodFastStart(Thread* self) {
52 JNIEnvExt* env = self->GetJniEnv();
53 DCHECK(env != nullptr);
54 uint32_t saved_local_ref_cookie = bit_cast<uint32_t>(env->GetLocalRefCookie());
55 env->SetLocalRefCookie(env->GetLocalsSegmentState());
56
57 if (kIsDebugBuild) {
58 ArtMethod* native_method = *self->GetManagedStack()->GetTopQuickFrame();
59 CHECK(native_method->IsFastNative()) << native_method->PrettyMethod();
60 }
61
62 return saved_local_ref_cookie;
63 }
64
65 // Called on entry to JNI, transition out of Runnable and release share of mutator_lock_.
JniMethodStart(Thread * self)66 extern uint32_t JniMethodStart(Thread* self) {
67 JNIEnvExt* env = self->GetJniEnv();
68 DCHECK(env != nullptr);
69 uint32_t saved_local_ref_cookie = bit_cast<uint32_t>(env->GetLocalRefCookie());
70 env->SetLocalRefCookie(env->GetLocalsSegmentState());
71 ArtMethod* native_method = *self->GetManagedStack()->GetTopQuickFrame();
72 // TODO: Introduce special entrypoint for synchronized @FastNative methods?
73 // Or ban synchronized @FastNative outright to avoid the extra check here?
74 DCHECK(!native_method->IsFastNative() || native_method->IsSynchronized());
75 if (!native_method->IsFastNative()) {
76 // When not fast JNI we transition out of runnable.
77 self->TransitionFromRunnableToSuspended(kNative);
78 }
79 return saved_local_ref_cookie;
80 }
81
JniMethodStartSynchronized(jobject to_lock,Thread * self)82 extern uint32_t JniMethodStartSynchronized(jobject to_lock, Thread* self) {
83 self->DecodeJObject(to_lock)->MonitorEnter(self);
84 return JniMethodStart(self);
85 }
86
87 // TODO: NO_THREAD_SAFETY_ANALYSIS due to different control paths depending on fast JNI.
GoToRunnable(Thread * self)88 static void GoToRunnable(Thread* self) NO_THREAD_SAFETY_ANALYSIS {
89 ArtMethod* native_method = *self->GetManagedStack()->GetTopQuickFrame();
90 bool is_fast = native_method->IsFastNative();
91 if (!is_fast) {
92 self->TransitionFromSuspendedToRunnable();
93 } else {
94 GoToRunnableFast(self);
95 }
96 }
97
GoToRunnableFast(Thread * self)98 ALWAYS_INLINE static inline void GoToRunnableFast(Thread* self) {
99 if (kIsDebugBuild) {
100 // Should only enter here if the method is @FastNative.
101 ArtMethod* native_method = *self->GetManagedStack()->GetTopQuickFrame();
102 CHECK(native_method->IsFastNative()) << native_method->PrettyMethod();
103 }
104
105 // When we are in @FastNative, we are already Runnable.
106 // Only do a suspend check on the way out of JNI.
107 if (UNLIKELY(self->TestAllFlags())) {
108 // In fast JNI mode we never transitioned out of runnable. Perform a suspend check if there
109 // is a flag raised.
110 DCHECK(Locks::mutator_lock_->IsSharedHeld(self));
111 self->CheckSuspend();
112 }
113 }
114
PopLocalReferences(uint32_t saved_local_ref_cookie,Thread * self)115 static void PopLocalReferences(uint32_t saved_local_ref_cookie, Thread* self)
116 REQUIRES_SHARED(Locks::mutator_lock_) {
117 JNIEnvExt* env = self->GetJniEnv();
118 if (UNLIKELY(env->IsCheckJniEnabled())) {
119 env->CheckNoHeldMonitors();
120 }
121 env->SetLocalSegmentState(env->GetLocalRefCookie());
122 env->SetLocalRefCookie(bit_cast<IRTSegmentState>(saved_local_ref_cookie));
123 self->PopHandleScope();
124 }
125
126 // TODO: These should probably be templatized or macro-ized.
127 // Otherwise there's just too much repetitive boilerplate.
128
JniMethodEnd(uint32_t saved_local_ref_cookie,Thread * self)129 extern void JniMethodEnd(uint32_t saved_local_ref_cookie, Thread* self) {
130 GoToRunnable(self);
131 PopLocalReferences(saved_local_ref_cookie, self);
132 }
133
JniMethodFastEnd(uint32_t saved_local_ref_cookie,Thread * self)134 extern void JniMethodFastEnd(uint32_t saved_local_ref_cookie, Thread* self) {
135 GoToRunnableFast(self);
136 PopLocalReferences(saved_local_ref_cookie, self);
137 }
138
JniMethodEndSynchronized(uint32_t saved_local_ref_cookie,jobject locked,Thread * self)139 extern void JniMethodEndSynchronized(uint32_t saved_local_ref_cookie,
140 jobject locked,
141 Thread* self) {
142 GoToRunnable(self);
143 UnlockJniSynchronizedMethod(locked, self); // Must decode before pop.
144 PopLocalReferences(saved_local_ref_cookie, self);
145 }
146
147 // Common result handling for EndWithReference.
JniMethodEndWithReferenceHandleResult(jobject result,uint32_t saved_local_ref_cookie,Thread * self)148 static mirror::Object* JniMethodEndWithReferenceHandleResult(jobject result,
149 uint32_t saved_local_ref_cookie,
150 Thread* self)
151 NO_THREAD_SAFETY_ANALYSIS {
152 // Must decode before pop. The 'result' may not be valid in case of an exception, though.
153 ObjPtr<mirror::Object> o;
154 if (!self->IsExceptionPending()) {
155 o = self->DecodeJObject(result);
156 }
157 PopLocalReferences(saved_local_ref_cookie, self);
158 // Process result.
159 if (UNLIKELY(self->GetJniEnv()->IsCheckJniEnabled())) {
160 // CheckReferenceResult can resolve types.
161 StackHandleScope<1> hs(self);
162 HandleWrapperObjPtr<mirror::Object> h_obj(hs.NewHandleWrapper(&o));
163 CheckReferenceResult(h_obj, self);
164 }
165 VerifyObject(o);
166 return o.Ptr();
167 }
168
JniMethodFastEndWithReference(jobject result,uint32_t saved_local_ref_cookie,Thread * self)169 extern mirror::Object* JniMethodFastEndWithReference(jobject result,
170 uint32_t saved_local_ref_cookie,
171 Thread* self) {
172 GoToRunnableFast(self);
173 return JniMethodEndWithReferenceHandleResult(result, saved_local_ref_cookie, self);
174 }
175
JniMethodEndWithReference(jobject result,uint32_t saved_local_ref_cookie,Thread * self)176 extern mirror::Object* JniMethodEndWithReference(jobject result,
177 uint32_t saved_local_ref_cookie,
178 Thread* self) {
179 GoToRunnable(self);
180 return JniMethodEndWithReferenceHandleResult(result, saved_local_ref_cookie, self);
181 }
182
JniMethodEndWithReferenceSynchronized(jobject result,uint32_t saved_local_ref_cookie,jobject locked,Thread * self)183 extern mirror::Object* JniMethodEndWithReferenceSynchronized(jobject result,
184 uint32_t saved_local_ref_cookie,
185 jobject locked,
186 Thread* self) {
187 GoToRunnable(self);
188 UnlockJniSynchronizedMethod(locked, self);
189 return JniMethodEndWithReferenceHandleResult(result, saved_local_ref_cookie, self);
190 }
191
GenericJniMethodEnd(Thread * self,uint32_t saved_local_ref_cookie,jvalue result,uint64_t result_f,ArtMethod * called,HandleScope * handle_scope)192 extern uint64_t GenericJniMethodEnd(Thread* self,
193 uint32_t saved_local_ref_cookie,
194 jvalue result,
195 uint64_t result_f,
196 ArtMethod* called,
197 HandleScope* handle_scope)
198 // TODO: NO_THREAD_SAFETY_ANALYSIS as GoToRunnable() is NO_THREAD_SAFETY_ANALYSIS
199 NO_THREAD_SAFETY_ANALYSIS {
200 bool critical_native = called->IsCriticalNative();
201 bool fast_native = called->IsFastNative();
202 bool normal_native = !critical_native && !fast_native;
203
204 // @Fast and @CriticalNative do not do a state transition.
205 if (LIKELY(normal_native)) {
206 GoToRunnable(self);
207 }
208 // We need the mutator lock (i.e., calling GoToRunnable()) before accessing the shorty or the
209 // locked object.
210 jobject locked = called->IsSynchronized() ? handle_scope->GetHandle(0).ToJObject() : nullptr;
211 char return_shorty_char = called->GetShorty()[0];
212 if (return_shorty_char == 'L') {
213 if (locked != nullptr) {
214 DCHECK(normal_native) << " @FastNative and synchronize is not supported";
215 UnlockJniSynchronizedMethod(locked, self);
216 }
217 return reinterpret_cast<uint64_t>(JniMethodEndWithReferenceHandleResult(
218 result.l, saved_local_ref_cookie, self));
219 } else {
220 if (locked != nullptr) {
221 DCHECK(normal_native) << " @FastNative and synchronize is not supported";
222 UnlockJniSynchronizedMethod(locked, self); // Must decode before pop.
223 }
224 if (LIKELY(!critical_native)) {
225 PopLocalReferences(saved_local_ref_cookie, self);
226 }
227 switch (return_shorty_char) {
228 case 'F': {
229 if (kRuntimeISA == InstructionSet::kX86) {
230 // Convert back the result to float.
231 double d = bit_cast<double, uint64_t>(result_f);
232 return bit_cast<uint32_t, float>(static_cast<float>(d));
233 } else {
234 return result_f;
235 }
236 }
237 case 'D':
238 return result_f;
239 case 'Z':
240 return result.z;
241 case 'B':
242 return result.b;
243 case 'C':
244 return result.c;
245 case 'S':
246 return result.s;
247 case 'I':
248 return result.i;
249 case 'J':
250 return result.j;
251 case 'V':
252 return 0;
253 default:
254 LOG(FATAL) << "Unexpected return shorty character " << return_shorty_char;
255 UNREACHABLE();
256 }
257 }
258 }
259
260 } // namespace art
261