java_lang_Class.cc revision 2efb0aa57da168944f99a2d13aed2a426cfa76e7 
1/*
2 * Copyright (C) 2008 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "java_lang_Class.h"
18
19#include "art_field-inl.h"
20#include "class_linker.h"
21#include "common_throws.h"
22#include "dex_file-inl.h"
23#include "jni_internal.h"
24#include "nth_caller_visitor.h"
25#include "mirror/class-inl.h"
26#include "mirror/class_loader.h"
27#include "mirror/field-inl.h"
28#include "mirror/method.h"
29#include "mirror/object-inl.h"
30#include "mirror/object_array-inl.h"
31#include "mirror/string-inl.h"
32#include "reflection.h"
33#include "scoped_thread_state_change.h"
34#include "scoped_fast_native_object_access.h"
35#include "ScopedLocalRef.h"
36#include "ScopedUtfChars.h"
37#include "utf.h"
38#include "well_known_classes.h"
39
40namespace art {
41
42ALWAYS_INLINE static inline mirror::Class* DecodeClass(
43    const ScopedFastNativeObjectAccess& soa, jobject java_class)
44    SHARED_REQUIRES(Locks::mutator_lock_) {
45  mirror::Class* c = soa.Decode<mirror::Class*>(java_class);
46  DCHECK(c != nullptr);
47  DCHECK(c->IsClass());
48  // TODO: we could EnsureInitialized here, rather than on every reflective get/set or invoke .
49  // For now, we conservatively preserve the old dalvik behavior. A quick "IsInitialized" check
50  // every time probably doesn't make much difference to reflection performance anyway.
51  return c;
52}
53
54// "name" is in "binary name" format, e.g. "dalvik.system.Debug$1".
55static jclass Class_classForName(JNIEnv* env, jclass, jstring javaName, jboolean initialize,
56                                 jobject javaLoader) {
57  ScopedFastNativeObjectAccess soa(env);
58  ScopedUtfChars name(env, javaName);
59  if (name.c_str() == nullptr) {
60    return nullptr;
61  }
62
63  // We need to validate and convert the name (from x.y.z to x/y/z).  This
64  // is especially handy for array types, since we want to avoid
65  // auto-generating bogus array classes.
66  if (!IsValidBinaryClassName(name.c_str())) {
67    soa.Self()->ThrowNewExceptionF("Ljava/lang/ClassNotFoundException;",
68                                   "Invalid name: %s", name.c_str());
69    return nullptr;
70  }
71
72  std::string descriptor(DotToDescriptor(name.c_str()));
73  StackHandleScope<2> hs(soa.Self());
74  Handle<mirror::ClassLoader> class_loader(hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader)));
75  ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
76  Handle<mirror::Class> c(
77      hs.NewHandle(class_linker->FindClass(soa.Self(), descriptor.c_str(), class_loader)));
78  if (c.Get() == nullptr) {
79    ScopedLocalRef<jthrowable> cause(env, env->ExceptionOccurred());
80    env->ExceptionClear();
81    jthrowable cnfe = reinterpret_cast<jthrowable>(env->NewObject(WellKnownClasses::java_lang_ClassNotFoundException,
82                                                                  WellKnownClasses::java_lang_ClassNotFoundException_init,
83                                                                  javaName, cause.get()));
84    if (cnfe != nullptr) {
85      // Make sure allocation didn't fail with an OOME.
86      env->Throw(cnfe);
87    }
88    return nullptr;
89  }
90  if (initialize) {
91    class_linker->EnsureInitialized(soa.Self(), c, true, true);
92  }
93  return soa.AddLocalReference<jclass>(c.Get());
94}
95
96static jstring Class_getNameNative(JNIEnv* env, jobject javaThis) {
97  ScopedFastNativeObjectAccess soa(env);
98  StackHandleScope<1> hs(soa.Self());
99  mirror::Class* const c = DecodeClass(soa, javaThis);
100  return soa.AddLocalReference<jstring>(mirror::Class::ComputeName(hs.NewHandle(c)));
101}
102
103static jobjectArray Class_getProxyInterfaces(JNIEnv* env, jobject javaThis) {
104  ScopedFastNativeObjectAccess soa(env);
105  mirror::Class* c = DecodeClass(soa, javaThis);
106  return soa.AddLocalReference<jobjectArray>(c->GetInterfaces()->Clone(soa.Self()));
107}
108
109static mirror::ObjectArray<mirror::Field>* GetDeclaredFields(
110    Thread* self, mirror::Class* klass, bool public_only, bool force_resolve)
111      SHARED_REQUIRES(Locks::mutator_lock_) {
112  StackHandleScope<1> hs(self);
113  IterationRange<StrideIterator<ArtField>> ifields = klass->GetIFields();
114  IterationRange<StrideIterator<ArtField>> sfields = klass->GetSFields();
115  size_t array_size = klass->NumInstanceFields() + klass->NumStaticFields();
116  if (public_only) {
117    // Lets go subtract all the non public fields.
118    for (ArtField& field : ifields) {
119      if (!field.IsPublic()) {
120        --array_size;
121      }
122    }
123    for (ArtField& field : sfields) {
124      if (!field.IsPublic()) {
125        --array_size;
126      }
127    }
128  }
129  size_t array_idx = 0;
130  auto object_array = hs.NewHandle(mirror::ObjectArray<mirror::Field>::Alloc(
131      self, mirror::Field::ArrayClass(), array_size));
132  if (object_array.Get() == nullptr) {
133    return nullptr;
134  }
135  for (ArtField& field : ifields) {
136    if (!public_only || field.IsPublic()) {
137      auto* reflect_field = mirror::Field::CreateFromArtField(self, &field, force_resolve);
138      if (reflect_field == nullptr) {
139        if (kIsDebugBuild) {
140          self->AssertPendingException();
141        }
142        // Maybe null due to OOME or type resolving exception.
143        return nullptr;
144      }
145      object_array->SetWithoutChecks<false>(array_idx++, reflect_field);
146    }
147  }
148  for (ArtField& field : sfields) {
149    if (!public_only || field.IsPublic()) {
150      auto* reflect_field = mirror::Field::CreateFromArtField(self, &field, force_resolve);
151      if (reflect_field == nullptr) {
152        if (kIsDebugBuild) {
153          self->AssertPendingException();
154        }
155        return nullptr;
156      }
157      object_array->SetWithoutChecks<false>(array_idx++, reflect_field);
158    }
159  }
160  DCHECK_EQ(array_idx, array_size);
161  return object_array.Get();
162}
163
164static jobjectArray Class_getDeclaredFieldsUnchecked(JNIEnv* env, jobject javaThis,
165                                                     jboolean publicOnly) {
166  ScopedFastNativeObjectAccess soa(env);
167  return soa.AddLocalReference<jobjectArray>(
168      GetDeclaredFields(soa.Self(), DecodeClass(soa, javaThis), publicOnly != JNI_FALSE, false));
169}
170
171static jobjectArray Class_getDeclaredFields(JNIEnv* env, jobject javaThis) {
172  ScopedFastNativeObjectAccess soa(env);
173  return soa.AddLocalReference<jobjectArray>(
174      GetDeclaredFields(soa.Self(), DecodeClass(soa, javaThis), false, true));
175}
176
177static jobjectArray Class_getPublicDeclaredFields(JNIEnv* env, jobject javaThis) {
178  ScopedFastNativeObjectAccess soa(env);
179  return soa.AddLocalReference<jobjectArray>(
180      GetDeclaredFields(soa.Self(), DecodeClass(soa, javaThis), true, true));
181}
182
183// Performs a binary search through an array of fields, TODO: Is this fast enough if we don't use
184// the dex cache for lookups? I think CompareModifiedUtf8ToUtf16AsCodePointValues should be fairly
185// fast.
186ALWAYS_INLINE static inline ArtField* FindFieldByName(
187    Thread* self ATTRIBUTE_UNUSED, mirror::String* name, LengthPrefixedArray<ArtField>* fields)
188    SHARED_REQUIRES(Locks::mutator_lock_) {
189  if (fields == nullptr) {
190    return nullptr;
191  }
192  size_t low = 0;
193  size_t high = fields->size();
194  const uint16_t* const data = name->GetValue();
195  const size_t length = name->GetLength();
196  while (low < high) {
197    auto mid = (low + high) / 2;
198    ArtField& field = fields->At(mid);
199    int result = CompareModifiedUtf8ToUtf16AsCodePointValues(field.GetName(), data, length);
200    // Alternate approach, only a few % faster at the cost of more allocations.
201    // int result = field->GetStringName(self, true)->CompareTo(name);
202    if (result < 0) {
203      low = mid + 1;
204    } else if (result > 0) {
205      high = mid;
206    } else {
207      return &field;
208    }
209  }
210  if (kIsDebugBuild) {
211    for (ArtField& field : MakeIterationRangeFromLengthPrefixedArray(fields)) {
212      CHECK_NE(field.GetName(), name->ToModifiedUtf8());
213    }
214  }
215  return nullptr;
216}
217
218ALWAYS_INLINE static inline mirror::Field* GetDeclaredField(
219    Thread* self, mirror::Class* c, mirror::String* name)
220    SHARED_REQUIRES(Locks::mutator_lock_) {
221  ArtField* art_field = FindFieldByName(self, name, c->GetIFieldsPtr());
222  if (art_field != nullptr) {
223    return mirror::Field::CreateFromArtField(self, art_field, true);
224  }
225  art_field = FindFieldByName(self, name, c->GetSFieldsPtr());
226  if (art_field != nullptr) {
227    return mirror::Field::CreateFromArtField(self, art_field, true);
228  }
229  return nullptr;
230}
231
232static mirror::Field* GetPublicFieldRecursive(
233    Thread* self, mirror::Class* clazz, mirror::String* name)
234    SHARED_REQUIRES(Locks::mutator_lock_) {
235  DCHECK(clazz != nullptr);
236  DCHECK(name != nullptr);
237  DCHECK(self != nullptr);
238
239  StackHandleScope<1> hs(self);
240  MutableHandle<mirror::Class> h_clazz(hs.NewHandle(clazz));
241
242  // We search the current class, its direct interfaces then its superclass.
243  while (h_clazz.Get() != nullptr) {
244    mirror::Field* result = GetDeclaredField(self, h_clazz.Get(), name);
245    if ((result != nullptr) && (result->GetAccessFlags() & kAccPublic)) {
246      return result;
247    } else if (UNLIKELY(self->IsExceptionPending())) {
248      // Something went wrong. Bail out.
249      return nullptr;
250    }
251
252    uint32_t num_direct_interfaces = h_clazz->NumDirectInterfaces();
253    for (uint32_t i = 0; i < num_direct_interfaces; i++) {
254      mirror::Class *iface = mirror::Class::GetDirectInterface(self, h_clazz, i);
255      if (UNLIKELY(iface == nullptr)) {
256        self->AssertPendingException();
257        return nullptr;
258      }
259      result = GetPublicFieldRecursive(self, iface, name);
260      if (result != nullptr) {
261        DCHECK(result->GetAccessFlags() & kAccPublic);
262        return result;
263      } else if (UNLIKELY(self->IsExceptionPending())) {
264        // Something went wrong. Bail out.
265        return nullptr;
266      }
267    }
268
269    // We don't try the superclass if we are an interface.
270    if (h_clazz->IsInterface()) {
271      break;
272    }
273
274    // Get the next class.
275    h_clazz.Assign(h_clazz->GetSuperClass());
276  }
277  return nullptr;
278}
279
280static jobject Class_getPublicFieldRecursive(JNIEnv* env, jobject javaThis, jstring name) {
281  ScopedFastNativeObjectAccess soa(env);
282  auto* name_string = soa.Decode<mirror::String*>(name);
283  if (UNLIKELY(name_string == nullptr)) {
284    ThrowNullPointerException("name == null");
285    return nullptr;
286  }
287  return soa.AddLocalReference<jobject>(
288      GetPublicFieldRecursive(soa.Self(), DecodeClass(soa, javaThis), name_string));
289}
290
291static jobject Class_getDeclaredFieldInternal(JNIEnv* env, jobject javaThis, jstring name) {
292  ScopedFastNativeObjectAccess soa(env);
293  auto* name_string = soa.Decode<mirror::String*>(name);
294  return soa.AddLocalReference<jobject>(
295      GetDeclaredField(soa.Self(), DecodeClass(soa, javaThis), name_string));
296}
297
298static jobject Class_getDeclaredField(JNIEnv* env, jobject javaThis, jstring name) {
299  ScopedFastNativeObjectAccess soa(env);
300  auto* name_string = soa.Decode<mirror::String*>(name);
301  if (name_string == nullptr) {
302    ThrowNullPointerException("name == null");
303    return nullptr;
304  }
305  auto* klass = DecodeClass(soa, javaThis);
306  mirror::Field* result = GetDeclaredField(soa.Self(), klass, name_string);
307  if (result == nullptr) {
308    std::string name_str = name_string->ToModifiedUtf8();
309    // We may have a pending exception if we failed to resolve.
310    if (!soa.Self()->IsExceptionPending()) {
311      ThrowNoSuchFieldException(DecodeClass(soa, javaThis), name_str.c_str());
312    }
313    return nullptr;
314  }
315  return soa.AddLocalReference<jobject>(result);
316}
317
318static jobject Class_getDeclaredConstructorInternal(
319    JNIEnv* env, jobject javaThis, jobjectArray args) {
320  ScopedFastNativeObjectAccess soa(env);
321  auto* klass = DecodeClass(soa, javaThis);
322  auto* params = soa.Decode<mirror::ObjectArray<mirror::Class>*>(args);
323  StackHandleScope<1> hs(soa.Self());
324  auto* declared_constructor = klass->GetDeclaredConstructor(soa.Self(), hs.NewHandle(params));
325  if (declared_constructor != nullptr) {
326    return soa.AddLocalReference<jobject>(
327        mirror::Constructor::CreateFromArtMethod(soa.Self(), declared_constructor));
328  }
329  return nullptr;
330}
331
332static ALWAYS_INLINE inline bool MethodMatchesConstructor(ArtMethod* m, bool public_only)
333    SHARED_REQUIRES(Locks::mutator_lock_) {
334  DCHECK(m != nullptr);
335  return (!public_only || m->IsPublic()) && !m->IsStatic() && m->IsConstructor();
336}
337
338static jobjectArray Class_getDeclaredConstructorsInternal(
339    JNIEnv* env, jobject javaThis, jboolean publicOnly) {
340  ScopedFastNativeObjectAccess soa(env);
341  StackHandleScope<2> hs(soa.Self());
342  Handle<mirror::Class> h_klass = hs.NewHandle(DecodeClass(soa, javaThis));
343  size_t constructor_count = 0;
344  // Two pass approach for speed.
345  for (auto& m : h_klass->GetDirectMethods(sizeof(void*))) {
346    constructor_count += MethodMatchesConstructor(&m, publicOnly != JNI_FALSE) ? 1u : 0u;
347  }
348  auto h_constructors = hs.NewHandle(mirror::ObjectArray<mirror::Constructor>::Alloc(
349      soa.Self(), mirror::Constructor::ArrayClass(), constructor_count));
350  if (UNLIKELY(h_constructors.Get() == nullptr)) {
351    soa.Self()->AssertPendingException();
352    return nullptr;
353  }
354  constructor_count = 0;
355  for (auto& m : h_klass->GetDirectMethods(sizeof(void*))) {
356    if (MethodMatchesConstructor(&m, publicOnly != JNI_FALSE)) {
357      auto* constructor = mirror::Constructor::CreateFromArtMethod(soa.Self(), &m);
358      if (UNLIKELY(constructor == nullptr)) {
359        soa.Self()->AssertPendingOOMException();
360        return nullptr;
361      }
362      h_constructors->SetWithoutChecks<false>(constructor_count++, constructor);
363    }
364  }
365  return soa.AddLocalReference<jobjectArray>(h_constructors.Get());
366}
367
368static jobject Class_getDeclaredMethodInternal(JNIEnv* env, jobject javaThis,
369                                               jobject name, jobjectArray args) {
370  // Covariant return types permit the class to define multiple
371  // methods with the same name and parameter types. Prefer to
372  // return a non-synthetic method in such situations. We may
373  // still return a synthetic method to handle situations like
374  // escalated visibility. We never return miranda methods that
375  // were synthesized by the runtime.
376  constexpr uint32_t kSkipModifiers = kAccMiranda | kAccSynthetic;
377  ScopedFastNativeObjectAccess soa(env);
378  StackHandleScope<3> hs(soa.Self());
379  auto h_method_name = hs.NewHandle(soa.Decode<mirror::String*>(name));
380  if (UNLIKELY(h_method_name.Get() == nullptr)) {
381    ThrowNullPointerException("name == null");
382    return nullptr;
383  }
384  auto h_args = hs.NewHandle(soa.Decode<mirror::ObjectArray<mirror::Class>*>(args));
385  Handle<mirror::Class> h_klass = hs.NewHandle(DecodeClass(soa, javaThis));
386  ArtMethod* result = nullptr;
387  for (auto& m : h_klass->GetVirtualMethods(sizeof(void*))) {
388    auto* np_method = m.GetInterfaceMethodIfProxy(sizeof(void*));
389    // May cause thread suspension.
390    mirror::String* np_name = np_method->GetNameAsString(soa.Self());
391    if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) {
392      if (UNLIKELY(soa.Self()->IsExceptionPending())) {
393        return nullptr;
394      }
395      continue;
396    }
397    auto modifiers = m.GetAccessFlags();
398    if ((modifiers & kSkipModifiers) == 0) {
399      return soa.AddLocalReference<jobject>(mirror::Method::CreateFromArtMethod(soa.Self(), &m));
400    }
401    if ((modifiers & kAccMiranda) == 0) {
402      result = &m;  // Remember as potential result if it's not a miranda method.
403    }
404  }
405  if (result == nullptr) {
406    for (auto& m : h_klass->GetDirectMethods(sizeof(void*))) {
407      auto modifiers = m.GetAccessFlags();
408      if ((modifiers & kAccConstructor) != 0) {
409        continue;
410      }
411      auto* np_method = m.GetInterfaceMethodIfProxy(sizeof(void*));
412      // May cause thread suspension.
413      mirror::String* np_name = np_method->GetNameAsString(soa.Self());
414      if (np_name == nullptr) {
415        soa.Self()->AssertPendingException();
416        return nullptr;
417      }
418      if (!np_name->Equals(h_method_name.Get()) || !np_method->EqualParameters(h_args)) {
419        if (UNLIKELY(soa.Self()->IsExceptionPending())) {
420          return nullptr;
421        }
422        continue;
423      }
424      if ((modifiers & kSkipModifiers) == 0) {
425        return soa.AddLocalReference<jobject>(mirror::Method::CreateFromArtMethod(soa.Self(), &m));
426      }
427      // Direct methods cannot be miranda methods, so this potential result must be synthetic.
428      result = &m;
429    }
430  }
431  return result != nullptr ?
432      soa.AddLocalReference<jobject>(mirror::Method::CreateFromArtMethod(soa.Self(), result)) :
433      nullptr;
434}
435
436static jobjectArray Class_getDeclaredMethodsUnchecked(JNIEnv* env, jobject javaThis,
437                                                      jboolean publicOnly) {
438  ScopedFastNativeObjectAccess soa(env);
439  StackHandleScope<2> hs(soa.Self());
440  Handle<mirror::Class> klass = hs.NewHandle(DecodeClass(soa, javaThis));
441  size_t num_methods = 0;
442  for (auto& m : klass->GetVirtualMethods(sizeof(void*))) {
443    auto modifiers = m.GetAccessFlags();
444    if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) &&
445        (modifiers & kAccMiranda) == 0) {
446      ++num_methods;
447    }
448  }
449  for (auto& m : klass->GetDirectMethods(sizeof(void*))) {
450    auto modifiers = m.GetAccessFlags();
451    // Add non-constructor direct/static methods.
452    if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) &&
453        (modifiers & kAccConstructor) == 0) {
454      ++num_methods;
455    }
456  }
457  auto ret = hs.NewHandle(mirror::ObjectArray<mirror::Method>::Alloc(
458      soa.Self(), mirror::Method::ArrayClass(), num_methods));
459  num_methods = 0;
460  for (auto& m : klass->GetVirtualMethods(sizeof(void*))) {
461    auto modifiers = m.GetAccessFlags();
462    if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) &&
463        (modifiers & kAccMiranda) == 0) {
464      auto* method = mirror::Method::CreateFromArtMethod(soa.Self(), &m);
465      if (method == nullptr) {
466        soa.Self()->AssertPendingException();
467        return nullptr;
468      }
469      ret->SetWithoutChecks<false>(num_methods++, method);
470    }
471  }
472  for (auto& m : klass->GetDirectMethods(sizeof(void*))) {
473    auto modifiers = m.GetAccessFlags();
474    // Add non-constructor direct/static methods.
475    if ((publicOnly == JNI_FALSE || (modifiers & kAccPublic) != 0) &&
476        (modifiers & kAccConstructor) == 0) {
477      auto* method = mirror::Method::CreateFromArtMethod(soa.Self(), &m);
478      if (method == nullptr) {
479        soa.Self()->AssertPendingException();
480        return nullptr;
481      }
482      ret->SetWithoutChecks<false>(num_methods++, method);
483    }
484  }
485  return soa.AddLocalReference<jobjectArray>(ret.Get());
486}
487
488static jobject Class_getDeclaredAnnotation(JNIEnv* env, jobject javaThis, jclass annotationType) {
489  ScopedFastNativeObjectAccess soa(env);
490  StackHandleScope<2> hs(soa.Self());
491  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
492  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
493    return nullptr;
494  }
495  Handle<mirror::Class> annotation_class(hs.NewHandle(soa.Decode<mirror::Class*>(annotationType)));
496  return soa.AddLocalReference<jobject>(
497      klass->GetDexFile().GetAnnotationForClass(klass, annotation_class));
498}
499
500static jobjectArray Class_getDeclaredAnnotations(JNIEnv* env, jobject javaThis) {
501  ScopedFastNativeObjectAccess soa(env);
502  StackHandleScope<1> hs(soa.Self());
503  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
504  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
505    // Return an empty array instead of a null pointer.
506    mirror::Class* annotation_array_class =
507        soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_annotation_Annotation__array);
508    mirror::ObjectArray<mirror::Object>* empty_array =
509        mirror::ObjectArray<mirror::Object>::Alloc(soa.Self(), annotation_array_class, 0);
510    return soa.AddLocalReference<jobjectArray>(empty_array);
511  }
512  return soa.AddLocalReference<jobjectArray>(klass->GetDexFile().GetAnnotationsForClass(klass));
513}
514
515static jobjectArray Class_getDeclaredClasses(JNIEnv* env, jobject javaThis) {
516  ScopedFastNativeObjectAccess soa(env);
517  StackHandleScope<1> hs(soa.Self());
518  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
519  mirror::ObjectArray<mirror::Class>* classes = nullptr;
520  if (!klass->IsProxyClass() && klass->GetDexCache() != nullptr) {
521    classes = klass->GetDexFile().GetDeclaredClasses(klass);
522  }
523  if (classes == nullptr) {
524    // Return an empty array instead of a null pointer.
525    if (soa.Self()->IsExceptionPending()) {
526      // Pending exception from GetDeclaredClasses.
527      return nullptr;
528    }
529    mirror::Class* class_class = mirror::Class::GetJavaLangClass();
530    mirror::Class* class_array_class =
531        Runtime::Current()->GetClassLinker()->FindArrayClass(soa.Self(), &class_class);
532    if (class_array_class == nullptr) {
533      return nullptr;
534    }
535    mirror::ObjectArray<mirror::Class>* empty_array =
536        mirror::ObjectArray<mirror::Class>::Alloc(soa.Self(), class_array_class, 0);
537    return soa.AddLocalReference<jobjectArray>(empty_array);
538  }
539  return soa.AddLocalReference<jobjectArray>(classes);
540}
541
542static jclass Class_getEnclosingClass(JNIEnv* env, jobject javaThis) {
543  ScopedFastNativeObjectAccess soa(env);
544  StackHandleScope<1> hs(soa.Self());
545  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
546  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
547    return nullptr;
548  }
549  return soa.AddLocalReference<jclass>(klass->GetDexFile().GetEnclosingClass(klass));
550}
551
552static jobject Class_getEnclosingConstructorNative(JNIEnv* env, jobject javaThis) {
553  ScopedFastNativeObjectAccess soa(env);
554  StackHandleScope<1> hs(soa.Self());
555  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
556  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
557    return nullptr;
558  }
559  mirror::Object* method = klass->GetDexFile().GetEnclosingMethod(klass);
560  if (method != nullptr) {
561    if (method->GetClass() ==
562        soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_reflect_Constructor)) {
563      return soa.AddLocalReference<jobject>(method);
564    }
565  }
566  return nullptr;
567}
568
569static jobject Class_getEnclosingMethodNative(JNIEnv* env, jobject javaThis) {
570  ScopedFastNativeObjectAccess soa(env);
571  StackHandleScope<1> hs(soa.Self());
572  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
573  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
574    return nullptr;
575  }
576  mirror::Object* method = klass->GetDexFile().GetEnclosingMethod(klass);
577  if (method != nullptr) {
578    if (method->GetClass() ==
579        soa.Decode<mirror::Class*>(WellKnownClasses::java_lang_reflect_Method)) {
580      return soa.AddLocalReference<jobject>(method);
581    }
582  }
583  return nullptr;
584}
585
586static jint Class_getInnerClassFlags(JNIEnv* env, jobject javaThis, jint defaultValue) {
587  ScopedFastNativeObjectAccess soa(env);
588  StackHandleScope<1> hs(soa.Self());
589  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
590  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
591    return defaultValue;
592  }
593  uint32_t flags;
594  if (!klass->GetDexFile().GetInnerClassFlags(klass, &flags)) {
595    return defaultValue;
596  }
597  return flags;
598}
599
600static jstring Class_getInnerClassName(JNIEnv* env, jobject javaThis) {
601  ScopedFastNativeObjectAccess soa(env);
602  StackHandleScope<1> hs(soa.Self());
603  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
604  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
605    return nullptr;
606  }
607  mirror::String* class_name = nullptr;
608  if (!klass->GetDexFile().GetInnerClass(klass, &class_name)) {
609    return nullptr;
610  }
611  return soa.AddLocalReference<jstring>(class_name);
612}
613
614static jboolean Class_isAnonymousClass(JNIEnv* env, jobject javaThis) {
615  ScopedFastNativeObjectAccess soa(env);
616  StackHandleScope<1> hs(soa.Self());
617  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
618  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
619    return false;
620  }
621  mirror::String* class_name = nullptr;
622  if (!klass->GetDexFile().GetInnerClass(klass, &class_name)) {
623    return false;
624  }
625  return class_name == nullptr;
626}
627
628static jboolean Class_isDeclaredAnnotationPresent(JNIEnv* env, jobject javaThis,
629                                                  jclass annotationType) {
630  ScopedFastNativeObjectAccess soa(env);
631  StackHandleScope<2> hs(soa.Self());
632  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
633  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
634    return false;
635  }
636  Handle<mirror::Class> annotation_class(hs.NewHandle(soa.Decode<mirror::Class*>(annotationType)));
637  return klass->GetDexFile().IsClassAnnotationPresent(klass, annotation_class);
638}
639
640static jclass Class_getDeclaringClass(JNIEnv* env, jobject javaThis) {
641  ScopedFastNativeObjectAccess soa(env);
642  StackHandleScope<1> hs(soa.Self());
643  Handle<mirror::Class> klass(hs.NewHandle(DecodeClass(soa, javaThis)));
644  if (klass->IsProxyClass() || klass->GetDexCache() == nullptr) {
645    return nullptr;
646  }
647  // Return null for anonymous classes.
648  if (Class_isAnonymousClass(env, javaThis)) {
649    return nullptr;
650  }
651  return soa.AddLocalReference<jclass>(klass->GetDexFile().GetDeclaringClass(klass));
652}
653
654static jobject Class_newInstance(JNIEnv* env, jobject javaThis) {
655  ScopedFastNativeObjectAccess soa(env);
656  StackHandleScope<4> hs(soa.Self());
657  Handle<mirror::Class> klass = hs.NewHandle(DecodeClass(soa, javaThis));
658  if (UNLIKELY(klass->GetPrimitiveType() != 0 || klass->IsInterface() || klass->IsArrayClass() ||
659               klass->IsAbstract())) {
660    soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
661                                   "%s cannot be instantiated", PrettyClass(klass.Get()).c_str());
662    return nullptr;
663  }
664  auto caller = hs.NewHandle<mirror::Class>(nullptr);
665  // Verify that we can access the class.
666  if (!klass->IsPublic()) {
667    caller.Assign(GetCallingClass(soa.Self(), 1));
668    if (caller.Get() != nullptr && !caller->CanAccess(klass.Get())) {
669      soa.Self()->ThrowNewExceptionF(
670          "Ljava/lang/IllegalAccessException;", "%s is not accessible from %s",
671          PrettyClass(klass.Get()).c_str(), PrettyClass(caller.Get()).c_str());
672      return nullptr;
673    }
674  }
675  auto* constructor = klass->GetDeclaredConstructor(
676      soa.Self(), NullHandle<mirror::ObjectArray<mirror::Class>>());
677  if (UNLIKELY(constructor == nullptr)) {
678    soa.Self()->ThrowNewExceptionF("Ljava/lang/InstantiationException;",
679                                   "%s has no zero argument constructor",
680                                   PrettyClass(klass.Get()).c_str());
681    return nullptr;
682  }
683  // Invoke the string allocator to return an empty string for the string class.
684  if (klass->IsStringClass()) {
685    gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator();
686    mirror::SetStringCountVisitor visitor(0);
687    mirror::Object* obj = mirror::String::Alloc<true>(soa.Self(), 0, allocator_type, visitor);
688    if (UNLIKELY(soa.Self()->IsExceptionPending())) {
689      return nullptr;
690    } else {
691      return soa.AddLocalReference<jobject>(obj);
692    }
693  }
694  auto receiver = hs.NewHandle(klass->AllocObject(soa.Self()));
695  if (UNLIKELY(receiver.Get() == nullptr)) {
696    soa.Self()->AssertPendingOOMException();
697    return nullptr;
698  }
699  // Verify that we can access the constructor.
700  auto* declaring_class = constructor->GetDeclaringClass();
701  if (!constructor->IsPublic()) {
702    if (caller.Get() == nullptr) {
703      caller.Assign(GetCallingClass(soa.Self(), 1));
704    }
705    if (UNLIKELY(caller.Get() != nullptr && !VerifyAccess(
706        soa.Self(), receiver.Get(), declaring_class, constructor->GetAccessFlags(),
707        caller.Get()))) {
708      soa.Self()->ThrowNewExceptionF(
709          "Ljava/lang/IllegalAccessException;", "%s is not accessible from %s",
710          PrettyMethod(constructor).c_str(), PrettyClass(caller.Get()).c_str());
711      return nullptr;
712    }
713  }
714  // Ensure that we are initialized.
715  if (UNLIKELY(!declaring_class->IsInitialized())) {
716    if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(
717        soa.Self(), hs.NewHandle(declaring_class), true, true)) {
718      soa.Self()->AssertPendingException();
719      return nullptr;
720    }
721  }
722  // Invoke the constructor.
723  JValue result;
724  uint32_t args[1] = { static_cast<uint32_t>(reinterpret_cast<uintptr_t>(receiver.Get())) };
725  constructor->Invoke(soa.Self(), args, sizeof(args), &result, "V");
726  if (UNLIKELY(soa.Self()->IsExceptionPending())) {
727    return nullptr;
728  }
729  // Constructors are ()V methods, so we shouldn't touch the result of InvokeMethod.
730  return soa.AddLocalReference<jobject>(receiver.Get());
731}
732
733static JNINativeMethod gMethods[] = {
734  NATIVE_METHOD(Class, classForName,
735                "!(Ljava/lang/String;ZLjava/lang/ClassLoader;)Ljava/lang/Class;"),
736  NATIVE_METHOD(Class, getDeclaredAnnotation,
737                "!(Ljava/lang/Class;)Ljava/lang/annotation/Annotation;"),
738  NATIVE_METHOD(Class, getDeclaredAnnotations, "!()[Ljava/lang/annotation/Annotation;"),
739  NATIVE_METHOD(Class, getDeclaredClasses, "!()[Ljava/lang/Class;"),
740  NATIVE_METHOD(Class, getDeclaredConstructorInternal,
741                "!([Ljava/lang/Class;)Ljava/lang/reflect/Constructor;"),
742  NATIVE_METHOD(Class, getDeclaredConstructorsInternal, "!(Z)[Ljava/lang/reflect/Constructor;"),
743  NATIVE_METHOD(Class, getDeclaredField, "!(Ljava/lang/String;)Ljava/lang/reflect/Field;"),
744  NATIVE_METHOD(Class, getPublicFieldRecursive, "!(Ljava/lang/String;)Ljava/lang/reflect/Field;"),
745  NATIVE_METHOD(Class, getDeclaredFieldInternal, "!(Ljava/lang/String;)Ljava/lang/reflect/Field;"),
746  NATIVE_METHOD(Class, getDeclaredFields, "!()[Ljava/lang/reflect/Field;"),
747  NATIVE_METHOD(Class, getDeclaredFieldsUnchecked, "!(Z)[Ljava/lang/reflect/Field;"),
748  NATIVE_METHOD(Class, getDeclaredMethodInternal,
749                "!(Ljava/lang/String;[Ljava/lang/Class;)Ljava/lang/reflect/Method;"),
750  NATIVE_METHOD(Class, getDeclaredMethodsUnchecked,
751                "!(Z)[Ljava/lang/reflect/Method;"),
752  NATIVE_METHOD(Class, getDeclaringClass, "!()Ljava/lang/Class;"),
753  NATIVE_METHOD(Class, getEnclosingClass, "!()Ljava/lang/Class;"),
754  NATIVE_METHOD(Class, getEnclosingConstructorNative, "!()Ljava/lang/reflect/Constructor;"),
755  NATIVE_METHOD(Class, getEnclosingMethodNative, "!()Ljava/lang/reflect/Method;"),
756  NATIVE_METHOD(Class, getInnerClassFlags, "!(I)I"),
757  NATIVE_METHOD(Class, getInnerClassName, "!()Ljava/lang/String;"),
758  NATIVE_METHOD(Class, getNameNative, "!()Ljava/lang/String;"),
759  NATIVE_METHOD(Class, getProxyInterfaces, "!()[Ljava/lang/Class;"),
760  NATIVE_METHOD(Class, getPublicDeclaredFields, "!()[Ljava/lang/reflect/Field;"),
761  NATIVE_METHOD(Class, isAnonymousClass, "!()Z"),
762  NATIVE_METHOD(Class, isDeclaredAnnotationPresent, "!(Ljava/lang/Class;)Z"),
763  NATIVE_METHOD(Class, newInstance, "!()Ljava/lang/Object;"),
764};
765
766void register_java_lang_Class(JNIEnv* env) {
767  REGISTER_NATIVE_METHODS("java/lang/Class");
768}
769
770}  // namespace art
771