1 /*
2  * Copyright (C) 2016 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 "dex_file_annotations.h"
18 
19 #include <stdlib.h>
20 
21 #include "android-base/stringprintf.h"
22 
23 #include "art_field-inl.h"
24 #include "art_method-inl.h"
25 #include "class_linker-inl.h"
26 #include "dex_file-inl.h"
27 #include "jni_internal.h"
28 #include "jvalue-inl.h"
29 #include "mirror/field.h"
30 #include "mirror/method.h"
31 #include "reflection.h"
32 #include "thread.h"
33 
34 namespace art {
35 
36 using android::base::StringPrintf;
37 
38 struct DexFile::AnnotationValue {
39   JValue value_;
40   uint8_t type_;
41 };
42 
43 namespace {
44 
45 // A helper class that contains all the data needed to do annotation lookup.
46 class ClassData {
47  public:
REQUIRES_SHARED(Locks::mutator_lock_)48   explicit ClassData(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_)
49     : ClassData(ScopedNullHandle<mirror::Class>(),  // klass
50                 method,
51                 *method->GetDexFile(),
52                 &method->GetClassDef()) {}
53 
54   // Requires Scope to be able to create at least 1 handles.
55   template <typename Scope>
ClassData(Scope & hs,ArtField * field)56   ClassData(Scope& hs, ArtField* field) REQUIRES_SHARED(Locks::mutator_lock_)
57     : ClassData(hs.NewHandle(field->GetDeclaringClass())) { }
58 
REQUIRES_SHARED(art::Locks::mutator_lock_)59   explicit ClassData(Handle<mirror::Class> klass) REQUIRES_SHARED(art::Locks::mutator_lock_)
60     : ClassData(klass,  // klass
61                 nullptr,  // method
62                 klass->GetDexFile(),
63                 klass->GetClassDef()) {}
64 
GetDexFile() const65   const DexFile& GetDexFile() const REQUIRES_SHARED(Locks::mutator_lock_) {
66     return dex_file_;
67   }
68 
GetClassDef() const69   const DexFile::ClassDef* GetClassDef() const REQUIRES_SHARED(Locks::mutator_lock_) {
70     return class_def_;
71   }
72 
GetDexCache() const73   ObjPtr<mirror::DexCache> GetDexCache() const REQUIRES_SHARED(Locks::mutator_lock_) {
74     if (method_ != nullptr) {
75       return method_->GetDexCache();
76     } else {
77       return real_klass_->GetDexCache();
78     }
79   }
80 
GetClassLoader() const81   ObjPtr<mirror::ClassLoader> GetClassLoader() const REQUIRES_SHARED(Locks::mutator_lock_) {
82     if (method_ != nullptr) {
83       return method_->GetDeclaringClass()->GetClassLoader();
84     } else {
85       return real_klass_->GetClassLoader();
86     }
87   }
88 
GetRealClass() const89   ObjPtr<mirror::Class> GetRealClass() const REQUIRES_SHARED(Locks::mutator_lock_) {
90     if (method_ != nullptr) {
91       return method_->GetDeclaringClass();
92     } else {
93       return real_klass_.Get();
94     }
95   }
96 
97  private:
ClassData(Handle<mirror::Class> klass,ArtMethod * method,const DexFile & dex_file,const DexFile::ClassDef * class_def)98   ClassData(Handle<mirror::Class> klass,
99             ArtMethod* method,
100             const DexFile& dex_file,
101             const DexFile::ClassDef* class_def) REQUIRES_SHARED(Locks::mutator_lock_)
102       : real_klass_(klass),
103         method_(method),
104         dex_file_(dex_file),
105         class_def_(class_def) {
106     DCHECK((method_ == nullptr) || real_klass_.IsNull());
107   }
108 
109   Handle<mirror::Class> real_klass_;
110   ArtMethod* method_;
111   const DexFile& dex_file_;
112   const DexFile::ClassDef* class_def_;
113 
114   DISALLOW_COPY_AND_ASSIGN(ClassData);
115 };
116 
117 mirror::Object* CreateAnnotationMember(const ClassData& klass,
118                                        Handle<mirror::Class> annotation_class,
119                                        const uint8_t** annotation)
120     REQUIRES_SHARED(Locks::mutator_lock_);
121 
IsVisibilityCompatible(uint32_t actual,uint32_t expected)122 bool IsVisibilityCompatible(uint32_t actual, uint32_t expected) {
123   if (expected == DexFile::kDexVisibilityRuntime) {
124     int32_t sdk_version = Runtime::Current()->GetTargetSdkVersion();
125     if (sdk_version > 0 && sdk_version <= 23) {
126       return actual == DexFile::kDexVisibilityRuntime || actual == DexFile::kDexVisibilityBuild;
127     }
128   }
129   return actual == expected;
130 }
131 
FindAnnotationSetForField(ArtField * field)132 const DexFile::AnnotationSetItem* FindAnnotationSetForField(ArtField* field)
133     REQUIRES_SHARED(Locks::mutator_lock_) {
134   const DexFile* dex_file = field->GetDexFile();
135   ObjPtr<mirror::Class> klass = field->GetDeclaringClass();
136   const DexFile::AnnotationsDirectoryItem* annotations_dir =
137       dex_file->GetAnnotationsDirectory(*klass->GetClassDef());
138   if (annotations_dir == nullptr) {
139     return nullptr;
140   }
141   const DexFile::FieldAnnotationsItem* field_annotations =
142       dex_file->GetFieldAnnotations(annotations_dir);
143   if (field_annotations == nullptr) {
144     return nullptr;
145   }
146   uint32_t field_index = field->GetDexFieldIndex();
147   uint32_t field_count = annotations_dir->fields_size_;
148   for (uint32_t i = 0; i < field_count; ++i) {
149     if (field_annotations[i].field_idx_ == field_index) {
150       return dex_file->GetFieldAnnotationSetItem(field_annotations[i]);
151     }
152   }
153   return nullptr;
154 }
155 
SearchAnnotationSet(const DexFile & dex_file,const DexFile::AnnotationSetItem * annotation_set,const char * descriptor,uint32_t visibility)156 const DexFile::AnnotationItem* SearchAnnotationSet(const DexFile& dex_file,
157                                                    const DexFile::AnnotationSetItem* annotation_set,
158                                                    const char* descriptor,
159                                                    uint32_t visibility)
160     REQUIRES_SHARED(Locks::mutator_lock_) {
161   const DexFile::AnnotationItem* result = nullptr;
162   for (uint32_t i = 0; i < annotation_set->size_; ++i) {
163     const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
164     if (!IsVisibilityCompatible(annotation_item->visibility_, visibility)) {
165       continue;
166     }
167     const uint8_t* annotation = annotation_item->annotation_;
168     uint32_t type_index = DecodeUnsignedLeb128(&annotation);
169 
170     if (strcmp(descriptor, dex_file.StringByTypeIdx(dex::TypeIndex(type_index))) == 0) {
171       result = annotation_item;
172       break;
173     }
174   }
175   return result;
176 }
177 
SkipAnnotationValue(const DexFile & dex_file,const uint8_t ** annotation_ptr)178 bool SkipAnnotationValue(const DexFile& dex_file, const uint8_t** annotation_ptr)
179     REQUIRES_SHARED(Locks::mutator_lock_) {
180   const uint8_t* annotation = *annotation_ptr;
181   uint8_t header_byte = *(annotation++);
182   uint8_t value_type = header_byte & DexFile::kDexAnnotationValueTypeMask;
183   uint8_t value_arg = header_byte >> DexFile::kDexAnnotationValueArgShift;
184   int32_t width = value_arg + 1;
185 
186   switch (value_type) {
187     case DexFile::kDexAnnotationByte:
188     case DexFile::kDexAnnotationShort:
189     case DexFile::kDexAnnotationChar:
190     case DexFile::kDexAnnotationInt:
191     case DexFile::kDexAnnotationLong:
192     case DexFile::kDexAnnotationFloat:
193     case DexFile::kDexAnnotationDouble:
194     case DexFile::kDexAnnotationString:
195     case DexFile::kDexAnnotationType:
196     case DexFile::kDexAnnotationMethod:
197     case DexFile::kDexAnnotationField:
198     case DexFile::kDexAnnotationEnum:
199       break;
200     case DexFile::kDexAnnotationArray:
201     {
202       uint32_t size = DecodeUnsignedLeb128(&annotation);
203       while (size--) {
204         if (!SkipAnnotationValue(dex_file, &annotation)) {
205           return false;
206         }
207       }
208       width = 0;
209       break;
210     }
211     case DexFile::kDexAnnotationAnnotation:
212     {
213       DecodeUnsignedLeb128(&annotation);  // unused type_index
214       uint32_t size = DecodeUnsignedLeb128(&annotation);
215       while (size--) {
216         DecodeUnsignedLeb128(&annotation);  // unused element_name_index
217         if (!SkipAnnotationValue(dex_file, &annotation)) {
218           return false;
219         }
220       }
221       width = 0;
222       break;
223     }
224     case DexFile::kDexAnnotationBoolean:
225     case DexFile::kDexAnnotationNull:
226       width = 0;
227       break;
228     default:
229       LOG(FATAL) << StringPrintf("Bad annotation element value byte 0x%02x", value_type);
230       return false;
231   }
232 
233   annotation += width;
234   *annotation_ptr = annotation;
235   return true;
236 }
237 
SearchEncodedAnnotation(const DexFile & dex_file,const uint8_t * annotation,const char * name)238 const uint8_t* SearchEncodedAnnotation(const DexFile& dex_file,
239                                        const uint8_t* annotation,
240                                        const char* name)
241     REQUIRES_SHARED(Locks::mutator_lock_) {
242   DecodeUnsignedLeb128(&annotation);  // unused type_index
243   uint32_t size = DecodeUnsignedLeb128(&annotation);
244 
245   while (size != 0) {
246     uint32_t element_name_index = DecodeUnsignedLeb128(&annotation);
247     const char* element_name =
248         dex_file.GetStringData(dex_file.GetStringId(dex::StringIndex(element_name_index)));
249     if (strcmp(name, element_name) == 0) {
250       return annotation;
251     }
252     SkipAnnotationValue(dex_file, &annotation);
253     size--;
254   }
255   return nullptr;
256 }
257 
FindAnnotationSetForMethod(ArtMethod * method)258 const DexFile::AnnotationSetItem* FindAnnotationSetForMethod(ArtMethod* method)
259     REQUIRES_SHARED(Locks::mutator_lock_) {
260   const DexFile* dex_file = method->GetDexFile();
261   const DexFile::AnnotationsDirectoryItem* annotations_dir =
262       dex_file->GetAnnotationsDirectory(method->GetClassDef());
263   if (annotations_dir == nullptr) {
264     return nullptr;
265   }
266   const DexFile::MethodAnnotationsItem* method_annotations =
267       dex_file->GetMethodAnnotations(annotations_dir);
268   if (method_annotations == nullptr) {
269     return nullptr;
270   }
271   uint32_t method_index = method->GetDexMethodIndex();
272   uint32_t method_count = annotations_dir->methods_size_;
273   for (uint32_t i = 0; i < method_count; ++i) {
274     if (method_annotations[i].method_idx_ == method_index) {
275       return dex_file->GetMethodAnnotationSetItem(method_annotations[i]);
276     }
277   }
278   return nullptr;
279 }
280 
FindAnnotationsItemForMethod(ArtMethod * method)281 const DexFile::ParameterAnnotationsItem* FindAnnotationsItemForMethod(ArtMethod* method)
282     REQUIRES_SHARED(Locks::mutator_lock_) {
283   const DexFile* dex_file = method->GetDexFile();
284   const DexFile::AnnotationsDirectoryItem* annotations_dir =
285       dex_file->GetAnnotationsDirectory(method->GetClassDef());
286   if (annotations_dir == nullptr) {
287     return nullptr;
288   }
289   const DexFile::ParameterAnnotationsItem* parameter_annotations =
290       dex_file->GetParameterAnnotations(annotations_dir);
291   if (parameter_annotations == nullptr) {
292     return nullptr;
293   }
294   uint32_t method_index = method->GetDexMethodIndex();
295   uint32_t parameter_count = annotations_dir->parameters_size_;
296   for (uint32_t i = 0; i < parameter_count; ++i) {
297     if (parameter_annotations[i].method_idx_ == method_index) {
298       return &parameter_annotations[i];
299     }
300   }
301   return nullptr;
302 }
303 
FindAnnotationSetForClass(const ClassData & klass)304 const DexFile::AnnotationSetItem* FindAnnotationSetForClass(const ClassData& klass)
305     REQUIRES_SHARED(Locks::mutator_lock_) {
306   const DexFile& dex_file = klass.GetDexFile();
307   const DexFile::AnnotationsDirectoryItem* annotations_dir =
308       dex_file.GetAnnotationsDirectory(*klass.GetClassDef());
309   if (annotations_dir == nullptr) {
310     return nullptr;
311   }
312   return dex_file.GetClassAnnotationSet(annotations_dir);
313 }
314 
ProcessEncodedAnnotation(const ClassData & klass,const uint8_t ** annotation)315 mirror::Object* ProcessEncodedAnnotation(const ClassData& klass, const uint8_t** annotation)
316     REQUIRES_SHARED(Locks::mutator_lock_) {
317   uint32_t type_index = DecodeUnsignedLeb128(annotation);
318   uint32_t size = DecodeUnsignedLeb128(annotation);
319 
320   Thread* self = Thread::Current();
321   ScopedObjectAccessUnchecked soa(self);
322   StackHandleScope<4> hs(self);
323   ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
324   Handle<mirror::Class> annotation_class(hs.NewHandle(
325       class_linker->ResolveType(klass.GetDexFile(),
326                                 dex::TypeIndex(type_index),
327                                 hs.NewHandle(klass.GetDexCache()),
328                                 hs.NewHandle(klass.GetClassLoader()))));
329   if (annotation_class == nullptr) {
330     LOG(INFO) << "Unable to resolve " << klass.GetRealClass()->PrettyClass()
331               << " annotation class " << type_index;
332     DCHECK(Thread::Current()->IsExceptionPending());
333     Thread::Current()->ClearException();
334     return nullptr;
335   }
336 
337   ObjPtr<mirror::Class> annotation_member_class =
338       soa.Decode<mirror::Class>(WellKnownClasses::libcore_reflect_AnnotationMember).Ptr();
339   mirror::Class* annotation_member_array_class =
340       class_linker->FindArrayClass(self, &annotation_member_class);
341   if (annotation_member_array_class == nullptr) {
342     return nullptr;
343   }
344   mirror::ObjectArray<mirror::Object>* element_array = nullptr;
345   if (size > 0) {
346     element_array =
347         mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_member_array_class, size);
348     if (element_array == nullptr) {
349       LOG(ERROR) << "Failed to allocate annotation member array (" << size << " elements)";
350       return nullptr;
351     }
352   }
353 
354   Handle<mirror::ObjectArray<mirror::Object>> h_element_array(hs.NewHandle(element_array));
355   for (uint32_t i = 0; i < size; ++i) {
356     mirror::Object* new_member = CreateAnnotationMember(klass, annotation_class, annotation);
357     if (new_member == nullptr) {
358       return nullptr;
359     }
360     h_element_array->SetWithoutChecks<false>(i, new_member);
361   }
362 
363   JValue result;
364   ArtMethod* create_annotation_method =
365       jni::DecodeArtMethod(WellKnownClasses::libcore_reflect_AnnotationFactory_createAnnotation);
366   uint32_t args[2] = { static_cast<uint32_t>(reinterpret_cast<uintptr_t>(annotation_class.Get())),
367                        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(h_element_array.Get())) };
368   create_annotation_method->Invoke(self, args, sizeof(args), &result, "LLL");
369   if (self->IsExceptionPending()) {
370     LOG(INFO) << "Exception in AnnotationFactory.createAnnotation";
371     return nullptr;
372   }
373 
374   return result.GetL();
375 }
376 
377 template <bool kTransactionActive>
ProcessAnnotationValue(const ClassData & klass,const uint8_t ** annotation_ptr,DexFile::AnnotationValue * annotation_value,Handle<mirror::Class> array_class,DexFile::AnnotationResultStyle result_style)378 bool ProcessAnnotationValue(const ClassData& klass,
379                             const uint8_t** annotation_ptr,
380                             DexFile::AnnotationValue* annotation_value,
381                             Handle<mirror::Class> array_class,
382                             DexFile::AnnotationResultStyle result_style)
383     REQUIRES_SHARED(Locks::mutator_lock_) {
384   const DexFile& dex_file = klass.GetDexFile();
385   Thread* self = Thread::Current();
386   ObjPtr<mirror::Object> element_object = nullptr;
387   bool set_object = false;
388   Primitive::Type primitive_type = Primitive::kPrimVoid;
389   const uint8_t* annotation = *annotation_ptr;
390   uint8_t header_byte = *(annotation++);
391   uint8_t value_type = header_byte & DexFile::kDexAnnotationValueTypeMask;
392   uint8_t value_arg = header_byte >> DexFile::kDexAnnotationValueArgShift;
393   int32_t width = value_arg + 1;
394   annotation_value->type_ = value_type;
395 
396   switch (value_type) {
397     case DexFile::kDexAnnotationByte:
398       annotation_value->value_.SetB(
399           static_cast<int8_t>(DexFile::ReadSignedInt(annotation, value_arg)));
400       primitive_type = Primitive::kPrimByte;
401       break;
402     case DexFile::kDexAnnotationShort:
403       annotation_value->value_.SetS(
404           static_cast<int16_t>(DexFile::ReadSignedInt(annotation, value_arg)));
405       primitive_type = Primitive::kPrimShort;
406       break;
407     case DexFile::kDexAnnotationChar:
408       annotation_value->value_.SetC(
409           static_cast<uint16_t>(DexFile::ReadUnsignedInt(annotation, value_arg, false)));
410       primitive_type = Primitive::kPrimChar;
411       break;
412     case DexFile::kDexAnnotationInt:
413       annotation_value->value_.SetI(DexFile::ReadSignedInt(annotation, value_arg));
414       primitive_type = Primitive::kPrimInt;
415       break;
416     case DexFile::kDexAnnotationLong:
417       annotation_value->value_.SetJ(DexFile::ReadSignedLong(annotation, value_arg));
418       primitive_type = Primitive::kPrimLong;
419       break;
420     case DexFile::kDexAnnotationFloat:
421       annotation_value->value_.SetI(DexFile::ReadUnsignedInt(annotation, value_arg, true));
422       primitive_type = Primitive::kPrimFloat;
423       break;
424     case DexFile::kDexAnnotationDouble:
425       annotation_value->value_.SetJ(DexFile::ReadUnsignedLong(annotation, value_arg, true));
426       primitive_type = Primitive::kPrimDouble;
427       break;
428     case DexFile::kDexAnnotationBoolean:
429       annotation_value->value_.SetZ(value_arg != 0);
430       primitive_type = Primitive::kPrimBoolean;
431       width = 0;
432       break;
433     case DexFile::kDexAnnotationString: {
434       uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false);
435       if (result_style == DexFile::kAllRaw) {
436         annotation_value->value_.SetI(index);
437       } else {
438         StackHandleScope<1> hs(self);
439         element_object = Runtime::Current()->GetClassLinker()->ResolveString(
440             klass.GetDexFile(), dex::StringIndex(index), hs.NewHandle(klass.GetDexCache()));
441         set_object = true;
442         if (element_object == nullptr) {
443           return false;
444         }
445       }
446       break;
447     }
448     case DexFile::kDexAnnotationType: {
449       uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false);
450       if (result_style == DexFile::kAllRaw) {
451         annotation_value->value_.SetI(index);
452       } else {
453         dex::TypeIndex type_index(index);
454         StackHandleScope<2> hs(self);
455         element_object = Runtime::Current()->GetClassLinker()->ResolveType(
456             klass.GetDexFile(),
457             type_index,
458             hs.NewHandle(klass.GetDexCache()),
459             hs.NewHandle(klass.GetClassLoader()));
460         set_object = true;
461         if (element_object == nullptr) {
462           CHECK(self->IsExceptionPending());
463           if (result_style == DexFile::kAllObjects) {
464             const char* msg = dex_file.StringByTypeIdx(type_index);
465             self->ThrowNewWrappedException("Ljava/lang/TypeNotPresentException;", msg);
466             element_object = self->GetException();
467             self->ClearException();
468           } else {
469             return false;
470           }
471         }
472       }
473       break;
474     }
475     case DexFile::kDexAnnotationMethod: {
476       uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false);
477       if (result_style == DexFile::kAllRaw) {
478         annotation_value->value_.SetI(index);
479       } else {
480         ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
481         StackHandleScope<2> hs(self);
482         ArtMethod* method = class_linker->ResolveMethodWithoutInvokeType(
483             klass.GetDexFile(),
484             index,
485             hs.NewHandle(klass.GetDexCache()),
486             hs.NewHandle(klass.GetClassLoader()));
487         if (method == nullptr) {
488           return false;
489         }
490         PointerSize pointer_size = class_linker->GetImagePointerSize();
491         set_object = true;
492         if (method->IsConstructor()) {
493           if (pointer_size == PointerSize::k64) {
494             element_object = mirror::Constructor::CreateFromArtMethod<PointerSize::k64,
495                 kTransactionActive>(self, method);
496           } else {
497             element_object = mirror::Constructor::CreateFromArtMethod<PointerSize::k32,
498                 kTransactionActive>(self, method);
499           }
500         } else {
501           if (pointer_size == PointerSize::k64) {
502             element_object = mirror::Method::CreateFromArtMethod<PointerSize::k64,
503                 kTransactionActive>(self, method);
504           } else {
505             element_object = mirror::Method::CreateFromArtMethod<PointerSize::k32,
506                 kTransactionActive>(self, method);
507           }
508         }
509         if (element_object == nullptr) {
510           return false;
511         }
512       }
513       break;
514     }
515     case DexFile::kDexAnnotationField: {
516       uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false);
517       if (result_style == DexFile::kAllRaw) {
518         annotation_value->value_.SetI(index);
519       } else {
520         StackHandleScope<2> hs(self);
521         ArtField* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS(
522             klass.GetDexFile(),
523             index,
524             hs.NewHandle(klass.GetDexCache()),
525             hs.NewHandle(klass.GetClassLoader()));
526         if (field == nullptr) {
527           return false;
528         }
529         set_object = true;
530         PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
531         if (pointer_size == PointerSize::k64) {
532           element_object = mirror::Field::CreateFromArtField<PointerSize::k64,
533               kTransactionActive>(self, field, true);
534         } else {
535           element_object = mirror::Field::CreateFromArtField<PointerSize::k32,
536               kTransactionActive>(self, field, true);
537         }
538         if (element_object == nullptr) {
539           return false;
540         }
541       }
542       break;
543     }
544     case DexFile::kDexAnnotationEnum: {
545       uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false);
546       if (result_style == DexFile::kAllRaw) {
547         annotation_value->value_.SetI(index);
548       } else {
549         StackHandleScope<3> hs(self);
550         ArtField* enum_field = Runtime::Current()->GetClassLinker()->ResolveField(
551             klass.GetDexFile(),
552             index,
553             hs.NewHandle(klass.GetDexCache()),
554             hs.NewHandle(klass.GetClassLoader()),
555             true);
556         if (enum_field == nullptr) {
557           return false;
558         } else {
559           Handle<mirror::Class> field_class(hs.NewHandle(enum_field->GetDeclaringClass()));
560           Runtime::Current()->GetClassLinker()->EnsureInitialized(self, field_class, true, true);
561           element_object = enum_field->GetObject(field_class.Get());
562           set_object = true;
563         }
564       }
565       break;
566     }
567     case DexFile::kDexAnnotationArray:
568       if (result_style == DexFile::kAllRaw || array_class == nullptr) {
569         return false;
570       } else {
571         ScopedObjectAccessUnchecked soa(self);
572         StackHandleScope<2> hs(self);
573         uint32_t size = DecodeUnsignedLeb128(&annotation);
574         Handle<mirror::Class> component_type(hs.NewHandle(array_class->GetComponentType()));
575         Handle<mirror::Array> new_array(hs.NewHandle(mirror::Array::Alloc<true>(
576             self, array_class.Get(), size, array_class->GetComponentSizeShift(),
577             Runtime::Current()->GetHeap()->GetCurrentAllocator())));
578         if (new_array == nullptr) {
579           LOG(ERROR) << "Annotation element array allocation failed with size " << size;
580           return false;
581         }
582         DexFile::AnnotationValue new_annotation_value;
583         for (uint32_t i = 0; i < size; ++i) {
584           if (!ProcessAnnotationValue<kTransactionActive>(klass,
585                                                           &annotation,
586                                                           &new_annotation_value,
587                                                           component_type,
588                                                           DexFile::kPrimitivesOrObjects)) {
589             return false;
590           }
591           if (!component_type->IsPrimitive()) {
592             mirror::Object* obj = new_annotation_value.value_.GetL();
593             new_array->AsObjectArray<mirror::Object>()->
594                 SetWithoutChecks<kTransactionActive>(i, obj);
595           } else {
596             switch (new_annotation_value.type_) {
597               case DexFile::kDexAnnotationByte:
598                 new_array->AsByteArray()->SetWithoutChecks<kTransactionActive>(
599                     i, new_annotation_value.value_.GetB());
600                 break;
601               case DexFile::kDexAnnotationShort:
602                 new_array->AsShortArray()->SetWithoutChecks<kTransactionActive>(
603                     i, new_annotation_value.value_.GetS());
604                 break;
605               case DexFile::kDexAnnotationChar:
606                 new_array->AsCharArray()->SetWithoutChecks<kTransactionActive>(
607                     i, new_annotation_value.value_.GetC());
608                 break;
609               case DexFile::kDexAnnotationInt:
610                 new_array->AsIntArray()->SetWithoutChecks<kTransactionActive>(
611                     i, new_annotation_value.value_.GetI());
612                 break;
613               case DexFile::kDexAnnotationLong:
614                 new_array->AsLongArray()->SetWithoutChecks<kTransactionActive>(
615                     i, new_annotation_value.value_.GetJ());
616                 break;
617               case DexFile::kDexAnnotationFloat:
618                 new_array->AsFloatArray()->SetWithoutChecks<kTransactionActive>(
619                     i, new_annotation_value.value_.GetF());
620                 break;
621               case DexFile::kDexAnnotationDouble:
622                 new_array->AsDoubleArray()->SetWithoutChecks<kTransactionActive>(
623                     i, new_annotation_value.value_.GetD());
624                 break;
625               case DexFile::kDexAnnotationBoolean:
626                 new_array->AsBooleanArray()->SetWithoutChecks<kTransactionActive>(
627                     i, new_annotation_value.value_.GetZ());
628                 break;
629               default:
630                 LOG(FATAL) << "Found invalid annotation value type while building annotation array";
631                 return false;
632             }
633           }
634         }
635         element_object = new_array.Get();
636         set_object = true;
637         width = 0;
638       }
639       break;
640     case DexFile::kDexAnnotationAnnotation:
641       if (result_style == DexFile::kAllRaw) {
642         return false;
643       }
644       element_object = ProcessEncodedAnnotation(klass, &annotation);
645       if (element_object == nullptr) {
646         return false;
647       }
648       set_object = true;
649       width = 0;
650       break;
651     case DexFile::kDexAnnotationNull:
652       if (result_style == DexFile::kAllRaw) {
653         annotation_value->value_.SetI(0);
654       } else {
655         CHECK(element_object == nullptr);
656         set_object = true;
657       }
658       width = 0;
659       break;
660     default:
661       LOG(ERROR) << StringPrintf("Bad annotation element value type 0x%02x", value_type);
662       return false;
663   }
664 
665   annotation += width;
666   *annotation_ptr = annotation;
667 
668   if (result_style == DexFile::kAllObjects && primitive_type != Primitive::kPrimVoid) {
669     element_object = BoxPrimitive(primitive_type, annotation_value->value_).Ptr();
670     set_object = true;
671   }
672 
673   if (set_object) {
674     annotation_value->value_.SetL(element_object.Ptr());
675   }
676 
677   return true;
678 }
679 
CreateAnnotationMember(const ClassData & klass,Handle<mirror::Class> annotation_class,const uint8_t ** annotation)680 mirror::Object* CreateAnnotationMember(const ClassData& klass,
681                                        Handle<mirror::Class> annotation_class,
682                                        const uint8_t** annotation) {
683   const DexFile& dex_file = klass.GetDexFile();
684   Thread* self = Thread::Current();
685   ScopedObjectAccessUnchecked soa(self);
686   StackHandleScope<5> hs(self);
687   uint32_t element_name_index = DecodeUnsignedLeb128(annotation);
688   const char* name = dex_file.StringDataByIdx(dex::StringIndex(element_name_index));
689   Handle<mirror::String> string_name(
690       hs.NewHandle(mirror::String::AllocFromModifiedUtf8(self, name)));
691 
692   PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
693   ArtMethod* annotation_method =
694       annotation_class->FindDeclaredVirtualMethodByName(name, pointer_size);
695   if (annotation_method == nullptr) {
696     return nullptr;
697   }
698   Handle<mirror::Class> method_return(hs.NewHandle(
699       annotation_method->GetReturnType(true /* resolve */)));
700 
701   DexFile::AnnotationValue annotation_value;
702   if (!ProcessAnnotationValue<false>(klass,
703                                      annotation,
704                                      &annotation_value,
705                                      method_return,
706                                      DexFile::kAllObjects)) {
707     return nullptr;
708   }
709   Handle<mirror::Object> value_object(hs.NewHandle(annotation_value.value_.GetL()));
710 
711   ObjPtr<mirror::Class> annotation_member_class =
712       WellKnownClasses::ToClass(WellKnownClasses::libcore_reflect_AnnotationMember);
713   Handle<mirror::Object> new_member(hs.NewHandle(annotation_member_class->AllocObject(self)));
714   mirror::Method* method_obj_ptr;
715   DCHECK(!Runtime::Current()->IsActiveTransaction());
716   if (pointer_size == PointerSize::k64) {
717     method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k64, false>(
718         self, annotation_method);
719   } else {
720     method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k32, false>(
721         self, annotation_method);
722   }
723   Handle<mirror::Method> method_object(hs.NewHandle(method_obj_ptr));
724 
725   if (new_member == nullptr || string_name == nullptr ||
726       method_object == nullptr || method_return == nullptr) {
727     LOG(ERROR) << StringPrintf("Failed creating annotation element (m=%p n=%p a=%p r=%p",
728         new_member.Get(), string_name.Get(), method_object.Get(), method_return.Get());
729     return nullptr;
730   }
731 
732   JValue result;
733   ArtMethod* annotation_member_init =
734       jni::DecodeArtMethod(WellKnownClasses::libcore_reflect_AnnotationMember_init);
735   uint32_t args[5] = { static_cast<uint32_t>(reinterpret_cast<uintptr_t>(new_member.Get())),
736                        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(string_name.Get())),
737                        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(value_object.Get())),
738                        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(method_return.Get())),
739                        static_cast<uint32_t>(reinterpret_cast<uintptr_t>(method_object.Get()))
740   };
741   annotation_member_init->Invoke(self, args, sizeof(args), &result, "VLLLL");
742   if (self->IsExceptionPending()) {
743     LOG(INFO) << "Exception in AnnotationMember.<init>";
744     return nullptr;
745   }
746 
747   return new_member.Get();
748 }
749 
GetAnnotationItemFromAnnotationSet(const ClassData & klass,const DexFile::AnnotationSetItem * annotation_set,uint32_t visibility,Handle<mirror::Class> annotation_class,bool lookup_in_resolved_boot_classes=false)750 const DexFile::AnnotationItem* GetAnnotationItemFromAnnotationSet(
751     const ClassData& klass,
752     const DexFile::AnnotationSetItem* annotation_set,
753     uint32_t visibility,
754     Handle<mirror::Class> annotation_class,
755     bool lookup_in_resolved_boot_classes = false)
756     REQUIRES_SHARED(Locks::mutator_lock_) {
757   const DexFile& dex_file = klass.GetDexFile();
758   for (uint32_t i = 0; i < annotation_set->size_; ++i) {
759     const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
760     if (!IsVisibilityCompatible(annotation_item->visibility_, visibility)) {
761       continue;
762     }
763     const uint8_t* annotation = annotation_item->annotation_;
764     uint32_t type_index = DecodeUnsignedLeb128(&annotation);
765     mirror::Class* resolved_class;
766     if (lookup_in_resolved_boot_classes) {
767       ObjPtr<mirror::Class> looked_up_class =
768           Runtime::Current()->GetClassLinker()->LookupResolvedType(
769               klass.GetDexFile(),
770               dex::TypeIndex(type_index),
771               klass.GetDexCache(),
772               // Force the use of the bootstrap class loader.
773               static_cast<mirror::ClassLoader*>(nullptr));
774       resolved_class = looked_up_class.Ptr();
775       if (resolved_class == nullptr) {
776         // If `resolved_class` is null, this is fine: just ignore that
777         // annotation item. We expect this to happen, as we do not
778         // attempt to resolve the annotation's class in this code path.
779         continue;
780       }
781     } else {
782       StackHandleScope<2> hs(Thread::Current());
783       resolved_class = Runtime::Current()->GetClassLinker()->ResolveType(
784           klass.GetDexFile(),
785           dex::TypeIndex(type_index),
786           hs.NewHandle(klass.GetDexCache()),
787           hs.NewHandle(klass.GetClassLoader()));
788       if (resolved_class == nullptr) {
789         std::string temp;
790         LOG(WARNING) << StringPrintf("Unable to resolve %s annotation class %d",
791                                      klass.GetRealClass()->GetDescriptor(&temp), type_index);
792         CHECK(Thread::Current()->IsExceptionPending());
793         Thread::Current()->ClearException();
794         continue;
795       }
796     }
797     if (resolved_class == annotation_class.Get()) {
798       return annotation_item;
799     }
800   }
801 
802   return nullptr;
803 }
804 
GetAnnotationObjectFromAnnotationSet(const ClassData & klass,const DexFile::AnnotationSetItem * annotation_set,uint32_t visibility,Handle<mirror::Class> annotation_class)805 mirror::Object* GetAnnotationObjectFromAnnotationSet(
806     const ClassData& klass,
807     const DexFile::AnnotationSetItem* annotation_set,
808     uint32_t visibility,
809     Handle<mirror::Class> annotation_class)
810     REQUIRES_SHARED(Locks::mutator_lock_) {
811   const DexFile::AnnotationItem* annotation_item =
812       GetAnnotationItemFromAnnotationSet(klass, annotation_set, visibility, annotation_class);
813   if (annotation_item == nullptr) {
814     return nullptr;
815   }
816   const uint8_t* annotation = annotation_item->annotation_;
817   return ProcessEncodedAnnotation(klass, &annotation);
818 }
819 
GetAnnotationValue(const ClassData & klass,const DexFile::AnnotationItem * annotation_item,const char * annotation_name,Handle<mirror::Class> array_class,uint32_t expected_type)820 mirror::Object* GetAnnotationValue(const ClassData& klass,
821                                    const DexFile::AnnotationItem* annotation_item,
822                                    const char* annotation_name,
823                                    Handle<mirror::Class> array_class,
824                                    uint32_t expected_type)
825     REQUIRES_SHARED(Locks::mutator_lock_) {
826   const DexFile& dex_file = klass.GetDexFile();
827   const uint8_t* annotation =
828       SearchEncodedAnnotation(dex_file, annotation_item->annotation_, annotation_name);
829   if (annotation == nullptr) {
830     return nullptr;
831   }
832   DexFile::AnnotationValue annotation_value;
833   bool result = Runtime::Current()->IsActiveTransaction()
834       ? ProcessAnnotationValue<true>(klass,
835                                      &annotation,
836                                      &annotation_value,
837                                      array_class,
838                                      DexFile::kAllObjects)
839       : ProcessAnnotationValue<false>(klass,
840                                       &annotation,
841                                       &annotation_value,
842                                       array_class,
843                                       DexFile::kAllObjects);
844   if (!result) {
845     return nullptr;
846   }
847   if (annotation_value.type_ != expected_type) {
848     return nullptr;
849   }
850   return annotation_value.value_.GetL();
851 }
852 
GetSignatureValue(const ClassData & klass,const DexFile::AnnotationSetItem * annotation_set)853 mirror::ObjectArray<mirror::String>* GetSignatureValue(const ClassData& klass,
854     const DexFile::AnnotationSetItem* annotation_set)
855     REQUIRES_SHARED(Locks::mutator_lock_) {
856   const DexFile& dex_file = klass.GetDexFile();
857   StackHandleScope<1> hs(Thread::Current());
858   const DexFile::AnnotationItem* annotation_item =
859       SearchAnnotationSet(dex_file, annotation_set, "Ldalvik/annotation/Signature;",
860                           DexFile::kDexVisibilitySystem);
861   if (annotation_item == nullptr) {
862     return nullptr;
863   }
864   ObjPtr<mirror::Class> string_class = mirror::String::GetJavaLangString();
865   Handle<mirror::Class> string_array_class(hs.NewHandle(
866       Runtime::Current()->GetClassLinker()->FindArrayClass(Thread::Current(), &string_class)));
867   if (string_array_class == nullptr) {
868     return nullptr;
869   }
870   mirror::Object* obj =
871       GetAnnotationValue(klass, annotation_item, "value", string_array_class,
872                          DexFile::kDexAnnotationArray);
873   if (obj == nullptr) {
874     return nullptr;
875   }
876   return obj->AsObjectArray<mirror::String>();
877 }
878 
GetThrowsValue(const ClassData & klass,const DexFile::AnnotationSetItem * annotation_set)879 mirror::ObjectArray<mirror::Class>* GetThrowsValue(const ClassData& klass,
880                                                    const DexFile::AnnotationSetItem* annotation_set)
881     REQUIRES_SHARED(Locks::mutator_lock_) {
882   const DexFile& dex_file = klass.GetDexFile();
883   StackHandleScope<1> hs(Thread::Current());
884   const DexFile::AnnotationItem* annotation_item =
885       SearchAnnotationSet(dex_file, annotation_set, "Ldalvik/annotation/Throws;",
886                           DexFile::kDexVisibilitySystem);
887   if (annotation_item == nullptr) {
888     return nullptr;
889   }
890   ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass();
891   Handle<mirror::Class> class_array_class(hs.NewHandle(
892       Runtime::Current()->GetClassLinker()->FindArrayClass(Thread::Current(), &class_class)));
893   if (class_array_class == nullptr) {
894     return nullptr;
895   }
896   mirror::Object* obj =
897       GetAnnotationValue(klass, annotation_item, "value", class_array_class,
898                          DexFile::kDexAnnotationArray);
899   if (obj == nullptr) {
900     return nullptr;
901   }
902   return obj->AsObjectArray<mirror::Class>();
903 }
904 
ProcessAnnotationSet(const ClassData & klass,const DexFile::AnnotationSetItem * annotation_set,uint32_t visibility)905 mirror::ObjectArray<mirror::Object>* ProcessAnnotationSet(
906     const ClassData& klass,
907     const DexFile::AnnotationSetItem* annotation_set,
908     uint32_t visibility)
909     REQUIRES_SHARED(Locks::mutator_lock_) {
910   const DexFile& dex_file = klass.GetDexFile();
911   Thread* self = Thread::Current();
912   ScopedObjectAccessUnchecked soa(self);
913   StackHandleScope<2> hs(self);
914   Handle<mirror::Class> annotation_array_class(hs.NewHandle(
915       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_annotation_Annotation__array)));
916   if (annotation_set == nullptr) {
917     return mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_class.Get(), 0);
918   }
919 
920   uint32_t size = annotation_set->size_;
921   Handle<mirror::ObjectArray<mirror::Object>> result(hs.NewHandle(
922       mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_class.Get(), size)));
923   if (result == nullptr) {
924     return nullptr;
925   }
926 
927   uint32_t dest_index = 0;
928   for (uint32_t i = 0; i < size; ++i) {
929     const DexFile::AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i);
930     // Note that we do not use IsVisibilityCompatible here because older code
931     // was correct for this case.
932     if (annotation_item->visibility_ != visibility) {
933       continue;
934     }
935     const uint8_t* annotation = annotation_item->annotation_;
936     mirror::Object* annotation_obj = ProcessEncodedAnnotation(klass, &annotation);
937     if (annotation_obj != nullptr) {
938       result->SetWithoutChecks<false>(dest_index, annotation_obj);
939       ++dest_index;
940     } else if (self->IsExceptionPending()) {
941       return nullptr;
942     }
943   }
944 
945   if (dest_index == size) {
946     return result.Get();
947   }
948 
949   mirror::ObjectArray<mirror::Object>* trimmed_result =
950       mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_class.Get(), dest_index);
951   if (trimmed_result == nullptr) {
952     return nullptr;
953   }
954 
955   for (uint32_t i = 0; i < dest_index; ++i) {
956     mirror::Object* obj = result->GetWithoutChecks(i);
957     trimmed_result->SetWithoutChecks<false>(i, obj);
958   }
959 
960   return trimmed_result;
961 }
962 
ProcessAnnotationSetRefList(const ClassData & klass,const DexFile::AnnotationSetRefList * set_ref_list,uint32_t size)963 mirror::ObjectArray<mirror::Object>* ProcessAnnotationSetRefList(
964     const ClassData& klass,
965     const DexFile::AnnotationSetRefList* set_ref_list,
966     uint32_t size)
967     REQUIRES_SHARED(Locks::mutator_lock_) {
968   const DexFile& dex_file = klass.GetDexFile();
969   Thread* self = Thread::Current();
970   ScopedObjectAccessUnchecked soa(self);
971   StackHandleScope<1> hs(self);
972   ObjPtr<mirror::Class> annotation_array_class =
973       soa.Decode<mirror::Class>(WellKnownClasses::java_lang_annotation_Annotation__array);
974   mirror::Class* annotation_array_array_class =
975       Runtime::Current()->GetClassLinker()->FindArrayClass(self, &annotation_array_class);
976   if (annotation_array_array_class == nullptr) {
977     return nullptr;
978   }
979   Handle<mirror::ObjectArray<mirror::Object>> annotation_array_array(hs.NewHandle(
980       mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_array_class, size)));
981   if (annotation_array_array == nullptr) {
982     LOG(ERROR) << "Annotation set ref array allocation failed";
983     return nullptr;
984   }
985   for (uint32_t index = 0; index < size; ++index) {
986     const DexFile::AnnotationSetRefItem* set_ref_item = &set_ref_list->list_[index];
987     const DexFile::AnnotationSetItem* set_item = dex_file.GetSetRefItemItem(set_ref_item);
988     mirror::Object* annotation_set = ProcessAnnotationSet(klass, set_item,
989                                                           DexFile::kDexVisibilityRuntime);
990     if (annotation_set == nullptr) {
991       return nullptr;
992     }
993     annotation_array_array->SetWithoutChecks<false>(index, annotation_set);
994   }
995   return annotation_array_array.Get();
996 }
997 }  // namespace
998 
999 namespace annotations {
1000 
GetAnnotationForField(ArtField * field,Handle<mirror::Class> annotation_class)1001 mirror::Object* GetAnnotationForField(ArtField* field, Handle<mirror::Class> annotation_class) {
1002   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
1003   if (annotation_set == nullptr) {
1004     return nullptr;
1005   }
1006   StackHandleScope<1> hs(Thread::Current());
1007   const ClassData field_class(hs, field);
1008   return GetAnnotationObjectFromAnnotationSet(field_class,
1009                                               annotation_set,
1010                                               DexFile::kDexVisibilityRuntime,
1011                                               annotation_class);
1012 }
1013 
GetAnnotationsForField(ArtField * field)1014 mirror::ObjectArray<mirror::Object>* GetAnnotationsForField(ArtField* field) {
1015   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
1016   StackHandleScope<1> hs(Thread::Current());
1017   const ClassData field_class(hs, field);
1018   return ProcessAnnotationSet(field_class, annotation_set, DexFile::kDexVisibilityRuntime);
1019 }
1020 
GetSignatureAnnotationForField(ArtField * field)1021 mirror::ObjectArray<mirror::String>* GetSignatureAnnotationForField(ArtField* field) {
1022   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
1023   if (annotation_set == nullptr) {
1024     return nullptr;
1025   }
1026   StackHandleScope<1> hs(Thread::Current());
1027   const ClassData field_class(hs, field);
1028   return GetSignatureValue(field_class, annotation_set);
1029 }
1030 
IsFieldAnnotationPresent(ArtField * field,Handle<mirror::Class> annotation_class)1031 bool IsFieldAnnotationPresent(ArtField* field, Handle<mirror::Class> annotation_class) {
1032   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForField(field);
1033   if (annotation_set == nullptr) {
1034     return false;
1035   }
1036   StackHandleScope<1> hs(Thread::Current());
1037   const ClassData field_class(hs, field);
1038   const DexFile::AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
1039       field_class, annotation_set, DexFile::kDexVisibilityRuntime, annotation_class);
1040   return annotation_item != nullptr;
1041 }
1042 
GetAnnotationDefaultValue(ArtMethod * method)1043 mirror::Object* GetAnnotationDefaultValue(ArtMethod* method) {
1044   const ClassData klass(method);
1045   const DexFile* dex_file = &klass.GetDexFile();
1046   const DexFile::AnnotationsDirectoryItem* annotations_dir =
1047       dex_file->GetAnnotationsDirectory(*klass.GetClassDef());
1048   if (annotations_dir == nullptr) {
1049     return nullptr;
1050   }
1051   const DexFile::AnnotationSetItem* annotation_set =
1052       dex_file->GetClassAnnotationSet(annotations_dir);
1053   if (annotation_set == nullptr) {
1054     return nullptr;
1055   }
1056   const DexFile::AnnotationItem* annotation_item = SearchAnnotationSet(*dex_file, annotation_set,
1057       "Ldalvik/annotation/AnnotationDefault;", DexFile::kDexVisibilitySystem);
1058   if (annotation_item == nullptr) {
1059     return nullptr;
1060   }
1061   const uint8_t* annotation =
1062       SearchEncodedAnnotation(*dex_file, annotation_item->annotation_, "value");
1063   if (annotation == nullptr) {
1064     return nullptr;
1065   }
1066   uint8_t header_byte = *(annotation++);
1067   if ((header_byte & DexFile::kDexAnnotationValueTypeMask) != DexFile::kDexAnnotationAnnotation) {
1068     return nullptr;
1069   }
1070   annotation = SearchEncodedAnnotation(*dex_file, annotation, method->GetName());
1071   if (annotation == nullptr) {
1072     return nullptr;
1073   }
1074   DexFile::AnnotationValue annotation_value;
1075   StackHandleScope<1> hs(Thread::Current());
1076   Handle<mirror::Class> return_type(hs.NewHandle(method->GetReturnType(true /* resolve */)));
1077   if (!ProcessAnnotationValue<false>(klass,
1078                                      &annotation,
1079                                      &annotation_value,
1080                                      return_type,
1081                                      DexFile::kAllObjects)) {
1082     return nullptr;
1083   }
1084   return annotation_value.value_.GetL();
1085 }
1086 
GetAnnotationForMethod(ArtMethod * method,Handle<mirror::Class> annotation_class)1087 mirror::Object* GetAnnotationForMethod(ArtMethod* method, Handle<mirror::Class> annotation_class) {
1088   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
1089   if (annotation_set == nullptr) {
1090     return nullptr;
1091   }
1092   return GetAnnotationObjectFromAnnotationSet(ClassData(method), annotation_set,
1093                                               DexFile::kDexVisibilityRuntime, annotation_class);
1094 }
1095 
GetAnnotationsForMethod(ArtMethod * method)1096 mirror::ObjectArray<mirror::Object>* GetAnnotationsForMethod(ArtMethod* method) {
1097   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
1098   return ProcessAnnotationSet(ClassData(method),
1099                               annotation_set,
1100                               DexFile::kDexVisibilityRuntime);
1101 }
1102 
GetExceptionTypesForMethod(ArtMethod * method)1103 mirror::ObjectArray<mirror::Class>* GetExceptionTypesForMethod(ArtMethod* method) {
1104   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
1105   if (annotation_set == nullptr) {
1106     return nullptr;
1107   }
1108   return GetThrowsValue(ClassData(method), annotation_set);
1109 }
1110 
GetParameterAnnotations(ArtMethod * method)1111 mirror::ObjectArray<mirror::Object>* GetParameterAnnotations(ArtMethod* method) {
1112   const DexFile* dex_file = method->GetDexFile();
1113   const DexFile::ParameterAnnotationsItem* parameter_annotations =
1114       FindAnnotationsItemForMethod(method);
1115   if (parameter_annotations == nullptr) {
1116     return nullptr;
1117   }
1118   const DexFile::AnnotationSetRefList* set_ref_list =
1119       dex_file->GetParameterAnnotationSetRefList(parameter_annotations);
1120   if (set_ref_list == nullptr) {
1121     return nullptr;
1122   }
1123   uint32_t size = set_ref_list->size_;
1124   return ProcessAnnotationSetRefList(ClassData(method), set_ref_list, size);
1125 }
1126 
GetAnnotationForMethodParameter(ArtMethod * method,uint32_t parameter_idx,Handle<mirror::Class> annotation_class)1127 mirror::Object* GetAnnotationForMethodParameter(ArtMethod* method,
1128                                                 uint32_t parameter_idx,
1129                                                 Handle<mirror::Class> annotation_class) {
1130   const DexFile* dex_file = method->GetDexFile();
1131   const DexFile::ParameterAnnotationsItem* parameter_annotations =
1132       FindAnnotationsItemForMethod(method);
1133   if (parameter_annotations == nullptr) {
1134     return nullptr;
1135   }
1136   const DexFile::AnnotationSetRefList* set_ref_list =
1137       dex_file->GetParameterAnnotationSetRefList(parameter_annotations);
1138   if (set_ref_list == nullptr) {
1139     return nullptr;
1140   }
1141   if (parameter_idx >= set_ref_list->size_) {
1142     return nullptr;
1143   }
1144   const DexFile::AnnotationSetRefItem* annotation_set_ref = &set_ref_list->list_[parameter_idx];
1145   const DexFile::AnnotationSetItem* annotation_set =
1146      dex_file->GetSetRefItemItem(annotation_set_ref);
1147 
1148   return GetAnnotationObjectFromAnnotationSet(ClassData(method),
1149                                               annotation_set,
1150                                               DexFile::kDexVisibilityRuntime,
1151                                               annotation_class);
1152 }
1153 
GetParametersMetadataForMethod(ArtMethod * method,MutableHandle<mirror::ObjectArray<mirror::String>> * names,MutableHandle<mirror::IntArray> * access_flags)1154 bool GetParametersMetadataForMethod(ArtMethod* method,
1155                                     MutableHandle<mirror::ObjectArray<mirror::String>>* names,
1156                                     MutableHandle<mirror::IntArray>* access_flags) {
1157   const DexFile::AnnotationSetItem::AnnotationSetItem* annotation_set =
1158       FindAnnotationSetForMethod(method);
1159   if (annotation_set == nullptr) {
1160     return false;
1161   }
1162 
1163   const DexFile* dex_file = method->GetDexFile();
1164   const DexFile::AnnotationItem* annotation_item =
1165       SearchAnnotationSet(*dex_file,
1166                           annotation_set,
1167                           "Ldalvik/annotation/MethodParameters;",
1168                           DexFile::kDexVisibilitySystem);
1169   if (annotation_item == nullptr) {
1170     return false;
1171   }
1172 
1173   StackHandleScope<4> hs(Thread::Current());
1174 
1175   // Extract the parameters' names String[].
1176   ObjPtr<mirror::Class> string_class = mirror::String::GetJavaLangString();
1177   Handle<mirror::Class> string_array_class(hs.NewHandle(
1178       Runtime::Current()->GetClassLinker()->FindArrayClass(Thread::Current(), &string_class)));
1179   if (UNLIKELY(string_array_class == nullptr)) {
1180     return false;
1181   }
1182 
1183   ClassData data(method);
1184   Handle<mirror::Object> names_obj =
1185       hs.NewHandle(GetAnnotationValue(data,
1186                                       annotation_item,
1187                                       "names",
1188                                       string_array_class,
1189                                       DexFile::kDexAnnotationArray));
1190   if (names_obj == nullptr) {
1191     return false;
1192   }
1193 
1194   // Extract the parameters' access flags int[].
1195   Handle<mirror::Class> int_array_class(hs.NewHandle(mirror::IntArray::GetArrayClass()));
1196   if (UNLIKELY(int_array_class == nullptr)) {
1197     return false;
1198   }
1199   Handle<mirror::Object> access_flags_obj =
1200       hs.NewHandle(GetAnnotationValue(data,
1201                                       annotation_item,
1202                                       "accessFlags",
1203                                       int_array_class,
1204                                       DexFile::kDexAnnotationArray));
1205   if (access_flags_obj == nullptr) {
1206     return false;
1207   }
1208 
1209   names->Assign(names_obj.Get()->AsObjectArray<mirror::String>());
1210   access_flags->Assign(access_flags_obj.Get()->AsIntArray());
1211   return true;
1212 }
1213 
GetSignatureAnnotationForMethod(ArtMethod * method)1214 mirror::ObjectArray<mirror::String>* GetSignatureAnnotationForMethod(ArtMethod* method) {
1215   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
1216   if (annotation_set == nullptr) {
1217     return nullptr;
1218   }
1219   return GetSignatureValue(ClassData(method), annotation_set);
1220 }
1221 
IsMethodAnnotationPresent(ArtMethod * method,Handle<mirror::Class> annotation_class,uint32_t visibility,bool lookup_in_resolved_boot_classes)1222 bool IsMethodAnnotationPresent(ArtMethod* method,
1223                                Handle<mirror::Class> annotation_class,
1224                                uint32_t visibility /* = DexFile::kDexVisibilityRuntime */,
1225                                bool lookup_in_resolved_boot_classes /* = false */) {
1226   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method);
1227   if (annotation_set == nullptr) {
1228     return false;
1229   }
1230   const DexFile::AnnotationItem* annotation_item =
1231       GetAnnotationItemFromAnnotationSet(ClassData(method),
1232                                          annotation_set,
1233                                          visibility,
1234                                          annotation_class,
1235                                          lookup_in_resolved_boot_classes);
1236   return annotation_item != nullptr;
1237 }
1238 
GetAnnotationForClass(Handle<mirror::Class> klass,Handle<mirror::Class> annotation_class)1239 mirror::Object* GetAnnotationForClass(Handle<mirror::Class> klass,
1240                                       Handle<mirror::Class> annotation_class) {
1241   ClassData data(klass);
1242   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1243   if (annotation_set == nullptr) {
1244     return nullptr;
1245   }
1246   return GetAnnotationObjectFromAnnotationSet(data,
1247                                               annotation_set,
1248                                               DexFile::kDexVisibilityRuntime,
1249                                               annotation_class);
1250 }
1251 
GetAnnotationsForClass(Handle<mirror::Class> klass)1252 mirror::ObjectArray<mirror::Object>* GetAnnotationsForClass(Handle<mirror::Class> klass) {
1253   ClassData data(klass);
1254   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1255   return ProcessAnnotationSet(data, annotation_set, DexFile::kDexVisibilityRuntime);
1256 }
1257 
GetDeclaredClasses(Handle<mirror::Class> klass)1258 mirror::ObjectArray<mirror::Class>* GetDeclaredClasses(Handle<mirror::Class> klass) {
1259   ClassData data(klass);
1260   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1261   if (annotation_set == nullptr) {
1262     return nullptr;
1263   }
1264   const DexFile::AnnotationItem* annotation_item =
1265       SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/MemberClasses;",
1266                           DexFile::kDexVisibilitySystem);
1267   if (annotation_item == nullptr) {
1268     return nullptr;
1269   }
1270   StackHandleScope<1> hs(Thread::Current());
1271   ObjPtr<mirror::Class> class_class = mirror::Class::GetJavaLangClass();
1272   Handle<mirror::Class> class_array_class(hs.NewHandle(
1273       Runtime::Current()->GetClassLinker()->FindArrayClass(hs.Self(), &class_class)));
1274   if (class_array_class == nullptr) {
1275     return nullptr;
1276   }
1277   mirror::Object* obj =
1278       GetAnnotationValue(data, annotation_item, "value", class_array_class,
1279                          DexFile::kDexAnnotationArray);
1280   if (obj == nullptr) {
1281     return nullptr;
1282   }
1283   return obj->AsObjectArray<mirror::Class>();
1284 }
1285 
GetDeclaringClass(Handle<mirror::Class> klass)1286 mirror::Class* GetDeclaringClass(Handle<mirror::Class> klass) {
1287   ClassData data(klass);
1288   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1289   if (annotation_set == nullptr) {
1290     return nullptr;
1291   }
1292   const DexFile::AnnotationItem* annotation_item =
1293       SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/EnclosingClass;",
1294                           DexFile::kDexVisibilitySystem);
1295   if (annotation_item == nullptr) {
1296     return nullptr;
1297   }
1298   mirror::Object* obj = GetAnnotationValue(data, annotation_item, "value",
1299                                            ScopedNullHandle<mirror::Class>(),
1300                                            DexFile::kDexAnnotationType);
1301   if (obj == nullptr) {
1302     return nullptr;
1303   }
1304   return obj->AsClass();
1305 }
1306 
GetEnclosingClass(Handle<mirror::Class> klass)1307 mirror::Class* GetEnclosingClass(Handle<mirror::Class> klass) {
1308   mirror::Class* declaring_class = GetDeclaringClass(klass);
1309   if (declaring_class != nullptr) {
1310     return declaring_class;
1311   }
1312   ClassData data(klass);
1313   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1314   if (annotation_set == nullptr) {
1315     return nullptr;
1316   }
1317   const DexFile::AnnotationItem* annotation_item =
1318       SearchAnnotationSet(data.GetDexFile(),
1319                           annotation_set,
1320                           "Ldalvik/annotation/EnclosingMethod;",
1321                           DexFile::kDexVisibilitySystem);
1322   if (annotation_item == nullptr) {
1323     return nullptr;
1324   }
1325   const uint8_t* annotation =
1326       SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "value");
1327   if (annotation == nullptr) {
1328     return nullptr;
1329   }
1330   DexFile::AnnotationValue annotation_value;
1331   if (!ProcessAnnotationValue<false>(data,
1332                                      &annotation,
1333                                      &annotation_value,
1334                                      ScopedNullHandle<mirror::Class>(),
1335                                      DexFile::kAllRaw)) {
1336     return nullptr;
1337   }
1338   if (annotation_value.type_ != DexFile::kDexAnnotationMethod) {
1339     return nullptr;
1340   }
1341   StackHandleScope<2> hs(Thread::Current());
1342   ArtMethod* method = Runtime::Current()->GetClassLinker()->ResolveMethodWithoutInvokeType(
1343       data.GetDexFile(),
1344       annotation_value.value_.GetI(),
1345       hs.NewHandle(data.GetDexCache()),
1346       hs.NewHandle(data.GetClassLoader()));
1347   if (method == nullptr) {
1348     return nullptr;
1349   }
1350   return method->GetDeclaringClass();
1351 }
1352 
GetEnclosingMethod(Handle<mirror::Class> klass)1353 mirror::Object* GetEnclosingMethod(Handle<mirror::Class> klass) {
1354   ClassData data(klass);
1355   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1356   if (annotation_set == nullptr) {
1357     return nullptr;
1358   }
1359   const DexFile::AnnotationItem* annotation_item =
1360       SearchAnnotationSet(data.GetDexFile(),
1361                           annotation_set,
1362                           "Ldalvik/annotation/EnclosingMethod;",
1363                           DexFile::kDexVisibilitySystem);
1364   if (annotation_item == nullptr) {
1365     return nullptr;
1366   }
1367   return GetAnnotationValue(data, annotation_item, "value", ScopedNullHandle<mirror::Class>(),
1368       DexFile::kDexAnnotationMethod);
1369 }
1370 
GetInnerClass(Handle<mirror::Class> klass,mirror::String ** name)1371 bool GetInnerClass(Handle<mirror::Class> klass, mirror::String** name) {
1372   ClassData data(klass);
1373   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1374   if (annotation_set == nullptr) {
1375     return false;
1376   }
1377   const DexFile::AnnotationItem* annotation_item = SearchAnnotationSet(
1378       data.GetDexFile(),
1379       annotation_set,
1380       "Ldalvik/annotation/InnerClass;",
1381       DexFile::kDexVisibilitySystem);
1382   if (annotation_item == nullptr) {
1383     return false;
1384   }
1385   const uint8_t* annotation =
1386       SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "name");
1387   if (annotation == nullptr) {
1388     return false;
1389   }
1390   DexFile::AnnotationValue annotation_value;
1391   if (!ProcessAnnotationValue<false>(data,
1392                                      &annotation,
1393                                      &annotation_value,
1394                                      ScopedNullHandle<mirror::Class>(),
1395                                      DexFile::kAllObjects)) {
1396     return false;
1397   }
1398   if (annotation_value.type_ != DexFile::kDexAnnotationNull &&
1399       annotation_value.type_ != DexFile::kDexAnnotationString) {
1400     return false;
1401   }
1402   *name = down_cast<mirror::String*>(annotation_value.value_.GetL());
1403   return true;
1404 }
1405 
GetInnerClassFlags(Handle<mirror::Class> klass,uint32_t * flags)1406 bool GetInnerClassFlags(Handle<mirror::Class> klass, uint32_t* flags) {
1407   ClassData data(klass);
1408   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1409   if (annotation_set == nullptr) {
1410     return false;
1411   }
1412   const DexFile::AnnotationItem* annotation_item =
1413       SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/InnerClass;",
1414                           DexFile::kDexVisibilitySystem);
1415   if (annotation_item == nullptr) {
1416     return false;
1417   }
1418   const uint8_t* annotation =
1419       SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "accessFlags");
1420   if (annotation == nullptr) {
1421     return false;
1422   }
1423   DexFile::AnnotationValue annotation_value;
1424   if (!ProcessAnnotationValue<false>(data,
1425                                      &annotation,
1426                                      &annotation_value,
1427                                      ScopedNullHandle<mirror::Class>(),
1428                                      DexFile::kAllRaw)) {
1429     return false;
1430   }
1431   if (annotation_value.type_ != DexFile::kDexAnnotationInt) {
1432     return false;
1433   }
1434   *flags = annotation_value.value_.GetI();
1435   return true;
1436 }
1437 
GetSignatureAnnotationForClass(Handle<mirror::Class> klass)1438 mirror::ObjectArray<mirror::String>* GetSignatureAnnotationForClass(Handle<mirror::Class> klass) {
1439   ClassData data(klass);
1440   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1441   if (annotation_set == nullptr) {
1442     return nullptr;
1443   }
1444   return GetSignatureValue(data, annotation_set);
1445 }
1446 
GetSourceDebugExtension(Handle<mirror::Class> klass)1447 const char* GetSourceDebugExtension(Handle<mirror::Class> klass) {
1448   // Before instantiating ClassData, check that klass has a DexCache
1449   // assigned.  The ClassData constructor indirectly dereferences it
1450   // when calling klass->GetDexFile().
1451   if (klass->GetDexCache() == nullptr) {
1452     DCHECK(klass->IsPrimitive() || klass->IsArrayClass());
1453     return nullptr;
1454   }
1455 
1456   ClassData data(klass);
1457   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1458   if (annotation_set == nullptr) {
1459     return nullptr;
1460   }
1461 
1462   const DexFile::AnnotationItem* annotation_item = SearchAnnotationSet(
1463       data.GetDexFile(),
1464       annotation_set,
1465       "Ldalvik/annotation/SourceDebugExtension;",
1466       DexFile::kDexVisibilitySystem);
1467   if (annotation_item == nullptr) {
1468     return nullptr;
1469   }
1470 
1471   const uint8_t* annotation =
1472       SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "value");
1473   if (annotation == nullptr) {
1474     return nullptr;
1475   }
1476   DexFile::AnnotationValue annotation_value;
1477   if (!ProcessAnnotationValue<false>(data,
1478                                      &annotation,
1479                                      &annotation_value,
1480                                      ScopedNullHandle<mirror::Class>(),
1481                                      DexFile::kAllRaw)) {
1482     return nullptr;
1483   }
1484   if (annotation_value.type_ != DexFile::kDexAnnotationString) {
1485     return nullptr;
1486   }
1487   dex::StringIndex index(static_cast<uint32_t>(annotation_value.value_.GetI()));
1488   return data.GetDexFile().StringDataByIdx(index);
1489 }
1490 
IsClassAnnotationPresent(Handle<mirror::Class> klass,Handle<mirror::Class> annotation_class)1491 bool IsClassAnnotationPresent(Handle<mirror::Class> klass, Handle<mirror::Class> annotation_class) {
1492   ClassData data(klass);
1493   const DexFile::AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data);
1494   if (annotation_set == nullptr) {
1495     return false;
1496   }
1497   const DexFile::AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet(
1498       data, annotation_set, DexFile::kDexVisibilityRuntime, annotation_class);
1499   return annotation_item != nullptr;
1500 }
1501 
GetLineNumFromPC(const DexFile * dex_file,ArtMethod * method,uint32_t rel_pc)1502 int32_t GetLineNumFromPC(const DexFile* dex_file, ArtMethod* method, uint32_t rel_pc) {
1503   // For native method, lineno should be -2 to indicate it is native. Note that
1504   // "line number == -2" is how libcore tells from StackTraceElement.
1505   if (method->GetCodeItemOffset() == 0) {
1506     return -2;
1507   }
1508 
1509   const DexFile::CodeItem* code_item = dex_file->GetCodeItem(method->GetCodeItemOffset());
1510   DCHECK(code_item != nullptr) << method->PrettyMethod() << " " << dex_file->GetLocation();
1511 
1512   // A method with no line number info should return -1
1513   DexFile::LineNumFromPcContext context(rel_pc, -1);
1514   dex_file->DecodeDebugPositionInfo(code_item, DexFile::LineNumForPcCb, &context);
1515   return context.line_num_;
1516 }
1517 
1518 template<bool kTransactionActive>
ReadValueToField(ArtField * field) const1519 void RuntimeEncodedStaticFieldValueIterator::ReadValueToField(ArtField* field) const {
1520   DCHECK(dex_cache_ != nullptr);
1521   DCHECK(class_loader_ != nullptr);
1522   switch (type_) {
1523     case kBoolean: field->SetBoolean<kTransactionActive>(field->GetDeclaringClass(), jval_.z);
1524         break;
1525     case kByte:    field->SetByte<kTransactionActive>(field->GetDeclaringClass(), jval_.b); break;
1526     case kShort:   field->SetShort<kTransactionActive>(field->GetDeclaringClass(), jval_.s); break;
1527     case kChar:    field->SetChar<kTransactionActive>(field->GetDeclaringClass(), jval_.c); break;
1528     case kInt:     field->SetInt<kTransactionActive>(field->GetDeclaringClass(), jval_.i); break;
1529     case kLong:    field->SetLong<kTransactionActive>(field->GetDeclaringClass(), jval_.j); break;
1530     case kFloat:   field->SetFloat<kTransactionActive>(field->GetDeclaringClass(), jval_.f); break;
1531     case kDouble:  field->SetDouble<kTransactionActive>(field->GetDeclaringClass(), jval_.d); break;
1532     case kNull:    field->SetObject<kTransactionActive>(field->GetDeclaringClass(), nullptr); break;
1533     case kString: {
1534       mirror::String* resolved = linker_->ResolveString(dex_file_,
1535                                                         dex::StringIndex(jval_.i),
1536                                                         *dex_cache_);
1537       field->SetObject<kTransactionActive>(field->GetDeclaringClass(), resolved);
1538       break;
1539     }
1540     case kType: {
1541       mirror::Class* resolved = linker_->ResolveType(dex_file_,
1542                                                      dex::TypeIndex(jval_.i),
1543                                                      *dex_cache_,
1544                                                      *class_loader_);
1545       field->SetObject<kTransactionActive>(field->GetDeclaringClass(), resolved);
1546       break;
1547     }
1548     default: UNIMPLEMENTED(FATAL) << ": type " << type_;
1549   }
1550 }
1551 template
1552 void RuntimeEncodedStaticFieldValueIterator::ReadValueToField<true>(ArtField* field) const;
1553 template
1554 void RuntimeEncodedStaticFieldValueIterator::ReadValueToField<false>(ArtField* field) const;
1555 
1556 }  // namespace annotations
1557 
1558 }  // namespace art
1559