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