1 /* Copyright (C) 2016 The Android Open Source Project
2  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3  *
4  * This file implements interfaces from the file jvmti.h. This implementation
5  * is licensed under the same terms as the file jvmti.h.  The
6  * copyright and license information for the file jvmti.h follows.
7  *
8  * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
9  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
10  *
11  * This code is free software; you can redistribute it and/or modify it
12  * under the terms of the GNU General Public License version 2 only, as
13  * published by the Free Software Foundation.  Oracle designates this
14  * particular file as subject to the "Classpath" exception as provided
15  * by Oracle in the LICENSE file that accompanied this code.
16  *
17  * This code is distributed in the hope that it will be useful, but WITHOUT
18  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
20  * version 2 for more details (a copy is included in the LICENSE file that
21  * accompanied this code).
22  *
23  * You should have received a copy of the GNU General Public License version
24  * 2 along with this work; if not, write to the Free Software Foundation,
25  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
26  *
27  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
28  * or visit www.oracle.com if you need additional information or have any
29  * questions.
30  */
31 
32 #include "ti_method.h"
33 
34 #include <initializer_list>
35 #include <type_traits>
36 #include <variant>
37 
38 #include "android-base/macros.h"
39 #include "arch/context.h"
40 #include "art_jvmti.h"
41 #include "art_method-inl.h"
42 #include "base/enums.h"
43 #include "base/globals.h"
44 #include "base/macros.h"
45 #include "base/mutex-inl.h"
46 #include "deopt_manager.h"
47 #include "dex/code_item_accessors-inl.h"
48 #include "dex/code_item_accessors.h"
49 #include "dex/dex_file_annotations.h"
50 #include "dex/dex_file_types.h"
51 #include "dex/dex_instruction.h"
52 #include "dex/dex_instruction_iterator.h"
53 #include "dex/modifiers.h"
54 #include "dex/primitive.h"
55 #include "events-inl.h"
56 #include "gc_root-inl.h"
57 #include "handle.h"
58 #include "jit/jit.h"
59 #include "jni/jni_internal.h"
60 #include "jvmti.h"
61 #include "mirror/class-inl.h"
62 #include "mirror/class_loader.h"
63 #include "mirror/object-inl.h"
64 #include "mirror/object_array-inl.h"
65 #include "nativehelper/scoped_local_ref.h"
66 #include "oat_file.h"
67 #include "obj_ptr.h"
68 #include "runtime.h"
69 #include "runtime_callbacks.h"
70 #include "scoped_thread_state_change-inl.h"
71 #include "scoped_thread_state_change.h"
72 #include "stack.h"
73 #include "thread-current-inl.h"
74 #include "thread.h"
75 #include "thread_list.h"
76 #include "ti_logging.h"
77 #include "ti_stack.h"
78 #include "ti_thread.h"
79 #include "ti_phase.h"
80 #include "verifier/register_line-inl.h"
81 #include "verifier/reg_type-inl.h"
82 #include "verifier/method_verifier-inl.h"
83 
84 namespace openjdkjvmti {
85 
86 struct TiMethodCallback : public art::MethodCallback {
RegisterNativeMethodopenjdkjvmti::TiMethodCallback87   void RegisterNativeMethod(art::ArtMethod* method,
88                             const void* cur_method,
89                             /*out*/void** new_method)
90       override REQUIRES_SHARED(art::Locks::mutator_lock_) {
91     if (event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kNativeMethodBind)) {
92       art::Thread* thread = art::Thread::Current();
93       art::JNIEnvExt* jnienv = thread->GetJniEnv();
94       ScopedLocalRef<jthread> thread_jni(
95           jnienv, PhaseUtil::IsLivePhase() ? jnienv->AddLocalReference<jthread>(thread->GetPeer())
96                                            : nullptr);
97       jmethodID method_id = art::jni::EncodeArtMethod(method);
98       art::ScopedThreadSuspension sts(thread, art::ThreadState::kNative);
99       event_handler->DispatchEvent<ArtJvmtiEvent::kNativeMethodBind>(
100           thread,
101           static_cast<JNIEnv*>(jnienv),
102           thread_jni.get(),
103           method_id,
104           const_cast<void*>(cur_method),
105           new_method);
106     }
107   }
108 
109   EventHandler* event_handler = nullptr;
110 };
111 
112 TiMethodCallback gMethodCallback;
113 
Register(EventHandler * handler)114 void MethodUtil::Register(EventHandler* handler) {
115   gMethodCallback.event_handler = handler;
116   art::ScopedThreadStateChange stsc(art::Thread::Current(),
117                                     art::ThreadState::kWaitingForDebuggerToAttach);
118   art::ScopedSuspendAll ssa("Add method callback");
119   art::RuntimeCallbacks* callbacks = art::Runtime::Current()->GetRuntimeCallbacks();
120   callbacks->AddMethodCallback(&gMethodCallback);
121 }
122 
Unregister()123 void MethodUtil::Unregister() {
124   art::ScopedThreadStateChange stsc(art::Thread::Current(),
125                                     art::ThreadState::kWaitingForDebuggerToAttach);
126   art::ScopedSuspendAll ssa("Remove method callback");
127   art::RuntimeCallbacks* callbacks = art::Runtime::Current()->GetRuntimeCallbacks();
128   callbacks->RemoveMethodCallback(&gMethodCallback);
129 }
130 
GetBytecodes(jvmtiEnv * env,jmethodID method,jint * size_ptr,unsigned char ** bytecode_ptr)131 jvmtiError MethodUtil::GetBytecodes(jvmtiEnv* env,
132                                     jmethodID method,
133                                     jint* size_ptr,
134                                     unsigned char** bytecode_ptr) {
135   if (method == nullptr) {
136     return ERR(INVALID_METHODID);
137   }
138   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
139 
140   if (art_method->IsNative()) {
141     return ERR(NATIVE_METHOD);
142   }
143 
144   if (size_ptr == nullptr || bytecode_ptr == nullptr) {
145     return ERR(NULL_POINTER);
146   }
147 
148   art::ScopedObjectAccess soa(art::Thread::Current());
149   art::CodeItemInstructionAccessor accessor(art_method->DexInstructions());
150   if (!accessor.HasCodeItem()) {
151     *size_ptr = 0;
152     *bytecode_ptr = nullptr;
153     return OK;
154   }
155   // 2 bytes per instruction for dex code.
156   *size_ptr = accessor.InsnsSizeInCodeUnits() * 2;
157   jvmtiError err = env->Allocate(*size_ptr, bytecode_ptr);
158   if (err != OK) {
159     return err;
160   }
161   memcpy(*bytecode_ptr, accessor.Insns(), *size_ptr);
162   return OK;
163 }
164 
GetArgumentsSize(jvmtiEnv * env ATTRIBUTE_UNUSED,jmethodID method,jint * size_ptr)165 jvmtiError MethodUtil::GetArgumentsSize(jvmtiEnv* env ATTRIBUTE_UNUSED,
166                                         jmethodID method,
167                                         jint* size_ptr) {
168   if (method == nullptr) {
169     return ERR(INVALID_METHODID);
170   }
171   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
172 
173   if (art_method->IsNative()) {
174     return ERR(NATIVE_METHOD);
175   }
176 
177   if (size_ptr == nullptr) {
178     return ERR(NULL_POINTER);
179   }
180 
181   art::ScopedObjectAccess soa(art::Thread::Current());
182   if (art_method->IsProxyMethod() || art_method->IsAbstract()) {
183     // Use the shorty.
184     art::ArtMethod* base_method = art_method->GetInterfaceMethodIfProxy(art::kRuntimePointerSize);
185     size_t arg_count = art::ArtMethod::NumArgRegisters(base_method->GetShorty());
186     if (!base_method->IsStatic()) {
187       arg_count++;
188     }
189     *size_ptr = static_cast<jint>(arg_count);
190     return ERR(NONE);
191   }
192 
193   DCHECK_NE(art_method->GetCodeItemOffset(), 0u);
194   *size_ptr = art_method->DexInstructionData().InsSize();
195 
196   return ERR(NONE);
197 }
198 
GetLocalVariableTable(jvmtiEnv * env,jmethodID method,jint * entry_count_ptr,jvmtiLocalVariableEntry ** table_ptr)199 jvmtiError MethodUtil::GetLocalVariableTable(jvmtiEnv* env,
200                                              jmethodID method,
201                                              jint* entry_count_ptr,
202                                              jvmtiLocalVariableEntry** table_ptr) {
203   if (method == nullptr) {
204     return ERR(INVALID_METHODID);
205   }
206   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
207 
208   if (art_method->IsNative()) {
209     return ERR(NATIVE_METHOD);
210   }
211 
212   if (entry_count_ptr == nullptr || table_ptr == nullptr) {
213     return ERR(NULL_POINTER);
214   }
215 
216   art::ScopedObjectAccess soa(art::Thread::Current());
217 
218   const art::DexFile* const dex_file = art_method->GetDexFile();
219   if (dex_file == nullptr) {
220     return ERR(ABSENT_INFORMATION);
221   }
222 
223   // TODO HasCodeItem == false means that the method is abstract (or native, but we check that
224   // earlier). We should check what is returned by the RI in this situation since it's not clear
225   // what the appropriate return value is from the spec.
226   art::CodeItemDebugInfoAccessor accessor(art_method->DexInstructionDebugInfo());
227   if (!accessor.HasCodeItem()) {
228     return ERR(ABSENT_INFORMATION);
229   }
230 
231   std::vector<jvmtiLocalVariableEntry> variables;
232   jvmtiError err = OK;
233 
234   auto release = [&](jint* out_entry_count_ptr, jvmtiLocalVariableEntry** out_table_ptr) {
235     jlong table_size = sizeof(jvmtiLocalVariableEntry) * variables.size();
236     if (err != OK ||
237         (err = env->Allocate(table_size,
238                               reinterpret_cast<unsigned char**>(out_table_ptr))) != OK) {
239       for (jvmtiLocalVariableEntry& e : variables) {
240         env->Deallocate(reinterpret_cast<unsigned char*>(e.name));
241         env->Deallocate(reinterpret_cast<unsigned char*>(e.signature));
242         env->Deallocate(reinterpret_cast<unsigned char*>(e.generic_signature));
243       }
244       return err;
245     }
246     *out_entry_count_ptr = variables.size();
247     memcpy(*out_table_ptr, variables.data(), table_size);
248     return OK;
249   };
250 
251   auto visitor = [&](const art::DexFile::LocalInfo& entry) {
252     if (err != OK) {
253       return;
254     }
255     JvmtiUniquePtr<char[]> name_str = CopyString(env, entry.name_, &err);
256     if (err != OK) {
257       return;
258     }
259     JvmtiUniquePtr<char[]> sig_str = CopyString(env, entry.descriptor_, &err);
260     if (err != OK) {
261       return;
262     }
263     JvmtiUniquePtr<char[]> generic_sig_str = CopyString(env, entry.signature_, &err);
264     if (err != OK) {
265       return;
266     }
267     variables.push_back({
268       .start_location = static_cast<jlocation>(entry.start_address_),
269       .length = static_cast<jint>(entry.end_address_ - entry.start_address_),
270       .name = name_str.release(),
271       .signature = sig_str.release(),
272       .generic_signature = generic_sig_str.release(),
273       .slot = entry.reg_,
274     });
275   };
276 
277   if (!accessor.DecodeDebugLocalInfo(art_method->IsStatic(),
278                                      art_method->GetDexMethodIndex(),
279                                      visitor)) {
280     // Something went wrong with decoding the debug information. It might as well not be there.
281     return ERR(ABSENT_INFORMATION);
282   }
283   return release(entry_count_ptr, table_ptr);
284 }
285 
GetMaxLocals(jvmtiEnv * env ATTRIBUTE_UNUSED,jmethodID method,jint * max_ptr)286 jvmtiError MethodUtil::GetMaxLocals(jvmtiEnv* env ATTRIBUTE_UNUSED,
287                                     jmethodID method,
288                                     jint* max_ptr) {
289   if (method == nullptr) {
290     return ERR(INVALID_METHODID);
291   }
292   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
293 
294   if (art_method->IsNative()) {
295     return ERR(NATIVE_METHOD);
296   }
297 
298   if (max_ptr == nullptr) {
299     return ERR(NULL_POINTER);
300   }
301 
302   art::ScopedObjectAccess soa(art::Thread::Current());
303   if (art_method->IsProxyMethod() || art_method->IsAbstract()) {
304     // This isn't specified as an error case, so return 0.
305     *max_ptr = 0;
306     return ERR(NONE);
307   }
308 
309   DCHECK_NE(art_method->GetCodeItemOffset(), 0u);
310   *max_ptr = art_method->DexInstructionData().RegistersSize();
311 
312   return ERR(NONE);
313 }
314 
GetMethodName(jvmtiEnv * env,jmethodID method,char ** name_ptr,char ** signature_ptr,char ** generic_ptr)315 jvmtiError MethodUtil::GetMethodName(jvmtiEnv* env,
316                                      jmethodID method,
317                                      char** name_ptr,
318                                      char** signature_ptr,
319                                      char** generic_ptr) {
320   art::ScopedObjectAccess soa(art::Thread::Current());
321   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
322   art_method = art_method->GetInterfaceMethodIfProxy(art::kRuntimePointerSize);
323 
324   JvmtiUniquePtr<char[]> name_copy;
325   if (name_ptr != nullptr) {
326     const char* method_name = art_method->GetName();
327     if (method_name == nullptr) {
328       method_name = "<error>";
329     }
330     jvmtiError ret;
331     name_copy = CopyString(env, method_name, &ret);
332     if (name_copy == nullptr) {
333       return ret;
334     }
335     *name_ptr = name_copy.get();
336   }
337 
338   JvmtiUniquePtr<char[]> signature_copy;
339   if (signature_ptr != nullptr) {
340     const art::Signature sig = art_method->GetSignature();
341     std::string str = sig.ToString();
342     jvmtiError ret;
343     signature_copy = CopyString(env, str.c_str(), &ret);
344     if (signature_copy == nullptr) {
345       return ret;
346     }
347     *signature_ptr = signature_copy.get();
348   }
349 
350   if (generic_ptr != nullptr) {
351     *generic_ptr = nullptr;
352     if (!art_method->GetDeclaringClass()->IsProxyClass()) {
353       art::ObjPtr<art::mirror::ObjectArray<art::mirror::String>> str_array =
354           art::annotations::GetSignatureAnnotationForMethod(art_method);
355       if (str_array != nullptr) {
356         std::ostringstream oss;
357         for (auto str : str_array->Iterate()) {
358           oss << str->ToModifiedUtf8();
359         }
360         std::string output_string = oss.str();
361         jvmtiError ret;
362         JvmtiUniquePtr<char[]> generic_copy = CopyString(env, output_string.c_str(), &ret);
363         if (generic_copy == nullptr) {
364           return ret;
365         }
366         *generic_ptr = generic_copy.release();
367       } else if (soa.Self()->IsExceptionPending()) {
368         // TODO: Should we report an error here?
369         soa.Self()->ClearException();
370       }
371     }
372   }
373 
374   // Everything is fine, release the buffers.
375   name_copy.release();
376   signature_copy.release();
377 
378   return ERR(NONE);
379 }
380 
GetMethodDeclaringClass(jvmtiEnv * env ATTRIBUTE_UNUSED,jmethodID method,jclass * declaring_class_ptr)381 jvmtiError MethodUtil::GetMethodDeclaringClass(jvmtiEnv* env ATTRIBUTE_UNUSED,
382                                                jmethodID method,
383                                                jclass* declaring_class_ptr) {
384   if (declaring_class_ptr == nullptr) {
385     return ERR(NULL_POINTER);
386   }
387 
388   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
389   // Note: No GetInterfaceMethodIfProxy, we want to actual class.
390 
391   art::ScopedObjectAccess soa(art::Thread::Current());
392   art::ObjPtr<art::mirror::Class> klass = art_method->GetDeclaringClass();
393   *declaring_class_ptr = soa.AddLocalReference<jclass>(klass);
394 
395   return ERR(NONE);
396 }
397 
GetMethodLocation(jvmtiEnv * env ATTRIBUTE_UNUSED,jmethodID method,jlocation * start_location_ptr,jlocation * end_location_ptr)398 jvmtiError MethodUtil::GetMethodLocation(jvmtiEnv* env ATTRIBUTE_UNUSED,
399                                          jmethodID method,
400                                          jlocation* start_location_ptr,
401                                          jlocation* end_location_ptr) {
402   if (method == nullptr) {
403     return ERR(INVALID_METHODID);
404   }
405   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
406 
407   if (art_method->IsNative()) {
408     return ERR(NATIVE_METHOD);
409   }
410 
411   if (start_location_ptr == nullptr || end_location_ptr == nullptr) {
412     return ERR(NULL_POINTER);
413   }
414 
415   art::ScopedObjectAccess soa(art::Thread::Current());
416   if (art_method->IsProxyMethod() || art_method->IsAbstract()) {
417     // This isn't specified as an error case, so return -1/-1 as the RI does.
418     *start_location_ptr = -1;
419     *end_location_ptr = -1;
420     return ERR(NONE);
421   }
422 
423   DCHECK_NE(art_method->GetCodeItemOffset(), 0u);
424   *start_location_ptr = 0;
425   *end_location_ptr = art_method->DexInstructions().InsnsSizeInCodeUnits() - 1;
426 
427   return ERR(NONE);
428 }
429 
GetMethodModifiers(jvmtiEnv * env ATTRIBUTE_UNUSED,jmethodID method,jint * modifiers_ptr)430 jvmtiError MethodUtil::GetMethodModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED,
431                                           jmethodID method,
432                                           jint* modifiers_ptr) {
433   if (modifiers_ptr == nullptr) {
434     return ERR(NULL_POINTER);
435   }
436 
437   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
438   uint32_t modifiers = art_method->GetAccessFlags();
439 
440   // Note: Keep this code in sync with Executable.fixMethodFlags.
441   if ((modifiers & art::kAccAbstract) != 0) {
442     modifiers &= ~art::kAccNative;
443   }
444   modifiers &= ~art::kAccSynchronized;
445   if ((modifiers & art::kAccDeclaredSynchronized) != 0) {
446     modifiers |= art::kAccSynchronized;
447   }
448   modifiers &= art::kAccJavaFlagsMask;
449 
450   *modifiers_ptr = modifiers;
451   return ERR(NONE);
452 }
453 
GetLineNumberTable(jvmtiEnv * env,jmethodID method,jint * entry_count_ptr,jvmtiLineNumberEntry ** table_ptr)454 jvmtiError MethodUtil::GetLineNumberTable(jvmtiEnv* env,
455                                           jmethodID method,
456                                           jint* entry_count_ptr,
457                                           jvmtiLineNumberEntry** table_ptr) {
458   if (method == nullptr) {
459     return ERR(NULL_POINTER);
460   }
461   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
462   DCHECK(!art_method->IsRuntimeMethod());
463 
464   art::CodeItemDebugInfoAccessor accessor;
465   const art::DexFile* dex_file;
466   {
467     art::ScopedObjectAccess soa(art::Thread::Current());
468 
469     if (art_method->IsProxyMethod()) {
470       return ERR(ABSENT_INFORMATION);
471     }
472     if (art_method->IsNative()) {
473       return ERR(NATIVE_METHOD);
474     }
475     if (entry_count_ptr == nullptr || table_ptr == nullptr) {
476       return ERR(NULL_POINTER);
477     }
478 
479     accessor = art::CodeItemDebugInfoAccessor(art_method->DexInstructionDebugInfo());
480     dex_file = art_method->GetDexFile();
481     DCHECK(accessor.HasCodeItem()) << art_method->PrettyMethod() << " " << dex_file->GetLocation();
482   }
483 
484   std::vector<jvmtiLineNumberEntry> context;
485   bool success = accessor.DecodeDebugPositionInfo([&](const art::DexFile::PositionInfo& entry) {
486     context.push_back({static_cast<jlocation>(entry.address_), static_cast<jint>(entry.line_)});
487     return false;
488   });
489   if (!success) {
490     return ERR(ABSENT_INFORMATION);
491   }
492 
493   unsigned char* data;
494   jlong mem_size = context.size() * sizeof(jvmtiLineNumberEntry);
495   jvmtiError alloc_error = env->Allocate(mem_size, &data);
496   if (alloc_error != ERR(NONE)) {
497     return alloc_error;
498   }
499   *table_ptr = reinterpret_cast<jvmtiLineNumberEntry*>(data);
500   memcpy(*table_ptr, context.data(), mem_size);
501   *entry_count_ptr = static_cast<jint>(context.size());
502 
503   return ERR(NONE);
504 }
505 
506 template <typename T>
IsMethodT(jvmtiEnv * env ATTRIBUTE_UNUSED,jmethodID method,T test,jboolean * is_t_ptr)507 static jvmtiError IsMethodT(jvmtiEnv* env ATTRIBUTE_UNUSED,
508                             jmethodID method,
509                             T test,
510                             jboolean* is_t_ptr) {
511   if (method == nullptr) {
512     return ERR(INVALID_METHODID);
513   }
514   if (is_t_ptr == nullptr) {
515     return ERR(NULL_POINTER);
516   }
517 
518   art::ArtMethod* art_method = art::jni::DecodeArtMethod(method);
519   *is_t_ptr = test(art_method) ? JNI_TRUE : JNI_FALSE;
520 
521   return ERR(NONE);
522 }
523 
IsMethodNative(jvmtiEnv * env,jmethodID m,jboolean * is_native_ptr)524 jvmtiError MethodUtil::IsMethodNative(jvmtiEnv* env, jmethodID m, jboolean* is_native_ptr) {
525   auto test = [](art::ArtMethod* method) {
526     return method->IsNative();
527   };
528   return IsMethodT(env, m, test, is_native_ptr);
529 }
530 
IsMethodObsolete(jvmtiEnv * env,jmethodID m,jboolean * is_obsolete_ptr)531 jvmtiError MethodUtil::IsMethodObsolete(jvmtiEnv* env, jmethodID m, jboolean* is_obsolete_ptr) {
532   auto test = [](art::ArtMethod* method) {
533     return method->IsObsolete();
534   };
535   return IsMethodT(env, m, test, is_obsolete_ptr);
536 }
537 
IsMethodSynthetic(jvmtiEnv * env,jmethodID m,jboolean * is_synthetic_ptr)538 jvmtiError MethodUtil::IsMethodSynthetic(jvmtiEnv* env, jmethodID m, jboolean* is_synthetic_ptr) {
539   auto test = [](art::ArtMethod* method) {
540     return method->IsSynthetic();
541   };
542   return IsMethodT(env, m, test, is_synthetic_ptr);
543 }
544 
545 class CommonLocalVariableClosure : public art::Closure {
546  public:
547   // The verifier isn't always able to be as specific as the local-variable-table. We can only get
548   // 32-bit, 64-bit or reference.
549   enum class VerifierPrimitiveType {
550     k32BitValue,  // float, int, short, char, boolean, byte
551     k64BitValue,  // double, long
552     kReferenceValue,  // Object
553     kZeroValue,  // null or zero constant. Might be either k32BitValue or kReferenceValue
554   };
555 
556   using SlotType = std::variant<art::Primitive::Type, VerifierPrimitiveType>;
557 
CommonLocalVariableClosure(jvmtiEnv * jvmti,jint depth,jint slot)558   CommonLocalVariableClosure(jvmtiEnv* jvmti, jint depth, jint slot)
559       : jvmti_(jvmti), result_(ERR(INTERNAL)), depth_(depth), slot_(slot) {}
560 
Run(art::Thread * self)561   void Run(art::Thread* self) override REQUIRES_SHARED(art::Locks::mutator_lock_) {
562     art::Locks::mutator_lock_->AssertSharedHeld(art::Thread::Current());
563     bool needs_instrument;
564     {
565       art::ScopedAssertNoThreadSuspension sants("CommonLocalVariableClosure::Run");
566       std::unique_ptr<art::Context> context(art::Context::Create());
567       FindFrameAtDepthVisitor visitor(self, context.get(), depth_);
568       visitor.WalkStack();
569       if (!visitor.FoundFrame()) {
570         // Must have been a bad depth.
571         result_ = ERR(NO_MORE_FRAMES);
572         return;
573       }
574       art::ArtMethod* method = visitor.GetMethod();
575       // Native and 'art' proxy methods don't have registers.
576       if (method->IsNative() || method->IsProxyMethod()) {
577         // TODO It might be useful to fake up support for get at least on proxy frames.
578         result_ = ERR(OPAQUE_FRAME);
579         return;
580       } else if (slot_ >= method->DexInstructionData().RegistersSize() || slot_ < 0) {
581         result_ = ERR(INVALID_SLOT);
582         return;
583       }
584       needs_instrument = !visitor.IsShadowFrame();
585       uint32_t pc = visitor.GetDexPc(/*abort_on_failure=*/false);
586       if (pc == art::dex::kDexNoIndex) {
587         // Cannot figure out current PC.
588         result_ = ERR(OPAQUE_FRAME);
589         return;
590       }
591       std::string descriptor;
592       SlotType slot_type{ art::Primitive::kPrimVoid };
593       jvmtiError err = GetSlotType(method, pc, &descriptor, &slot_type);
594       if (err != OK) {
595         result_ = err;
596         return;
597       }
598 
599       err = GetTypeError(method, slot_type, descriptor);
600       if (err != OK) {
601         result_ = err;
602         return;
603       }
604       result_ = Execute(method, visitor);
605     }
606     if (needs_instrument) {
607       DeoptManager::Get()->DeoptimizeThread(self);
608     }
609   }
610 
GetResult()611   virtual jvmtiError GetResult() {
612     return result_;
613   }
614 
615  protected:
616   virtual jvmtiError Execute(art::ArtMethod* method, art::StackVisitor& visitor)
617       REQUIRES_SHARED(art::Locks::mutator_lock_) = 0;
618   virtual jvmtiError GetTypeError(art::ArtMethod* method,
619                                   SlotType type,
620                                   const std::string& descriptor)
621       REQUIRES_SHARED(art::Locks::mutator_lock_)  = 0;
622 
623   jvmtiError GetSlotType(art::ArtMethod* method,
624                          uint32_t dex_pc,
625                          /*out*/std::string* descriptor,
626                          /*out*/SlotType* type)
627       REQUIRES_SHARED(art::Locks::mutator_lock_);
628 
InferSlotTypeFromVerifier(art::ArtMethod * method,uint32_t dex_pc,std::string * descriptor,SlotType * type)629   jvmtiError InferSlotTypeFromVerifier(art::ArtMethod* method,
630                                        uint32_t dex_pc,
631                                        /*out*/ std::string* descriptor,
632                                        /*out*/ SlotType* type)
633       REQUIRES_SHARED(art::Locks::mutator_lock_) {
634     art::Thread* self = art::Thread::Current();
635     art::StackHandleScope<2> hs(self);
636     std::unique_ptr<art::verifier::MethodVerifier> verifier(
637         art::verifier::MethodVerifier::CalculateVerificationInfo(
638             self,
639             method,
640             hs.NewHandle(method->GetDexCache()),
641             hs.NewHandle(method->GetDeclaringClass()->GetClassLoader())));
642     if (verifier == nullptr) {
643       JVMTI_LOG(WARNING, jvmti_) << "Unable to extract verification information from "
644                                  << method->PrettyMethod() << " due to hard verification failures! "
645                                  << "How did this method even get loaded!";
646       return ERR(INTERNAL);
647     }
648     art::verifier::RegisterLine* line = verifier->GetRegLine(dex_pc);
649     if (line == nullptr) {
650       JVMTI_LOG(WARNING, jvmti_) << "Unable to determine register line at dex-pc " << dex_pc
651                                  << " for method " << method->PrettyMethod();
652       return ERR(OPAQUE_FRAME);
653     }
654     const art::verifier::RegType& rt = line->GetRegisterType(verifier.get(), slot_);
655     if (rt.IsUndefined()) {
656       return ERR(INVALID_SLOT);
657     } else if (rt.IsNonZeroReferenceTypes() || rt.IsNull()) {
658       *descriptor = (rt.HasClass() ? rt.GetDescriptor() : "Ljava/lang/Object;");
659       *type = VerifierPrimitiveType::kReferenceValue;
660       return OK;
661     } else if (rt.IsZero()) {
662       *descriptor = "I";
663       *type = VerifierPrimitiveType::kZeroValue;
664       return OK;
665     } else if (rt.IsCategory1Types()) {
666       *descriptor = "I";
667       *type = VerifierPrimitiveType::k32BitValue;
668       return OK;
669     } else if (rt.IsCategory2Types() && rt.IsLowHalf()) {
670       *descriptor = "J";
671       *type = VerifierPrimitiveType::k64BitValue;
672       return OK;
673     } else {
674       // The slot doesn't have a type. Must not be valid here.
675       return ERR(INVALID_SLOT);
676     }
677   }
678 
SquashType(SlotType t)679   constexpr VerifierPrimitiveType SquashType(SlotType t) {
680     if (std::holds_alternative<art::Primitive::Type>(t)) {
681       switch (std::get<art::Primitive::Type>(t)) {
682         // 32-bit primitives
683         case art::Primitive::kPrimByte:
684         case art::Primitive::kPrimChar:
685         case art::Primitive::kPrimInt:
686         case art::Primitive::kPrimShort:
687         case art::Primitive::kPrimBoolean:
688         case art::Primitive::kPrimFloat:
689           return VerifierPrimitiveType::k32BitValue;
690         // 64-bit primitives
691         case art::Primitive::kPrimLong:
692         case art::Primitive::kPrimDouble:
693           return VerifierPrimitiveType::k64BitValue;
694         case art::Primitive::kPrimNot:
695           return VerifierPrimitiveType::kReferenceValue;
696         case art::Primitive::kPrimVoid:
697           LOG(FATAL) << "Got kPrimVoid";
698           UNREACHABLE();
699       }
700     } else {
701       return std::get<VerifierPrimitiveType>(t);
702     }
703   }
704 
705   jvmtiEnv* jvmti_;
706   jvmtiError result_;
707   jint depth_;
708   jint slot_;
709 
710  private:
711   DISALLOW_COPY_AND_ASSIGN(CommonLocalVariableClosure);
712 };
713 
operator <<(std::ostream & os,CommonLocalVariableClosure::VerifierPrimitiveType state)714 std::ostream& operator<<(std::ostream& os,
715                          CommonLocalVariableClosure::VerifierPrimitiveType state) {
716   switch (state) {
717     case CommonLocalVariableClosure::VerifierPrimitiveType::k32BitValue:
718       return os << "32BitValue";
719     case CommonLocalVariableClosure::VerifierPrimitiveType::k64BitValue:
720       return os << "64BitValue";
721     case CommonLocalVariableClosure::VerifierPrimitiveType::kReferenceValue:
722       return os << "ReferenceValue";
723     case CommonLocalVariableClosure::VerifierPrimitiveType::kZeroValue:
724       return os << "ZeroValue";
725   }
726 }
727 
operator <<(std::ostream & os,CommonLocalVariableClosure::SlotType state)728 std::ostream& operator<<(std::ostream& os, CommonLocalVariableClosure::SlotType state) {
729   if (std::holds_alternative<art::Primitive::Type>(state)) {
730     return os << "Primitive::Type[" << std::get<art::Primitive::Type>(state) << "]";
731   } else {
732     return os << "VerifierPrimitiveType["
733               << std::get<CommonLocalVariableClosure::VerifierPrimitiveType>(state) << "]";
734   }
735 }
736 
GetSlotType(art::ArtMethod * method,uint32_t dex_pc,std::string * descriptor,SlotType * type)737 jvmtiError CommonLocalVariableClosure::GetSlotType(art::ArtMethod* method,
738                                                    uint32_t dex_pc,
739                                                    /*out*/ std::string* descriptor,
740                                                    /*out*/ SlotType* type) {
741   const art::DexFile* dex_file = method->GetDexFile();
742   if (dex_file == nullptr) {
743     return ERR(OPAQUE_FRAME);
744   }
745   art::CodeItemDebugInfoAccessor accessor(method->DexInstructionDebugInfo());
746   if (!accessor.HasCodeItem()) {
747     return ERR(OPAQUE_FRAME);
748   }
749   bool found = false;
750   *type = art::Primitive::kPrimVoid;
751   descriptor->clear();
752   auto visitor = [&](const art::DexFile::LocalInfo& entry) {
753     if (!found && entry.start_address_ <= dex_pc && entry.end_address_ > dex_pc &&
754         entry.reg_ == slot_) {
755       found = true;
756       *type = art::Primitive::GetType(entry.descriptor_[0]);
757       *descriptor = entry.descriptor_;
758     }
759   };
760   if (!accessor.DecodeDebugLocalInfo(method->IsStatic(), method->GetDexMethodIndex(), visitor) ||
761       !found) {
762     // Something went wrong with decoding the debug information. It might as well not be there.
763     // Try to find the type with the verifier.
764     // TODO This is very slow.
765     return InferSlotTypeFromVerifier(method, dex_pc, descriptor, type);
766   } else if (art::kIsDebugBuild) {
767     std::string type_unused;
768     SlotType verifier_type{ art::Primitive::kPrimVoid };
769     DCHECK_EQ(InferSlotTypeFromVerifier(method, dex_pc, &type_unused, &verifier_type), OK)
770         << method->PrettyMethod() << " failed to verify!";
771     if (*type == SlotType{ art::Primitive::kPrimNot }) {
772       // We cannot distinguish between a constant 0 and a null reference so we return that it is a
773       // 32bit value (Due to the way references are read by the interpreter this is safe even if
774       // it's modified, the value will remain null). This is not ideal since it prevents modifying
775       // locals in some circumstances but generally is not a big deal (since one can just modify it
776       // later once it's been determined to be a reference by a later instruction).
777       DCHECK(verifier_type == SlotType { VerifierPrimitiveType::kZeroValue } ||
778              verifier_type == SlotType { VerifierPrimitiveType::kReferenceValue })
779           << "Verifier disagrees on type of slot! debug: " << *type
780           << " verifier: " << verifier_type;
781     } else if (verifier_type == SlotType { VerifierPrimitiveType::kZeroValue }) {
782       DCHECK(VerifierPrimitiveType::k32BitValue == SquashType(*type) ||
783              VerifierPrimitiveType::kReferenceValue == SquashType(*type))
784           << "Verifier disagrees on type of slot! debug: " << *type
785           << " verifier: " << verifier_type;
786     } else {
787       DCHECK_EQ(SquashType(verifier_type), SquashType(*type))
788           << "Verifier disagrees on type of slot! debug: " << *type
789           << " verifier: " << verifier_type;
790     }
791   }
792   return OK;
793 }
794 
795 class GetLocalVariableClosure : public CommonLocalVariableClosure {
796  public:
GetLocalVariableClosure(jvmtiEnv * jvmti,jint depth,jint slot,art::Primitive::Type type,jvalue * val)797   GetLocalVariableClosure(jvmtiEnv* jvmti,
798                           jint depth,
799                           jint slot,
800                           art::Primitive::Type type,
801                           jvalue* val)
802       : CommonLocalVariableClosure(jvmti, depth, slot),
803         type_(type),
804         val_(val),
805         obj_val_(nullptr) {}
806 
GetResult()807   jvmtiError GetResult() override REQUIRES_SHARED(art::Locks::mutator_lock_) {
808     if (result_ == OK && type_ == art::Primitive::kPrimNot) {
809       if (obj_val_ == nullptr) {
810         val_->l = nullptr;
811       } else {
812         art::JNIEnvExt* jni = art::Thread::Current()->GetJniEnv();
813         val_->l = static_cast<JNIEnv*>(jni)->NewLocalRef(obj_val_);
814         jni->DeleteGlobalRef(obj_val_);
815         obj_val_ = nullptr;
816       }
817     }
818     return CommonLocalVariableClosure::GetResult();
819   }
820 
821  protected:
822   jvmtiError
GetTypeError(art::ArtMethod * method,SlotType slot_type,const std::string & descriptor)823   GetTypeError(art::ArtMethod* method, SlotType slot_type, const std::string& descriptor) override
824       REQUIRES_SHARED(art::Locks::mutator_lock_) {
825     jvmtiError res = GetTypeErrorInner(method, slot_type, descriptor);
826     if (res == ERR(TYPE_MISMATCH)) {
827       JVMTI_LOG(INFO, jvmti_) << "Unable to Get local variable in slot " << slot_ << ". Expected"
828                               << " slot to be of type compatible with " << SlotType { type_ }
829                               << " but slot is " << slot_type;
830     } else if (res != OK) {
831       JVMTI_LOG(INFO, jvmti_) << "Unable to get local variable in slot " << slot_ << ".";
832     }
833     return res;
834   }
835 
GetTypeErrorInner(art::ArtMethod * method ATTRIBUTE_UNUSED,SlotType slot_type,const std::string & descriptor ATTRIBUTE_UNUSED)836   jvmtiError GetTypeErrorInner(art::ArtMethod* method ATTRIBUTE_UNUSED,
837                                SlotType slot_type,
838                                const std::string& descriptor ATTRIBUTE_UNUSED)
839       REQUIRES_SHARED(art::Locks::mutator_lock_) {
840     switch (type_) {
841       case art::Primitive::kPrimFloat:
842       case art::Primitive::kPrimInt: {
843         if (std::holds_alternative<VerifierPrimitiveType>(slot_type)) {
844           return (slot_type == SlotType { VerifierPrimitiveType::k32BitValue } ||
845                   slot_type == SlotType { VerifierPrimitiveType::kZeroValue })
846                      ? OK
847                      : ERR(TYPE_MISMATCH);
848         } else if (type_ == art::Primitive::kPrimFloat ||
849                    slot_type == SlotType { art::Primitive::kPrimFloat }) {
850           // Check that we are actually a float.
851           return (SlotType { type_ } == slot_type) ? OK : ERR(TYPE_MISMATCH);
852         } else {
853           // Some smaller int type.
854           return SquashType(slot_type) == SquashType(SlotType { type_ }) ? OK : ERR(TYPE_MISMATCH);
855         }
856       }
857       case art::Primitive::kPrimLong:
858       case art::Primitive::kPrimDouble: {
859         // todo
860         if (std::holds_alternative<VerifierPrimitiveType>(slot_type)) {
861           return (slot_type == SlotType { VerifierPrimitiveType::k64BitValue })
862                      ? OK
863                      : ERR(TYPE_MISMATCH);
864         } else {
865           return slot_type == SlotType { type_ } ? OK : ERR(TYPE_MISMATCH);
866         }
867       }
868       case art::Primitive::kPrimNot:
869         return (SquashType(slot_type) == VerifierPrimitiveType::kReferenceValue ||
870                 SquashType(slot_type) == VerifierPrimitiveType::kZeroValue)
871                    ? OK
872                    : ERR(TYPE_MISMATCH);
873       case art::Primitive::kPrimShort:
874       case art::Primitive::kPrimChar:
875       case art::Primitive::kPrimByte:
876       case art::Primitive::kPrimBoolean:
877       case art::Primitive::kPrimVoid:
878         LOG(FATAL) << "Unexpected primitive type " << slot_type;
879         UNREACHABLE();
880     }
881   }
882 
Execute(art::ArtMethod * method,art::StackVisitor & visitor)883   jvmtiError Execute(art::ArtMethod* method, art::StackVisitor& visitor)
884       override REQUIRES_SHARED(art::Locks::mutator_lock_) {
885     switch (type_) {
886       case art::Primitive::kPrimNot: {
887         uint32_t ptr_val;
888         if (!visitor.GetVReg(method,
889                              static_cast<uint16_t>(slot_),
890                              art::kReferenceVReg,
891                              &ptr_val)) {
892           return ERR(OPAQUE_FRAME);
893         }
894         art::ObjPtr<art::mirror::Object> obj(reinterpret_cast<art::mirror::Object*>(ptr_val));
895         obj_val_ = art::Runtime::Current()->GetJavaVM()->AddGlobalRef(art::Thread::Current(), obj);
896         break;
897       }
898       case art::Primitive::kPrimInt:
899       case art::Primitive::kPrimFloat: {
900         if (!visitor.GetVReg(method,
901                              static_cast<uint16_t>(slot_),
902                              type_ == art::Primitive::kPrimFloat ? art::kFloatVReg : art::kIntVReg,
903                              reinterpret_cast<uint32_t*>(&val_->i))) {
904           return ERR(OPAQUE_FRAME);
905         }
906         break;
907       }
908       case art::Primitive::kPrimDouble:
909       case art::Primitive::kPrimLong: {
910         auto lo_type = type_ == art::Primitive::kPrimLong ? art::kLongLoVReg : art::kDoubleLoVReg;
911         auto high_type = type_ == art::Primitive::kPrimLong ? art::kLongHiVReg : art::kDoubleHiVReg;
912         if (!visitor.GetVRegPair(method,
913                                  static_cast<uint16_t>(slot_),
914                                  lo_type,
915                                  high_type,
916                                  reinterpret_cast<uint64_t*>(&val_->j))) {
917           return ERR(OPAQUE_FRAME);
918         }
919         break;
920       }
921       default: {
922         LOG(FATAL) << "unexpected register type " << type_;
923         UNREACHABLE();
924       }
925     }
926     return OK;
927   }
928 
929  private:
930   art::Primitive::Type type_;
931   jvalue* val_;
932   // A global reference to the return value. We use the global reference to safely transfer the
933   // value between threads.
934   jobject obj_val_;
935 };
936 
GetLocalVariableGeneric(jvmtiEnv * env,jthread thread,jint depth,jint slot,art::Primitive::Type type,jvalue * val)937 jvmtiError MethodUtil::GetLocalVariableGeneric(jvmtiEnv* env,
938                                                jthread thread,
939                                                jint depth,
940                                                jint slot,
941                                                art::Primitive::Type type,
942                                                jvalue* val) {
943   if (depth < 0) {
944     return ERR(ILLEGAL_ARGUMENT);
945   }
946   art::Thread* self = art::Thread::Current();
947   art::ScopedObjectAccess soa(self);
948   art::Locks::thread_list_lock_->ExclusiveLock(self);
949   art::Thread* target = nullptr;
950   jvmtiError err = ERR(INTERNAL);
951   if (!ThreadUtil::GetAliveNativeThread(thread, soa, &target, &err)) {
952     art::Locks::thread_list_lock_->ExclusiveUnlock(self);
953     return err;
954   }
955   GetLocalVariableClosure c(env, depth, slot, type, val);
956   // RequestSynchronousCheckpoint releases the thread_list_lock_ as a part of its execution.
957   if (!target->RequestSynchronousCheckpoint(&c)) {
958     return ERR(THREAD_NOT_ALIVE);
959   } else {
960     return c.GetResult();
961   }
962 }
963 
964 class SetLocalVariableClosure : public CommonLocalVariableClosure {
965  public:
SetLocalVariableClosure(jvmtiEnv * jvmti,art::Thread * caller,jint depth,jint slot,art::Primitive::Type type,jvalue val)966   SetLocalVariableClosure(jvmtiEnv* jvmti,
967                           art::Thread* caller,
968                           jint depth,
969                           jint slot,
970                           art::Primitive::Type type,
971                           jvalue val)
972       : CommonLocalVariableClosure(jvmti, depth, slot), caller_(caller), type_(type), val_(val) {}
973 
974  protected:
975   jvmtiError
GetTypeError(art::ArtMethod * method,SlotType slot_type,const std::string & descriptor)976   GetTypeError(art::ArtMethod* method, SlotType slot_type, const std::string& descriptor) override
977       REQUIRES_SHARED(art::Locks::mutator_lock_) {
978     jvmtiError res = GetTypeErrorInner(method, slot_type, descriptor);
979     if (res != OK) {
980       if (res == ERR(TYPE_MISMATCH)) {
981         std::ostringstream desc_exp;
982         std::ostringstream desc_set;
983         if (type_ == art::Primitive::kPrimNot) {
984           desc_exp << " (type: " << descriptor << ")";
985           art::ObjPtr<art::mirror::Object> new_val(art::Thread::Current()->DecodeJObject(val_.l));
986           desc_set << " (type: "
987                   << (new_val.IsNull() ? "NULL" : new_val->GetClass()->PrettyDescriptor()) << ")";
988         }
989         JVMTI_LOG(INFO, jvmti_) << "Unable to Set local variable in slot " << slot_ << ". Expected"
990                                 << " slot to be of type compatible with " << SlotType{ type_ }
991                                 << desc_set.str() << " but slot is " << slot_type << desc_exp.str();
992       } else {
993         JVMTI_LOG(INFO, jvmti_) << "Unable to set local variable in slot " << slot_ << ". "
994                                 << err_.str();
995       }
996     }
997     return res;
998   }
999 
1000   jvmtiError
GetTypeErrorInner(art::ArtMethod * method,SlotType slot_type,const std::string & descriptor)1001   GetTypeErrorInner(art::ArtMethod* method, SlotType slot_type, const std::string& descriptor)
1002       REQUIRES_SHARED(art::Locks::mutator_lock_) {
1003     switch (SquashType(SlotType{ type_ })) {
1004       case VerifierPrimitiveType::k32BitValue: {
1005         if (slot_type == SlotType{ VerifierPrimitiveType::kZeroValue }) {
1006           if (val_.i == 0) {
1007             return OK;
1008           } else {
1009             err_ << "Cannot determine if slot " << slot_ << " is a null reference or 32bit "
1010                  << "constant. Cannot allow writing to slot.";
1011             return ERR(INTERNAL);
1012           }
1013         } else if (SquashType(slot_type) != VerifierPrimitiveType::k32BitValue) {
1014           return ERR(TYPE_MISMATCH);
1015         } else if (slot_type == SlotType { VerifierPrimitiveType::k32BitValue } ||
1016                    slot_type == SlotType { type_ }) {
1017           return OK;
1018         } else if (type_ == art::Primitive::kPrimFloat ||
1019                    slot_type == SlotType { art::Primitive::kPrimFloat }) {
1020           // we should have hit the get == type_ above
1021           return ERR(TYPE_MISMATCH);
1022         } else {
1023           // Some smaller type then int.
1024           return OK;
1025         }
1026       }
1027       case VerifierPrimitiveType::k64BitValue: {
1028         if (slot_type == SlotType { VerifierPrimitiveType::k64BitValue } ||
1029             slot_type == SlotType { type_ }) {
1030           return OK;
1031         } else {
1032           return ERR(TYPE_MISMATCH);
1033         }
1034       }
1035       case VerifierPrimitiveType::kReferenceValue: {
1036         if (SquashType(slot_type) != VerifierPrimitiveType::kReferenceValue &&
1037             SquashType(slot_type) != VerifierPrimitiveType::kZeroValue) {
1038           return ERR(TYPE_MISMATCH);
1039         } else if (val_.l == nullptr) {
1040           return OK;
1041         } else if (slot_type == SlotType { VerifierPrimitiveType::kZeroValue }) {
1042           err_ << "Cannot determine if slot " << slot_ << " is a null "
1043                << "reference or 32bit constant. Cannot allow writing to slot.";
1044           return ERR(INTERNAL);
1045         } else {
1046           art::ClassLinker* cl = art::Runtime::Current()->GetClassLinker();
1047           art::ObjPtr<art::mirror::Class> set_class = caller_->DecodeJObject(val_.l)->GetClass();
1048           art::ObjPtr<art::mirror::ClassLoader> loader =
1049               method->GetDeclaringClass()->GetClassLoader();
1050           art::ObjPtr<art::mirror::Class> slot_class =
1051               cl->LookupClass(caller_, descriptor.c_str(), loader);
1052           DCHECK(!slot_class.IsNull()) << descriptor << " slot: " << slot_type;
1053           return slot_class->IsAssignableFrom(set_class) ? OK : ERR(TYPE_MISMATCH);
1054         }
1055       }
1056       case VerifierPrimitiveType::kZeroValue: {
1057         LOG(FATAL) << "Illegal result from SquashType of art::Primitive::Type " << type_;
1058         UNREACHABLE();
1059       }
1060     }
1061   }
1062 
Execute(art::ArtMethod * method,art::StackVisitor & visitor)1063   jvmtiError Execute(art::ArtMethod* method, art::StackVisitor& visitor)
1064       override REQUIRES_SHARED(art::Locks::mutator_lock_) {
1065     switch (type_) {
1066       case art::Primitive::kPrimNot: {
1067         if (!visitor.SetVRegReference(method,
1068                                       static_cast<uint16_t>(slot_),
1069                                       caller_->DecodeJObject(val_.l))) {
1070           return ERR(OPAQUE_FRAME);
1071         }
1072         break;
1073       }
1074       case art::Primitive::kPrimInt:
1075       case art::Primitive::kPrimFloat: {
1076         if (!visitor.SetVReg(method,
1077                              static_cast<uint16_t>(slot_),
1078                              static_cast<uint32_t>(val_.i),
1079                              type_ == art::Primitive::kPrimFloat ? art::kFloatVReg
1080                                                                  : art::kIntVReg)) {
1081           return ERR(OPAQUE_FRAME);
1082         }
1083         break;
1084       }
1085       case art::Primitive::kPrimDouble:
1086       case art::Primitive::kPrimLong: {
1087         auto lo_type = type_ == art::Primitive::kPrimLong ? art::kLongLoVReg : art::kDoubleLoVReg;
1088         auto high_type = type_ == art::Primitive::kPrimLong ? art::kLongHiVReg : art::kDoubleHiVReg;
1089         if (!visitor.SetVRegPair(method,
1090                                  static_cast<uint16_t>(slot_),
1091                                  static_cast<uint64_t>(val_.j),
1092                                  lo_type,
1093                                  high_type)) {
1094           return ERR(OPAQUE_FRAME);
1095         }
1096         break;
1097       }
1098       default: {
1099         LOG(FATAL) << "unexpected register type " << type_;
1100         UNREACHABLE();
1101       }
1102     }
1103     return OK;
1104   }
1105 
1106  private:
1107   art::Thread* caller_;
1108   art::Primitive::Type type_;
1109   jvalue val_;
1110   std::ostringstream err_;
1111 };
1112 
SetLocalVariableGeneric(jvmtiEnv * env,jthread thread,jint depth,jint slot,art::Primitive::Type type,jvalue val)1113 jvmtiError MethodUtil::SetLocalVariableGeneric(jvmtiEnv* env,
1114                                                jthread thread,
1115                                                jint depth,
1116                                                jint slot,
1117                                                art::Primitive::Type type,
1118                                                jvalue val) {
1119   if (depth < 0) {
1120     return ERR(ILLEGAL_ARGUMENT);
1121   }
1122   // Make sure that we know not to do any OSR anymore.
1123   // TODO We should really keep track of this at the Frame granularity.
1124   DeoptManager::Get()->SetLocalsUpdated();
1125   art::Thread* self = art::Thread::Current();
1126   art::ScopedObjectAccess soa(self);
1127   art::Locks::thread_list_lock_->ExclusiveLock(self);
1128   art::Thread* target = nullptr;
1129   jvmtiError err = ERR(INTERNAL);
1130   if (!ThreadUtil::GetAliveNativeThread(thread, soa, &target, &err)) {
1131     art::Locks::thread_list_lock_->ExclusiveUnlock(self);
1132     return err;
1133   }
1134   SetLocalVariableClosure c(env, self, depth, slot, type, val);
1135   // RequestSynchronousCheckpoint releases the thread_list_lock_ as a part of its execution.
1136   if (!target->RequestSynchronousCheckpoint(&c)) {
1137     return ERR(THREAD_NOT_ALIVE);
1138   } else {
1139     return c.GetResult();
1140   }
1141 }
1142 
1143 class GetLocalInstanceClosure : public art::Closure {
1144  public:
GetLocalInstanceClosure(jint depth)1145   explicit GetLocalInstanceClosure(jint depth)
1146       : result_(ERR(INTERNAL)),
1147         depth_(depth),
1148         val_(nullptr) {}
1149 
Run(art::Thread * self)1150   void Run(art::Thread* self) override REQUIRES(art::Locks::mutator_lock_) {
1151     art::ScopedAssertNoThreadSuspension sants("GetLocalInstanceClosure::Run");
1152     art::Locks::mutator_lock_->AssertSharedHeld(art::Thread::Current());
1153     std::unique_ptr<art::Context> context(art::Context::Create());
1154     FindFrameAtDepthVisitor visitor(self, context.get(), depth_);
1155     visitor.WalkStack();
1156     if (!visitor.FoundFrame()) {
1157       // Must have been a bad depth.
1158       result_ = ERR(NO_MORE_FRAMES);
1159       return;
1160     }
1161     result_ = OK;
1162     val_ = art::GcRoot<art::mirror::Object>(visitor.GetThisObject());
1163   }
1164 
GetResult(jobject * data_out)1165   jvmtiError GetResult(jobject* data_out) REQUIRES_SHARED(art::Locks::mutator_lock_) {
1166     if (result_ == OK) {
1167       *data_out = val_.IsNull()
1168           ? nullptr
1169           : art::Thread::Current()->GetJniEnv()->AddLocalReference<jobject>(val_.Read());
1170     }
1171     return result_;
1172   }
1173 
1174  private:
1175   jvmtiError result_;
1176   jint depth_;
1177   art::GcRoot<art::mirror::Object> val_;
1178 };
1179 
GetLocalInstance(jvmtiEnv * env ATTRIBUTE_UNUSED,jthread thread,jint depth,jobject * data)1180 jvmtiError MethodUtil::GetLocalInstance(jvmtiEnv* env ATTRIBUTE_UNUSED,
1181                                         jthread thread,
1182                                         jint depth,
1183                                         jobject* data) {
1184   if (depth < 0) {
1185     return ERR(ILLEGAL_ARGUMENT);
1186   }
1187   art::Thread* self = art::Thread::Current();
1188   art::ScopedObjectAccess soa(self);
1189   art::Locks::thread_list_lock_->ExclusiveLock(self);
1190   art::Thread* target = nullptr;
1191   jvmtiError err = ERR(INTERNAL);
1192   if (!ThreadUtil::GetAliveNativeThread(thread, soa, &target, &err)) {
1193     art::Locks::thread_list_lock_->ExclusiveUnlock(self);
1194     return err;
1195   }
1196   art::ScopedAssertNoThreadSuspension sants("Performing GetLocalInstance");
1197   GetLocalInstanceClosure c(depth);
1198   // RequestSynchronousCheckpoint releases the thread_list_lock_ as a part of its execution.  We
1199   // need to avoid suspending as we wait for the checkpoint to occur since we are (potentially)
1200   // transfering a GcRoot across threads.
1201   if (!target->RequestSynchronousCheckpoint(&c, art::ThreadState::kRunnable)) {
1202     return ERR(THREAD_NOT_ALIVE);
1203   } else {
1204     return c.GetResult(data);
1205   }
1206 }
1207 
1208 #define FOR_JVMTI_JVALUE_TYPES(fn) \
1209     fn(jint, art::Primitive::kPrimInt, i) \
1210     fn(jlong, art::Primitive::kPrimLong, j) \
1211     fn(jfloat, art::Primitive::kPrimFloat, f) \
1212     fn(jdouble, art::Primitive::kPrimDouble, d) \
1213     fn(jobject, art::Primitive::kPrimNot, l)
1214 
1215 namespace impl {
1216 
1217 template<typename T> void WriteJvalue(T, jvalue*);
1218 template<typename T> void ReadJvalue(jvalue, T*);
1219 template<typename T> art::Primitive::Type GetJNIType();
1220 
1221 #define JNI_TYPE_CHAR(type, prim, id) \
1222 template<> art::Primitive::Type GetJNIType<type>() { \
1223   return prim; \
1224 }
1225 
1226 FOR_JVMTI_JVALUE_TYPES(JNI_TYPE_CHAR);
1227 
1228 #undef JNI_TYPE_CHAR
1229 
1230 #define RW_JVALUE(srctype, prim, id) \
1231     template<> void ReadJvalue<srctype>(jvalue in, std::add_pointer<srctype>::type out) { \
1232       *out = in.id; \
1233     } \
1234     template<> void WriteJvalue<srctype>(srctype in, jvalue* out) { \
1235       out->id = in; \
1236     }
1237 
1238 FOR_JVMTI_JVALUE_TYPES(RW_JVALUE);
1239 
1240 #undef RW_JVALUE
1241 
1242 }  // namespace impl
1243 
1244 template<typename T>
SetLocalVariable(jvmtiEnv * env,jthread thread,jint depth,jint slot,T data)1245 jvmtiError MethodUtil::SetLocalVariable(jvmtiEnv* env,
1246                                         jthread thread,
1247                                         jint depth,
1248                                         jint slot,
1249                                         T data) {
1250   jvalue v = {.j = 0};
1251   art::Primitive::Type type = impl::GetJNIType<T>();
1252   impl::WriteJvalue(data, &v);
1253   return SetLocalVariableGeneric(env, thread, depth, slot, type, v);
1254 }
1255 
1256 template<typename T>
GetLocalVariable(jvmtiEnv * env,jthread thread,jint depth,jint slot,T * data)1257 jvmtiError MethodUtil::GetLocalVariable(jvmtiEnv* env,
1258                                         jthread thread,
1259                                         jint depth,
1260                                         jint slot,
1261                                         T* data) {
1262   if (data == nullptr) {
1263     return ERR(NULL_POINTER);
1264   }
1265   jvalue v = {.j = 0};
1266   art::Primitive::Type type = impl::GetJNIType<T>();
1267   jvmtiError err = GetLocalVariableGeneric(env, thread, depth, slot, type, &v);
1268   if (err != OK) {
1269     return err;
1270   } else {
1271     impl::ReadJvalue(v, data);
1272     return OK;
1273   }
1274 }
1275 
1276 #define GET_SET_LV(srctype, prim, id) \
1277     template jvmtiError MethodUtil::GetLocalVariable<srctype>(jvmtiEnv*, \
1278                                                               jthread, \
1279                                                               jint, \
1280                                                               jint, \
1281                                                               std::add_pointer<srctype>::type); \
1282     template jvmtiError MethodUtil::SetLocalVariable<srctype>(jvmtiEnv*, \
1283                                                               jthread, \
1284                                                               jint, \
1285                                                               jint, \
1286                                                               srctype);
1287 
1288 FOR_JVMTI_JVALUE_TYPES(GET_SET_LV);
1289 
1290 #undef GET_SET_LV
1291 
1292 #undef FOR_JVMTI_JVALUE_TYPES
1293 
1294 }  // namespace openjdkjvmti
1295