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_class.h"
33 
34 #include "android-base/stringprintf.h"
35 
36 #include <mutex>
37 #include <string_view>
38 #include <unordered_set>
39 
40 #include "art_jvmti.h"
41 #include "base/array_ref.h"
42 #include "base/logging.h"
43 #include "base/macros.h"
44 #include "base/utils.h"
45 #include "class_linker.h"
46 #include "class_loader_utils.h"
47 #include "class_table-inl.h"
48 #include "common_throws.h"
49 #include "dex/art_dex_file_loader.h"
50 #include "dex/dex_file_annotations.h"
51 #include "dex/dex_file_loader.h"
52 #include "dex/primitive.h"
53 #include "events-inl.h"
54 #include "fixed_up_dex_file.h"
55 #include "gc/heap-visit-objects-inl.h"
56 #include "gc/heap.h"
57 #include "gc_root.h"
58 #include "handle.h"
59 #include "jni/jni_env_ext-inl.h"
60 #include "jni/jni_internal.h"
61 #include "mirror/array-alloc-inl.h"
62 #include "mirror/array-inl.h"
63 #include "mirror/class-inl.h"
64 #include "mirror/class_ext.h"
65 #include "mirror/object-inl.h"
66 #include "mirror/object-refvisitor-inl.h"
67 #include "mirror/object_array-inl.h"
68 #include "mirror/object_reference.h"
69 #include "mirror/reference-inl.h"
70 #include "nativehelper/scoped_local_ref.h"
71 #include "reflection.h"
72 #include "runtime.h"
73 #include "runtime_callbacks.h"
74 #include "scoped_thread_state_change-inl.h"
75 #include "thread-current-inl.h"
76 #include "thread_list.h"
77 #include "ti_class_definition.h"
78 #include "ti_class_loader-inl.h"
79 #include "ti_logging.h"
80 #include "ti_phase.h"
81 #include "ti_redefine.h"
82 #include "transform.h"
83 #include "well_known_classes.h"
84 
85 namespace openjdkjvmti {
86 
87 using android::base::StringPrintf;
88 
MakeSingleDexFile(art::Thread * self,const char * descriptor,const std::string & orig_location,jint final_len,const unsigned char * final_dex_data)89 static std::unique_ptr<const art::DexFile> MakeSingleDexFile(art::Thread* self,
90                                                              const char* descriptor,
91                                                              const std::string& orig_location,
92                                                              jint final_len,
93                                                              const unsigned char* final_dex_data)
94       REQUIRES_SHARED(art::Locks::mutator_lock_) {
95   // Make the mmap
96   std::string error_msg;
97   art::ArrayRef<const unsigned char> final_data(final_dex_data, final_len);
98   art::MemMap map = Redefiner::MoveDataToMemMap(orig_location, final_data, &error_msg);
99   if (!map.IsValid()) {
100     LOG(WARNING) << "Unable to allocate mmap for redefined dex file! Error was: " << error_msg;
101     self->ThrowOutOfMemoryError(StringPrintf(
102         "Unable to allocate dex file for transformation of %s", descriptor).c_str());
103     return nullptr;
104   }
105 
106   // Make a dex-file
107   if (map.Size() < sizeof(art::DexFile::Header)) {
108     LOG(WARNING) << "Could not read dex file header because dex_data was too short";
109     art::ThrowClassFormatError(nullptr,
110                                "Unable to read transformed dex file of %s",
111                                descriptor);
112     return nullptr;
113   }
114   uint32_t checksum = reinterpret_cast<const art::DexFile::Header*>(map.Begin())->checksum_;
115   std::string map_name = map.GetName();
116   const art::ArtDexFileLoader dex_file_loader;
117   std::unique_ptr<const art::DexFile> dex_file(dex_file_loader.Open(map_name,
118                                                                     checksum,
119                                                                     std::move(map),
120                                                                     /*verify=*/true,
121                                                                     /*verify_checksum=*/true,
122                                                                     &error_msg));
123   if (dex_file.get() == nullptr) {
124     LOG(WARNING) << "Unable to load modified dex file for " << descriptor << ": " << error_msg;
125     art::ThrowClassFormatError(nullptr,
126                                "Unable to read transformed dex file of %s because %s",
127                                descriptor,
128                                error_msg.c_str());
129     return nullptr;
130   }
131   if (dex_file->NumClassDefs() != 1) {
132     LOG(WARNING) << "Dex file contains more than 1 class_def. Ignoring.";
133     // TODO Throw some other sort of error here maybe?
134     art::ThrowClassFormatError(
135         nullptr,
136         "Unable to use transformed dex file of %s because it contained too many classes",
137         descriptor);
138     return nullptr;
139   }
140   return dex_file;
141 }
142 
143 // A deleter that acts like the jvmtiEnv->Deallocate so that asan does not get tripped up.
144 // TODO We should everything use the actual jvmtiEnv->Allocate/Deallocate functions once we can
145 // figure out which env to use.
146 template <typename T>
147 class FakeJvmtiDeleter {
148  public:
FakeJvmtiDeleter()149   FakeJvmtiDeleter() {}
150 
151   FakeJvmtiDeleter(FakeJvmtiDeleter&) = default;
152   FakeJvmtiDeleter(FakeJvmtiDeleter&&) noexcept = default;
153   FakeJvmtiDeleter& operator=(const FakeJvmtiDeleter&) = default;
154 
operator ()(const U * ptr) const155   template <typename U> void operator()(const U* ptr) const {
156     if (ptr != nullptr) {
157       free(const_cast<U*>(ptr));
158     }
159   }
160 };
161 
162 struct ClassCallback : public art::ClassLoadCallback {
ClassPreDefineopenjdkjvmti::ClassCallback163   void ClassPreDefine(const char* descriptor,
164                       art::Handle<art::mirror::Class> klass,
165                       art::Handle<art::mirror::ClassLoader> class_loader,
166                       const art::DexFile& initial_dex_file,
167                       const art::dex::ClassDef& initial_class_def ATTRIBUTE_UNUSED,
168                       /*out*/art::DexFile const** final_dex_file,
169                       /*out*/art::dex::ClassDef const** final_class_def)
170       override REQUIRES_SHARED(art::Locks::mutator_lock_) {
171     bool is_enabled =
172         event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kClassFileLoadHookRetransformable) ||
173         event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kClassFileLoadHookNonRetransformable);
174     if (!is_enabled) {
175       return;
176     }
177     if (descriptor[0] != 'L') {
178       // It is a primitive or array. Just return
179       return;
180     }
181     jvmtiPhase phase = PhaseUtil::GetPhaseUnchecked();
182     if (UNLIKELY(phase != JVMTI_PHASE_START && phase != JVMTI_PHASE_LIVE)) {
183       // We want to wait until we are at least in the START phase so that all WellKnownClasses and
184       // mirror classes have been initialized and loaded. The runtime relies on these classes having
185       // specific fields and methods present. Since PreDefine hooks don't need to abide by this
186       // restriction we will simply not send the event for these classes.
187       LOG(WARNING) << "Ignoring load of class <" << descriptor << "> as it is being loaded during "
188                    << "runtime initialization.";
189       return;
190     }
191 
192     art::Thread* self = art::Thread::Current();
193     ArtClassDefinition def;
194     def.InitFirstLoad(descriptor, class_loader, initial_dex_file);
195 
196     // Call all non-retransformable agents.
197     Transformer::TransformSingleClassDirect<ArtJvmtiEvent::kClassFileLoadHookNonRetransformable>(
198         event_handler, self, &def);
199 
200     std::vector<unsigned char> post_non_retransform;
201     if (def.IsModified()) {
202       // Copy the dex data after the non-retransformable events.
203       post_non_retransform.resize(def.GetDexData().size());
204       memcpy(post_non_retransform.data(), def.GetDexData().data(), post_non_retransform.size());
205     }
206 
207     // Call all structural transformation agents.
208     Transformer::TransformSingleClassDirect<ArtJvmtiEvent::kStructuralDexFileLoadHook>(
209         event_handler, self, &def);
210     // Call all retransformable agents.
211     Transformer::TransformSingleClassDirect<ArtJvmtiEvent::kClassFileLoadHookRetransformable>(
212         event_handler, self, &def);
213 
214     if (def.IsModified()) {
215       VLOG(class_linker) << "Changing class " << descriptor;
216       art::StackHandleScope<2> hs(self);
217       // Save the results of all the non-retransformable agents.
218       // First allocate the ClassExt
219       art::Handle<art::mirror::ClassExt> ext =
220           hs.NewHandle(art::mirror::Class::EnsureExtDataPresent(klass, self));
221       // Make sure we have a ClassExt. This is fine even though we are a temporary since it will
222       // get copied.
223       if (ext.IsNull()) {
224         // We will just return failure if we fail to allocate
225         LOG(WARNING) << "Could not allocate ext-data for class '" << descriptor << "'. "
226                      << "Aborting transformation since we will be unable to store it.";
227         self->AssertPendingOOMException();
228         return;
229       }
230 
231       // Allocate the byte array to store the dex file bytes in.
232       art::MutableHandle<art::mirror::Object> arr(hs.NewHandle<art::mirror::Object>(nullptr));
233       if (post_non_retransform.empty() && strcmp(descriptor, "Ljava/lang/Long;") != 0) {
234         // we didn't have any non-retransformable agents. We can just cache a pointer to the
235         // initial_dex_file. It will be kept live by the class_loader.
236         jlong dex_ptr = reinterpret_cast<uintptr_t>(&initial_dex_file);
237         art::JValue val;
238         val.SetJ(dex_ptr);
239         arr.Assign(art::BoxPrimitive(art::Primitive::kPrimLong, val));
240       } else {
241         arr.Assign(art::mirror::ByteArray::AllocateAndFill(
242             self,
243             reinterpret_cast<const signed char*>(post_non_retransform.data()),
244             post_non_retransform.size()));
245       }
246       if (arr.IsNull()) {
247         LOG(WARNING) << "Unable to allocate memory for initial dex-file. Aborting transformation";
248         self->AssertPendingOOMException();
249         return;
250       }
251 
252       std::unique_ptr<const art::DexFile> dex_file(MakeSingleDexFile(self,
253                                                                      descriptor,
254                                                                      initial_dex_file.GetLocation(),
255                                                                      def.GetDexData().size(),
256                                                                      def.GetDexData().data()));
257       if (dex_file.get() == nullptr) {
258         return;
259       }
260 
261       // TODO Check Redefined dex file for all invariants.
262       LOG(WARNING) << "Dex file created by class-definition time transformation of "
263                    << descriptor << " is not checked for all retransformation invariants.";
264 
265       if (!ClassLoaderHelper::AddToClassLoader(self, class_loader, dex_file.get())) {
266         LOG(ERROR) << "Unable to add " << descriptor << " to class loader!";
267         return;
268       }
269 
270       // Actually set the ClassExt's original bytes once we have actually succeeded.
271       ext->SetOriginalDexFile(arr.Get());
272       // Set the return values
273       *final_class_def = &dex_file->GetClassDef(0);
274       *final_dex_file = dex_file.release();
275     }
276   }
277 
ClassLoadopenjdkjvmti::ClassCallback278   void ClassLoad(art::Handle<art::mirror::Class> klass) override
279       REQUIRES_SHARED(art::Locks::mutator_lock_) {
280     if (event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kClassLoad)) {
281       art::Thread* thread = art::Thread::Current();
282       ScopedLocalRef<jclass> jklass(thread->GetJniEnv(),
283                                     thread->GetJniEnv()->AddLocalReference<jclass>(klass.Get()));
284       art::ObjPtr<art::mirror::Object> peer(thread->GetPeer());
285       ScopedLocalRef<jthread> thread_jni(
286           thread->GetJniEnv(),
287           peer.IsNull() ? nullptr : thread->GetJniEnv()->AddLocalReference<jthread>(peer));
288       event_handler->DispatchEvent<ArtJvmtiEvent::kClassLoad>(
289           thread,
290           static_cast<JNIEnv*>(thread->GetJniEnv()),
291           thread_jni.get(),
292           jklass.get());
293       if (klass->IsTemp()) {
294         AddTempClass(thread, jklass.get());
295       }
296     }
297   }
298 
ClassPrepareopenjdkjvmti::ClassCallback299   void ClassPrepare(art::Handle<art::mirror::Class> temp_klass,
300                     art::Handle<art::mirror::Class> klass)
301       override REQUIRES_SHARED(art::Locks::mutator_lock_) {
302     if (event_handler->IsEventEnabledAnywhere(ArtJvmtiEvent::kClassPrepare)) {
303       art::Thread* thread = art::Thread::Current();
304       if (temp_klass.Get() != klass.Get()) {
305         DCHECK(temp_klass->IsTemp());
306         DCHECK(temp_klass->IsRetired());
307         HandleTempClass(thread, temp_klass, klass);
308       }
309       ScopedLocalRef<jclass> jklass(thread->GetJniEnv(),
310                                     thread->GetJniEnv()->AddLocalReference<jclass>(klass.Get()));
311       art::ObjPtr<art::mirror::Object> peer(thread->GetPeer());
312       ScopedLocalRef<jthread> thread_jni(
313           thread->GetJniEnv(),
314           peer.IsNull() ? nullptr : thread->GetJniEnv()->AddLocalReference<jthread>(peer));
315       event_handler->DispatchEvent<ArtJvmtiEvent::kClassPrepare>(
316           thread,
317           static_cast<JNIEnv*>(thread->GetJniEnv()),
318           thread_jni.get(),
319           jklass.get());
320     }
321   }
322 
323   // To support parallel class-loading, we need to perform some locking dances here. Namely,
324   // the fixup stage must not be holding the temp_classes lock when it fixes up the system
325   // (as that requires suspending all mutators).
326 
AddTempClassopenjdkjvmti::ClassCallback327   void AddTempClass(art::Thread* self, jclass klass) {
328     std::unique_lock<std::mutex> mu(temp_classes_lock);
329     jclass global_klass = reinterpret_cast<jclass>(self->GetJniEnv()->NewGlobalRef(klass));
330     temp_classes.push_back(global_klass);
331   }
332 
HandleTempClassopenjdkjvmti::ClassCallback333   void HandleTempClass(art::Thread* self,
334                        art::Handle<art::mirror::Class> temp_klass,
335                        art::Handle<art::mirror::Class> klass)
336       REQUIRES_SHARED(art::Locks::mutator_lock_) {
337     bool requires_fixup = false;
338     {
339       std::unique_lock<std::mutex> mu(temp_classes_lock);
340       if (temp_classes.empty()) {
341         return;
342       }
343 
344       for (auto it = temp_classes.begin(); it != temp_classes.end(); ++it) {
345         if (temp_klass.Get() == art::ObjPtr<art::mirror::Class>::DownCast(self->DecodeJObject(*it))) {
346           self->GetJniEnv()->DeleteGlobalRef(*it);
347           temp_classes.erase(it);
348           requires_fixup = true;
349           break;
350         }
351       }
352     }
353     if (requires_fixup) {
354       FixupTempClass(self, temp_klass, klass);
355     }
356   }
357 
FixupTempClassopenjdkjvmti::ClassCallback358   void FixupTempClass(art::Thread* self,
359                       art::Handle<art::mirror::Class> temp_klass,
360                       art::Handle<art::mirror::Class> klass)
361      REQUIRES_SHARED(art::Locks::mutator_lock_) {
362     // Suspend everything.
363     art::gc::Heap* heap = art::Runtime::Current()->GetHeap();
364     if (heap->IsGcConcurrentAndMoving()) {
365       // Need to take a heap dump while GC isn't running. See the
366       // comment in Heap::VisitObjects().
367       heap->IncrementDisableMovingGC(self);
368     }
369     {
370       art::ScopedThreadSuspension sts(self, art::kWaitingForVisitObjects);
371       art::ScopedSuspendAll ssa("FixupTempClass");
372 
373       art::mirror::Class* input = temp_klass.Get();
374       art::mirror::Class* output = klass.Get();
375 
376       FixupGlobalReferenceTables(input, output);
377       FixupLocalReferenceTables(self, input, output);
378       FixupHeap(input, output);
379     }
380     if (heap->IsGcConcurrentAndMoving()) {
381       heap->DecrementDisableMovingGC(self);
382     }
383   }
384 
385   class RootUpdater : public art::RootVisitor {
386    public:
RootUpdater(const art::mirror::Class * input,art::mirror::Class * output)387     RootUpdater(const art::mirror::Class* input, art::mirror::Class* output)
388         : input_(input), output_(output) {}
389 
VisitRoots(art::mirror::Object *** roots,size_t count,const art::RootInfo & info ATTRIBUTE_UNUSED)390     void VisitRoots(art::mirror::Object*** roots,
391                     size_t count,
392                     const art::RootInfo& info ATTRIBUTE_UNUSED)
393         override {
394       for (size_t i = 0; i != count; ++i) {
395         if (*roots[i] == input_) {
396           *roots[i] = output_;
397         }
398       }
399     }
400 
VisitRoots(art::mirror::CompressedReference<art::mirror::Object> ** roots,size_t count,const art::RootInfo & info ATTRIBUTE_UNUSED)401     void VisitRoots(art::mirror::CompressedReference<art::mirror::Object>** roots,
402                     size_t count,
403                     const art::RootInfo& info ATTRIBUTE_UNUSED)
404         override REQUIRES_SHARED(art::Locks::mutator_lock_) {
405       for (size_t i = 0; i != count; ++i) {
406         if (roots[i]->AsMirrorPtr() == input_) {
407           roots[i]->Assign(output_);
408         }
409       }
410     }
411 
412    private:
413     const art::mirror::Class* input_;
414     art::mirror::Class* output_;
415   };
416 
FixupGlobalReferenceTablesopenjdkjvmti::ClassCallback417   void FixupGlobalReferenceTables(art::mirror::Class* input, art::mirror::Class* output)
418       REQUIRES(art::Locks::mutator_lock_) {
419     art::JavaVMExt* java_vm = art::Runtime::Current()->GetJavaVM();
420 
421     // Fix up the global table with a root visitor.
422     RootUpdater global_update(input, output);
423     java_vm->VisitRoots(&global_update);
424 
425     class WeakGlobalUpdate : public art::IsMarkedVisitor {
426      public:
427       WeakGlobalUpdate(art::mirror::Class* root_input, art::mirror::Class* root_output)
428           : input_(root_input), output_(root_output) {}
429 
430       art::mirror::Object* IsMarked(art::mirror::Object* obj) override {
431         if (obj == input_) {
432           return output_;
433         }
434         return obj;
435       }
436 
437      private:
438       const art::mirror::Class* input_;
439       art::mirror::Class* output_;
440     };
441     WeakGlobalUpdate weak_global_update(input, output);
442     java_vm->SweepJniWeakGlobals(&weak_global_update);
443   }
444 
FixupLocalReferenceTablesopenjdkjvmti::ClassCallback445   void FixupLocalReferenceTables(art::Thread* self,
446                                  art::mirror::Class* input,
447                                  art::mirror::Class* output)
448       REQUIRES(art::Locks::mutator_lock_) {
449     class LocalUpdate {
450      public:
451       LocalUpdate(const art::mirror::Class* root_input, art::mirror::Class* root_output)
452           : input_(root_input), output_(root_output) {}
453 
454       static void Callback(art::Thread* t, void* arg) REQUIRES(art::Locks::mutator_lock_) {
455         LocalUpdate* local = reinterpret_cast<LocalUpdate*>(arg);
456 
457         // Fix up the local table with a root visitor.
458         RootUpdater local_update(local->input_, local->output_);
459         t->GetJniEnv()->VisitJniLocalRoots(
460             &local_update, art::RootInfo(art::kRootJNILocal, t->GetThreadId()));
461       }
462 
463      private:
464       const art::mirror::Class* input_;
465       art::mirror::Class* output_;
466     };
467     LocalUpdate local_upd(input, output);
468     art::MutexLock mu(self, *art::Locks::thread_list_lock_);
469     art::Runtime::Current()->GetThreadList()->ForEach(LocalUpdate::Callback, &local_upd);
470   }
471 
FixupHeapopenjdkjvmti::ClassCallback472   void FixupHeap(art::mirror::Class* input, art::mirror::Class* output)
473         REQUIRES(art::Locks::mutator_lock_) {
474     class HeapFixupVisitor {
475      public:
476       HeapFixupVisitor(const art::mirror::Class* root_input, art::mirror::Class* root_output)
477                 : input_(root_input), output_(root_output) {}
478 
479       void operator()(art::mirror::Object* src,
480                       art::MemberOffset field_offset,
481                       bool is_static ATTRIBUTE_UNUSED) const
482           REQUIRES_SHARED(art::Locks::mutator_lock_) {
483         art::mirror::HeapReference<art::mirror::Object>* trg =
484           src->GetFieldObjectReferenceAddr(field_offset);
485         if (trg->AsMirrorPtr() == input_) {
486           DCHECK_NE(field_offset.Uint32Value(), 0u);  // This shouldn't be the class field of
487                                                       // an object.
488           trg->Assign(output_);
489         }
490       }
491 
492       void operator()(art::ObjPtr<art::mirror::Class> klass ATTRIBUTE_UNUSED,
493                       art::ObjPtr<art::mirror::Reference> reference) const
494           REQUIRES_SHARED(art::Locks::mutator_lock_) {
495         art::mirror::Object* val = reference->GetReferent();
496         if (val == input_) {
497           reference->SetReferent<false>(output_);
498         }
499       }
500 
501       void VisitRoot(art::mirror::CompressedReference<art::mirror::Object>* root ATTRIBUTE_UNUSED)
502           const {
503         LOG(FATAL) << "Unreachable";
504       }
505 
506       void VisitRootIfNonNull(
507           art::mirror::CompressedReference<art::mirror::Object>* root ATTRIBUTE_UNUSED) const {
508         LOG(FATAL) << "Unreachable";
509       }
510 
511      private:
512       const art::mirror::Class* input_;
513       art::mirror::Class* output_;
514     };
515     HeapFixupVisitor hfv(input, output);
516     auto object_visitor = [&](art::mirror::Object* obj) {
517       obj->VisitReferences<false>(hfv, hfv);  // Visit references, not native roots.
518     };
519     art::Runtime::Current()->GetHeap()->VisitObjectsPaused(object_visitor);
520   }
521 
522   // A set of all the temp classes we have handed out. We have to fix up references to these.
523   // For simplicity, we store the temp classes as JNI global references in a vector. Normally a
524   // Prepare event will closely follow, so the vector should be small.
525   std::mutex temp_classes_lock;
526   std::vector<jclass> temp_classes;
527 
528   EventHandler* event_handler = nullptr;
529 };
530 
531 ClassCallback gClassCallback;
532 
Register(EventHandler * handler)533 void ClassUtil::Register(EventHandler* handler) {
534   gClassCallback.event_handler = handler;
535   art::ScopedThreadStateChange stsc(art::Thread::Current(),
536                                     art::ThreadState::kWaitingForDebuggerToAttach);
537   art::ScopedSuspendAll ssa("Add load callback");
538   art::Runtime::Current()->GetRuntimeCallbacks()->AddClassLoadCallback(&gClassCallback);
539 }
540 
Unregister()541 void ClassUtil::Unregister() {
542   art::ScopedThreadStateChange stsc(art::Thread::Current(),
543                                     art::ThreadState::kWaitingForDebuggerToAttach);
544   art::ScopedSuspendAll ssa("Remove thread callback");
545   art::Runtime* runtime = art::Runtime::Current();
546   runtime->GetRuntimeCallbacks()->RemoveClassLoadCallback(&gClassCallback);
547 }
548 
GetClassFields(jvmtiEnv * env,jclass jklass,jint * field_count_ptr,jfieldID ** fields_ptr)549 jvmtiError ClassUtil::GetClassFields(jvmtiEnv* env,
550                                      jclass jklass,
551                                      jint* field_count_ptr,
552                                      jfieldID** fields_ptr) {
553   art::ScopedObjectAccess soa(art::Thread::Current());
554   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
555   if (klass == nullptr) {
556     return ERR(INVALID_CLASS);
557   }
558 
559   // Check if this class is a temporary class object used for loading. Since we are seeing it the
560   // class must not have been prepared yet since otherwise the fixup would have gotten the jobject
561   // to point to the final class object.
562   if (klass->IsTemp() || klass->IsRetired()) {
563     return ERR(CLASS_NOT_PREPARED);
564   }
565 
566   if (field_count_ptr == nullptr || fields_ptr == nullptr) {
567     return ERR(NULL_POINTER);
568   }
569 
570   art::IterationRange<art::StrideIterator<art::ArtField>> ifields = klass->GetIFields();
571   art::IterationRange<art::StrideIterator<art::ArtField>> sfields = klass->GetSFields();
572   size_t array_size = klass->NumInstanceFields() + klass->NumStaticFields();
573 
574   unsigned char* out_ptr;
575   jvmtiError allocError = env->Allocate(array_size * sizeof(jfieldID), &out_ptr);
576   if (allocError != ERR(NONE)) {
577     return allocError;
578   }
579   jfieldID* field_array = reinterpret_cast<jfieldID*>(out_ptr);
580 
581   size_t array_idx = 0;
582   for (art::ArtField& field : sfields) {
583     field_array[array_idx] = art::jni::EncodeArtField(&field);
584     ++array_idx;
585   }
586   for (art::ArtField& field : ifields) {
587     field_array[array_idx] = art::jni::EncodeArtField(&field);
588     ++array_idx;
589   }
590 
591   *field_count_ptr = static_cast<jint>(array_size);
592   *fields_ptr = field_array;
593 
594   return ERR(NONE);
595 }
596 
GetClassMethods(jvmtiEnv * env,jclass jklass,jint * method_count_ptr,jmethodID ** methods_ptr)597 jvmtiError ClassUtil::GetClassMethods(jvmtiEnv* env,
598                                       jclass jklass,
599                                       jint* method_count_ptr,
600                                       jmethodID** methods_ptr) {
601   art::ScopedObjectAccess soa(art::Thread::Current());
602   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
603   if (klass == nullptr) {
604     return ERR(INVALID_CLASS);
605   }
606 
607   // Check if this class is a temporary class object used for loading. Since we are seeing it the
608   // class must not have been prepared yet since otherwise the fixup would have gotten the jobject
609   // to point to the final class object.
610   if (klass->IsTemp() || klass->IsRetired()) {
611     return ERR(CLASS_NOT_PREPARED);
612   }
613 
614   if (method_count_ptr == nullptr || methods_ptr == nullptr) {
615     return ERR(NULL_POINTER);
616   }
617 
618   size_t array_size = klass->NumDeclaredVirtualMethods() + klass->NumDirectMethods();
619   unsigned char* out_ptr;
620   jvmtiError allocError = env->Allocate(array_size * sizeof(jmethodID), &out_ptr);
621   if (allocError != ERR(NONE)) {
622     return allocError;
623   }
624   jmethodID* method_array = reinterpret_cast<jmethodID*>(out_ptr);
625 
626   if (art::kIsDebugBuild) {
627     size_t count = 0;
628     for (auto& m ATTRIBUTE_UNUSED : klass->GetDeclaredMethods(art::kRuntimePointerSize)) {
629       count++;
630     }
631     CHECK_EQ(count, klass->NumDirectMethods() + klass->NumDeclaredVirtualMethods());
632   }
633 
634   size_t array_idx = 0;
635   for (auto& m : klass->GetDeclaredMethods(art::kRuntimePointerSize)) {
636     method_array[array_idx] = art::jni::EncodeArtMethod(&m);
637     ++array_idx;
638   }
639 
640   *method_count_ptr = static_cast<jint>(array_size);
641   *methods_ptr = method_array;
642 
643   return ERR(NONE);
644 }
645 
GetImplementedInterfaces(jvmtiEnv * env,jclass jklass,jint * interface_count_ptr,jclass ** interfaces_ptr)646 jvmtiError ClassUtil::GetImplementedInterfaces(jvmtiEnv* env,
647                                                jclass jklass,
648                                                jint* interface_count_ptr,
649                                                jclass** interfaces_ptr) {
650   art::ScopedObjectAccess soa(art::Thread::Current());
651   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
652   if (klass == nullptr) {
653     return ERR(INVALID_CLASS);
654   }
655 
656   if (interface_count_ptr == nullptr || interfaces_ptr == nullptr) {
657     return ERR(NULL_POINTER);
658   }
659 
660   // Need to handle array specifically. Arrays implement Serializable and Cloneable, but the
661   // spec says these should not be reported.
662   if (klass->IsArrayClass()) {
663     *interface_count_ptr = 0;
664     *interfaces_ptr = nullptr;  // TODO: Should we allocate a dummy here?
665     return ERR(NONE);
666   }
667 
668   size_t array_size = klass->NumDirectInterfaces();
669   unsigned char* out_ptr;
670   jvmtiError allocError = env->Allocate(array_size * sizeof(jclass), &out_ptr);
671   if (allocError != ERR(NONE)) {
672     return allocError;
673   }
674   jclass* interface_array = reinterpret_cast<jclass*>(out_ptr);
675 
676   art::StackHandleScope<1> hs(soa.Self());
677   art::Handle<art::mirror::Class> h_klass(hs.NewHandle(klass));
678 
679   for (uint32_t idx = 0; idx != array_size; ++idx) {
680     art::ObjPtr<art::mirror::Class> inf_klass =
681         art::mirror::Class::ResolveDirectInterface(soa.Self(), h_klass, idx);
682     if (inf_klass == nullptr) {
683       soa.Self()->ClearException();
684       env->Deallocate(out_ptr);
685       // TODO: What is the right error code here?
686       return ERR(INTERNAL);
687     }
688     interface_array[idx] = soa.AddLocalReference<jclass>(inf_klass);
689   }
690 
691   *interface_count_ptr = static_cast<jint>(array_size);
692   *interfaces_ptr = interface_array;
693 
694   return ERR(NONE);
695 }
696 
GetClassSignature(jvmtiEnv * env,jclass jklass,char ** signature_ptr,char ** generic_ptr)697 jvmtiError ClassUtil::GetClassSignature(jvmtiEnv* env,
698                                          jclass jklass,
699                                          char** signature_ptr,
700                                          char** generic_ptr) {
701   art::ScopedObjectAccess soa(art::Thread::Current());
702   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
703   if (klass == nullptr) {
704     return ERR(INVALID_CLASS);
705   }
706 
707   JvmtiUniquePtr<char[]> sig_copy;
708   if (signature_ptr != nullptr) {
709     std::string storage;
710     const char* descriptor = klass->GetDescriptor(&storage);
711 
712     jvmtiError ret;
713     sig_copy = CopyString(env, descriptor, &ret);
714     if (sig_copy == nullptr) {
715       return ret;
716     }
717     *signature_ptr = sig_copy.get();
718   }
719 
720   if (generic_ptr != nullptr) {
721     *generic_ptr = nullptr;
722     if (!klass->IsProxyClass() && klass->GetDexCache() != nullptr) {
723       art::StackHandleScope<1> hs(soa.Self());
724       art::Handle<art::mirror::Class> h_klass = hs.NewHandle(klass);
725       art::ObjPtr<art::mirror::ObjectArray<art::mirror::String>> str_array =
726           art::annotations::GetSignatureAnnotationForClass(h_klass);
727       if (str_array != nullptr) {
728         std::ostringstream oss;
729         for (auto str : str_array->Iterate()) {
730           oss << str->ToModifiedUtf8();
731         }
732         std::string output_string = oss.str();
733         jvmtiError ret;
734         JvmtiUniquePtr<char[]> copy = CopyString(env, output_string.c_str(), &ret);
735         if (copy == nullptr) {
736           return ret;
737         }
738         *generic_ptr = copy.release();
739       } else if (soa.Self()->IsExceptionPending()) {
740         // TODO: Should we report an error here?
741         soa.Self()->ClearException();
742       }
743     }
744   }
745 
746   // Everything is fine, release the buffers.
747   sig_copy.release();
748 
749   return ERR(NONE);
750 }
751 
GetClassStatus(jvmtiEnv * env ATTRIBUTE_UNUSED,jclass jklass,jint * status_ptr)752 jvmtiError ClassUtil::GetClassStatus(jvmtiEnv* env ATTRIBUTE_UNUSED,
753                                      jclass jklass,
754                                      jint* status_ptr) {
755   art::ScopedObjectAccess soa(art::Thread::Current());
756   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
757   if (klass == nullptr) {
758     return ERR(INVALID_CLASS);
759   }
760 
761   if (status_ptr == nullptr) {
762     return ERR(NULL_POINTER);
763   }
764 
765   if (klass->IsArrayClass()) {
766     *status_ptr = JVMTI_CLASS_STATUS_ARRAY;
767   } else if (klass->IsPrimitive()) {
768     *status_ptr = JVMTI_CLASS_STATUS_PRIMITIVE;
769   } else {
770     *status_ptr = JVMTI_CLASS_STATUS_VERIFIED;  // All loaded classes are structurally verified.
771     // This is finicky. If there's an error, we'll say it wasn't prepared.
772     if (klass->IsResolved()) {
773       *status_ptr |= JVMTI_CLASS_STATUS_PREPARED;
774     }
775     if (klass->IsInitialized()) {
776       *status_ptr |= JVMTI_CLASS_STATUS_INITIALIZED;
777     }
778     // Technically the class may be erroneous for other reasons, but we do not have enough info.
779     if (klass->IsErroneous()) {
780       *status_ptr |= JVMTI_CLASS_STATUS_ERROR;
781     }
782   }
783 
784   return ERR(NONE);
785 }
786 
787 template <typename T>
ClassIsT(jclass jklass,T test,jboolean * is_t_ptr)788 static jvmtiError ClassIsT(jclass jklass, T test, jboolean* is_t_ptr) {
789   art::ScopedObjectAccess soa(art::Thread::Current());
790   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
791   if (klass == nullptr) {
792     return ERR(INVALID_CLASS);
793   }
794 
795   if (is_t_ptr == nullptr) {
796     return ERR(NULL_POINTER);
797   }
798 
799   *is_t_ptr = test(klass) ? JNI_TRUE : JNI_FALSE;
800   return ERR(NONE);
801 }
802 
IsInterface(jvmtiEnv * env ATTRIBUTE_UNUSED,jclass jklass,jboolean * is_interface_ptr)803 jvmtiError ClassUtil::IsInterface(jvmtiEnv* env ATTRIBUTE_UNUSED,
804                                   jclass jklass,
805                                   jboolean* is_interface_ptr) {
806   auto test = [](art::ObjPtr<art::mirror::Class> klass) REQUIRES_SHARED(art::Locks::mutator_lock_) {
807     return klass->IsInterface();
808   };
809   return ClassIsT(jklass, test, is_interface_ptr);
810 }
811 
IsArrayClass(jvmtiEnv * env ATTRIBUTE_UNUSED,jclass jklass,jboolean * is_array_class_ptr)812 jvmtiError ClassUtil::IsArrayClass(jvmtiEnv* env ATTRIBUTE_UNUSED,
813                                    jclass jklass,
814                                    jboolean* is_array_class_ptr) {
815   auto test = [](art::ObjPtr<art::mirror::Class> klass) REQUIRES_SHARED(art::Locks::mutator_lock_) {
816     return klass->IsArrayClass();
817   };
818   return ClassIsT(jklass, test, is_array_class_ptr);
819 }
820 
821 // Keep this in sync with Class.getModifiers().
ClassGetModifiers(art::Thread * self,art::ObjPtr<art::mirror::Class> klass)822 static uint32_t ClassGetModifiers(art::Thread* self, art::ObjPtr<art::mirror::Class> klass)
823     REQUIRES_SHARED(art::Locks::mutator_lock_) {
824   if (klass->IsArrayClass()) {
825     uint32_t component_modifiers = ClassGetModifiers(self, klass->GetComponentType());
826     if ((component_modifiers & art::kAccInterface) != 0) {
827       component_modifiers &= ~(art::kAccInterface | art::kAccStatic);
828     }
829     return art::kAccAbstract | art::kAccFinal | component_modifiers;
830   }
831 
832   uint32_t modifiers = klass->GetAccessFlags() & art::kAccJavaFlagsMask;
833 
834   art::StackHandleScope<1> hs(self);
835   art::Handle<art::mirror::Class> h_klass(hs.NewHandle(klass));
836   return art::mirror::Class::GetInnerClassFlags(h_klass, modifiers);
837 }
838 
GetClassModifiers(jvmtiEnv * env ATTRIBUTE_UNUSED,jclass jklass,jint * modifiers_ptr)839 jvmtiError ClassUtil::GetClassModifiers(jvmtiEnv* env ATTRIBUTE_UNUSED,
840                                         jclass jklass,
841                                         jint* modifiers_ptr) {
842   art::ScopedObjectAccess soa(art::Thread::Current());
843   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
844   if (klass == nullptr) {
845     return ERR(INVALID_CLASS);
846   }
847 
848   if (modifiers_ptr == nullptr) {
849     return ERR(NULL_POINTER);
850   }
851 
852   *modifiers_ptr = ClassGetModifiers(soa.Self(), klass);
853 
854   return ERR(NONE);
855 }
856 
GetClassLoader(jvmtiEnv * env ATTRIBUTE_UNUSED,jclass jklass,jobject * classloader_ptr)857 jvmtiError ClassUtil::GetClassLoader(jvmtiEnv* env ATTRIBUTE_UNUSED,
858                                      jclass jklass,
859                                      jobject* classloader_ptr) {
860   art::ScopedObjectAccess soa(art::Thread::Current());
861   art::ObjPtr<art::mirror::Class> klass = soa.Decode<art::mirror::Class>(jklass);
862   if (klass == nullptr) {
863     return ERR(INVALID_CLASS);
864   }
865 
866   if (classloader_ptr == nullptr) {
867     return ERR(NULL_POINTER);
868   }
869 
870   *classloader_ptr = soa.AddLocalReference<jobject>(klass->GetClassLoader());
871 
872   return ERR(NONE);
873 }
874 
875 // Copies unique class descriptors into the classes list from dex_files.
CopyClassDescriptors(jvmtiEnv * env,const std::vector<const art::DexFile * > & dex_files,jint * count_ptr,char *** classes)876 static jvmtiError CopyClassDescriptors(jvmtiEnv* env,
877                                        const std::vector<const art::DexFile*>& dex_files,
878                                        /*out*/jint* count_ptr,
879                                        /*out*/char*** classes) {
880   jvmtiError res = OK;
881   std::set<std::string_view> unique_descriptors;
882   std::vector<const char*> descriptors;
883   auto add_descriptor = [&](const char* desc) {
884     // Don't add duplicates.
885     if (res == OK && unique_descriptors.find(desc) == unique_descriptors.end()) {
886       // The desc will remain valid since we hold a ref to the class_loader.
887       unique_descriptors.insert(desc);
888       descriptors.push_back(CopyString(env, desc, &res).release());
889     }
890   };
891   for (const art::DexFile* dex_file : dex_files) {
892     uint32_t num_defs = dex_file->NumClassDefs();
893     for (uint32_t i = 0; i < num_defs; i++) {
894       add_descriptor(dex_file->GetClassDescriptor(dex_file->GetClassDef(i)));
895     }
896   }
897   char** out_data = nullptr;
898   if (res == OK) {
899     res = env->Allocate(sizeof(char*) * descriptors.size(),
900                         reinterpret_cast<unsigned char**>(&out_data));
901   }
902   if (res != OK) {
903     env->Deallocate(reinterpret_cast<unsigned char*>(out_data));
904     // Failed to allocate. Cleanup everything.
905     for (const char* data : descriptors) {
906       env->Deallocate(reinterpret_cast<unsigned char*>(const_cast<char*>(data)));
907     }
908     descriptors.clear();
909     return res;
910   }
911   // Everything is good.
912   memcpy(out_data, descriptors.data(), sizeof(char*) * descriptors.size());
913   *count_ptr = static_cast<jint>(descriptors.size());
914   *classes = out_data;
915   return OK;
916 }
917 
GetClassLoaderClassDescriptors(jvmtiEnv * env,jobject loader,jint * count_ptr,char *** classes)918 jvmtiError ClassUtil::GetClassLoaderClassDescriptors(jvmtiEnv* env,
919                                                      jobject loader,
920                                                      /*out*/jint* count_ptr,
921                                                      /*out*/char*** classes) {
922   art::Thread* self = art::Thread::Current();
923   if (env == nullptr) {
924     return ERR(INVALID_ENVIRONMENT);
925   } else if (self == nullptr) {
926     return ERR(UNATTACHED_THREAD);
927   } else if (count_ptr == nullptr || classes == nullptr) {
928     return ERR(NULL_POINTER);
929   }
930   art::JNIEnvExt* jnienv = self->GetJniEnv();
931   if (loader == nullptr ||
932       jnienv->IsInstanceOf(loader, art::WellKnownClasses::java_lang_BootClassLoader)) {
933     // We can just get the dex files directly for the boot class path.
934     return CopyClassDescriptors(env,
935                                 art::Runtime::Current()->GetClassLinker()->GetBootClassPath(),
936                                 count_ptr,
937                                 classes);
938   }
939   if (!jnienv->IsInstanceOf(loader, art::WellKnownClasses::java_lang_ClassLoader)) {
940     return ERR(ILLEGAL_ARGUMENT);
941   } else if (!jnienv->IsInstanceOf(loader,
942                                    art::WellKnownClasses::dalvik_system_BaseDexClassLoader)) {
943     JVMTI_LOG(ERROR, env) << "GetClassLoaderClassDescriptors is only implemented for "
944                           << "BootClassPath and dalvik.system.BaseDexClassLoader class loaders";
945     // TODO Possibly return OK With no classes would  be better since these ones cannot have any
946     // real classes associated with them.
947     return ERR(NOT_IMPLEMENTED);
948   }
949 
950   art::ScopedObjectAccess soa(self);
951   art::StackHandleScope<1> hs(self);
952   art::Handle<art::mirror::ClassLoader> class_loader(
953       hs.NewHandle(soa.Decode<art::mirror::ClassLoader>(loader)));
954   std::vector<const art::DexFile*> dex_files;
955   art::VisitClassLoaderDexFiles(
956       soa,
957       class_loader,
958       [&](const art::DexFile* dex_file) {
959         dex_files.push_back(dex_file);
960         return true;  // Continue with other dex files.
961       });
962   // We hold the loader so the dex files won't go away until after this call at worst.
963   return CopyClassDescriptors(env, dex_files, count_ptr, classes);
964 }
965 
GetClassLoaderClasses(jvmtiEnv * env,jobject initiating_loader,jint * class_count_ptr,jclass ** classes_ptr)966 jvmtiError ClassUtil::GetClassLoaderClasses(jvmtiEnv* env,
967                                             jobject initiating_loader,
968                                             jint* class_count_ptr,
969                                             jclass** classes_ptr) {
970   UNUSED(env, initiating_loader, class_count_ptr, classes_ptr);
971 
972   if (class_count_ptr == nullptr || classes_ptr == nullptr) {
973     return ERR(NULL_POINTER);
974   }
975   art::Thread* self = art::Thread::Current();
976   if (!self->GetJniEnv()->IsInstanceOf(initiating_loader,
977                                        art::WellKnownClasses::java_lang_ClassLoader)) {
978     return ERR(ILLEGAL_ARGUMENT);
979   }
980   if (self->GetJniEnv()->IsInstanceOf(initiating_loader,
981                                       art::WellKnownClasses::java_lang_BootClassLoader)) {
982     // Need to use null for the BootClassLoader.
983     initiating_loader = nullptr;
984   }
985 
986   art::ScopedObjectAccess soa(self);
987   art::ObjPtr<art::mirror::ClassLoader> class_loader =
988       soa.Decode<art::mirror::ClassLoader>(initiating_loader);
989 
990   art::ClassLinker* class_linker = art::Runtime::Current()->GetClassLinker();
991 
992   art::ReaderMutexLock mu(self, *art::Locks::classlinker_classes_lock_);
993 
994   art::ClassTable* class_table = class_linker->ClassTableForClassLoader(class_loader);
995   if (class_table == nullptr) {
996     // Nothing loaded.
997     *class_count_ptr = 0;
998     *classes_ptr = nullptr;
999     return ERR(NONE);
1000   }
1001 
1002   struct ClassTableCount {
1003     bool operator()(art::ObjPtr<art::mirror::Class> klass) {
1004       DCHECK(klass != nullptr);
1005       ++count;
1006       return true;
1007     }
1008 
1009     size_t count = 0;
1010   };
1011   ClassTableCount ctc;
1012   class_table->Visit(ctc);
1013 
1014   if (ctc.count == 0) {
1015     // Nothing loaded.
1016     *class_count_ptr = 0;
1017     *classes_ptr = nullptr;
1018     return ERR(NONE);
1019   }
1020 
1021   unsigned char* data;
1022   jvmtiError data_result = env->Allocate(ctc.count * sizeof(jclass), &data);
1023   if (data_result != ERR(NONE)) {
1024     return data_result;
1025   }
1026   jclass* class_array = reinterpret_cast<jclass*>(data);
1027 
1028   struct ClassTableFill {
1029     bool operator()(art::ObjPtr<art::mirror::Class> klass)
1030         REQUIRES_SHARED(art::Locks::mutator_lock_) {
1031       DCHECK(klass != nullptr);
1032       DCHECK_LT(count, ctc_ref.count);
1033       local_class_array[count++] = soa_ptr->AddLocalReference<jclass>(klass);
1034       return true;
1035     }
1036 
1037     jclass* local_class_array;
1038     const ClassTableCount& ctc_ref;
1039     art::ScopedObjectAccess* soa_ptr;
1040     size_t count;
1041   };
1042   ClassTableFill ctf = { class_array, ctc, &soa, 0 };
1043   class_table->Visit(ctf);
1044   DCHECK_EQ(ctc.count, ctf.count);
1045 
1046   *class_count_ptr = ctc.count;
1047   *classes_ptr = class_array;
1048 
1049   return ERR(NONE);
1050 }
1051 
GetClassVersionNumbers(jvmtiEnv * env ATTRIBUTE_UNUSED,jclass jklass,jint * minor_version_ptr,jint * major_version_ptr)1052 jvmtiError ClassUtil::GetClassVersionNumbers(jvmtiEnv* env ATTRIBUTE_UNUSED,
1053                                              jclass jklass,
1054                                              jint* minor_version_ptr,
1055                                              jint* major_version_ptr) {
1056   art::ScopedObjectAccess soa(art::Thread::Current());
1057   if (jklass == nullptr) {
1058     return ERR(INVALID_CLASS);
1059   }
1060   art::ObjPtr<art::mirror::Object> jklass_obj = soa.Decode<art::mirror::Object>(jklass);
1061   if (!jklass_obj->IsClass()) {
1062     return ERR(INVALID_CLASS);
1063   }
1064   art::ObjPtr<art::mirror::Class> klass = jklass_obj->AsClass();
1065   if (klass->IsPrimitive() || klass->IsArrayClass()) {
1066     return ERR(INVALID_CLASS);
1067   }
1068 
1069   if (minor_version_ptr == nullptr || major_version_ptr == nullptr) {
1070     return ERR(NULL_POINTER);
1071   }
1072 
1073   // Note: proxies will show the dex file version of java.lang.reflect.Proxy, as that is
1074   //       what their dex cache copies from.
1075   uint32_t version = klass->GetDexFile().GetHeader().GetVersion();
1076 
1077   *major_version_ptr = static_cast<jint>(version);
1078   *minor_version_ptr = 0;
1079 
1080   return ERR(NONE);
1081 }
1082 
GetSourceFileName(jvmtiEnv * env,jclass jklass,char ** source_name_ptr)1083 jvmtiError ClassUtil::GetSourceFileName(jvmtiEnv* env, jclass jklass, char** source_name_ptr) {
1084   art::ScopedObjectAccess soa(art::Thread::Current());
1085   if (jklass == nullptr) {
1086     return ERR(INVALID_CLASS);
1087   }
1088   art::ObjPtr<art::mirror::Object> jklass_obj = soa.Decode<art::mirror::Object>(jklass);
1089   if (!jklass_obj->IsClass()) {
1090     return ERR(INVALID_CLASS);
1091   }
1092   art::ObjPtr<art::mirror::Class> klass = jklass_obj->AsClass();
1093   if (klass->IsPrimitive() || klass->IsArrayClass()) {
1094     return ERR(ABSENT_INFORMATION);
1095   }
1096   JvmtiUniquePtr<char[]> source_copy;
1097   const char* file_name = klass->GetSourceFile();
1098   if (file_name == nullptr) {
1099     return ERR(ABSENT_INFORMATION);
1100   }
1101   jvmtiError ret;
1102   source_copy = CopyString(env, file_name, &ret);
1103   if (source_copy == nullptr) {
1104     return ret;
1105   }
1106   *source_name_ptr = source_copy.release();
1107   return OK;
1108 }
1109 
GetSourceDebugExtension(jvmtiEnv * env,jclass jklass,char ** source_debug_extension_ptr)1110 jvmtiError ClassUtil::GetSourceDebugExtension(jvmtiEnv* env,
1111                                               jclass jklass,
1112                                               char** source_debug_extension_ptr) {
1113   art::ScopedObjectAccess soa(art::Thread::Current());
1114   if (jklass == nullptr) {
1115     return ERR(INVALID_CLASS);
1116   }
1117   art::ObjPtr<art::mirror::Object> jklass_obj = soa.Decode<art::mirror::Object>(jklass);
1118   if (!jklass_obj->IsClass()) {
1119     return ERR(INVALID_CLASS);
1120   }
1121   art::StackHandleScope<1> hs(art::Thread::Current());
1122   art::Handle<art::mirror::Class> klass(hs.NewHandle(jklass_obj->AsClass()));
1123   if (klass->IsPrimitive() || klass->IsArrayClass()) {
1124     return ERR(ABSENT_INFORMATION);
1125   }
1126   JvmtiUniquePtr<char[]> ext_copy;
1127   const char* data = art::annotations::GetSourceDebugExtension(klass);
1128   if (data == nullptr) {
1129     return ERR(ABSENT_INFORMATION);
1130   }
1131   jvmtiError ret;
1132   ext_copy = CopyString(env, data, &ret);
1133   if (ext_copy == nullptr) {
1134     return ret;
1135   }
1136   *source_debug_extension_ptr = ext_copy.release();
1137   return OK;
1138 }
1139 
1140 }  // namespace openjdkjvmti
1141