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 "base/sdk_version.h" 26 #include "class_linker-inl.h" 27 #include "class_root.h" 28 #include "dex/dex_file-inl.h" 29 #include "dex/dex_instruction-inl.h" 30 #include "jni/jni_internal.h" 31 #include "jvalue-inl.h" 32 #include "mirror/array-alloc-inl.h" 33 #include "mirror/class-alloc-inl.h" 34 #include "mirror/field.h" 35 #include "mirror/method.h" 36 #include "mirror/object_array-alloc-inl.h" 37 #include "mirror/object_array-inl.h" 38 #include "oat_file.h" 39 #include "obj_ptr-inl.h" 40 #include "quicken_info.h" 41 #include "reflection.h" 42 #include "thread.h" 43 #include "well_known_classes.h" 44 45 namespace art { 46 47 using android::base::StringPrintf; 48 49 using dex::AnnotationItem; 50 using dex::AnnotationSetItem; 51 using dex::AnnotationSetRefItem; 52 using dex::AnnotationSetRefList; 53 using dex::AnnotationsDirectoryItem; 54 using dex::FieldAnnotationsItem; 55 using dex::MethodAnnotationsItem; 56 using dex::ParameterAnnotationsItem; 57 58 struct DexFile::AnnotationValue { 59 JValue value_; 60 uint8_t type_; 61 }; 62 63 namespace { 64 65 // A helper class that contains all the data needed to do annotation lookup. 66 class ClassData { 67 public: 68 explicit ClassData(ArtMethod* method) REQUIRES_SHARED(Locks::mutator_lock_) 69 : ClassData(ScopedNullHandle<mirror::Class>(), // klass 70 method, 71 *method->GetDexFile(), 72 &method->GetClassDef()) {} 73 74 // Requires Scope to be able to create at least 1 handles. 75 template <typename Scope> 76 ClassData(Scope& hs, ArtField* field) REQUIRES_SHARED(Locks::mutator_lock_) 77 : ClassData(hs.NewHandle(field->GetDeclaringClass())) { } 78 79 explicit ClassData(Handle<mirror::Class> klass) REQUIRES_SHARED(art::Locks::mutator_lock_) 80 : ClassData(klass, // klass 81 nullptr, // method 82 klass->GetDexFile(), 83 klass->GetClassDef()) {} 84 85 const DexFile& GetDexFile() const REQUIRES_SHARED(Locks::mutator_lock_) { 86 return dex_file_; 87 } 88 89 const dex::ClassDef* GetClassDef() const REQUIRES_SHARED(Locks::mutator_lock_) { 90 return class_def_; 91 } 92 93 ObjPtr<mirror::DexCache> GetDexCache() const REQUIRES_SHARED(Locks::mutator_lock_) { 94 if (method_ != nullptr) { 95 return method_->GetDexCache(); 96 } else { 97 return real_klass_->GetDexCache(); 98 } 99 } 100 101 ObjPtr<mirror::ClassLoader> GetClassLoader() const REQUIRES_SHARED(Locks::mutator_lock_) { 102 if (method_ != nullptr) { 103 return method_->GetDeclaringClass()->GetClassLoader(); 104 } else { 105 return real_klass_->GetClassLoader(); 106 } 107 } 108 109 ObjPtr<mirror::Class> GetRealClass() const REQUIRES_SHARED(Locks::mutator_lock_) { 110 if (method_ != nullptr) { 111 return method_->GetDeclaringClass(); 112 } else { 113 return real_klass_.Get(); 114 } 115 } 116 117 private: 118 ClassData(Handle<mirror::Class> klass, 119 ArtMethod* method, 120 const DexFile& dex_file, 121 const dex::ClassDef* class_def) REQUIRES_SHARED(Locks::mutator_lock_) 122 : real_klass_(klass), 123 method_(method), 124 dex_file_(dex_file), 125 class_def_(class_def) { 126 DCHECK((method_ == nullptr) || real_klass_.IsNull()); 127 } 128 129 Handle<mirror::Class> real_klass_; 130 ArtMethod* method_; 131 const DexFile& dex_file_; 132 const dex::ClassDef* class_def_; 133 134 DISALLOW_COPY_AND_ASSIGN(ClassData); 135 }; 136 137 ObjPtr<mirror::Object> CreateAnnotationMember(const ClassData& klass, 138 Handle<mirror::Class> annotation_class, 139 const uint8_t** annotation) 140 REQUIRES_SHARED(Locks::mutator_lock_); 141 142 bool IsVisibilityCompatible(uint32_t actual, uint32_t expected) { 143 if (expected == DexFile::kDexVisibilityRuntime) { 144 if (IsSdkVersionSetAndAtMost(Runtime::Current()->GetTargetSdkVersion(), SdkVersion::kM)) { 145 return actual == DexFile::kDexVisibilityRuntime || actual == DexFile::kDexVisibilityBuild; 146 } 147 } 148 return actual == expected; 149 } 150 151 static const AnnotationSetItem* FindAnnotationSetForField(const DexFile& dex_file, 152 const dex::ClassDef& class_def, 153 uint32_t field_index) 154 REQUIRES_SHARED(Locks::mutator_lock_) { 155 const AnnotationsDirectoryItem* annotations_dir = dex_file.GetAnnotationsDirectory(class_def); 156 if (annotations_dir == nullptr) { 157 return nullptr; 158 } 159 const FieldAnnotationsItem* field_annotations = dex_file.GetFieldAnnotations(annotations_dir); 160 if (field_annotations == nullptr) { 161 return nullptr; 162 } 163 uint32_t field_count = annotations_dir->fields_size_; 164 for (uint32_t i = 0; i < field_count; ++i) { 165 if (field_annotations[i].field_idx_ == field_index) { 166 return dex_file.GetFieldAnnotationSetItem(field_annotations[i]); 167 } 168 } 169 return nullptr; 170 } 171 172 static const AnnotationSetItem* FindAnnotationSetForField(ArtField* field) 173 REQUIRES_SHARED(Locks::mutator_lock_) { 174 ObjPtr<mirror::Class> klass = field->GetDeclaringClass(); 175 const dex::ClassDef* class_def = klass->GetClassDef(); 176 if (class_def == nullptr) { 177 DCHECK(klass->IsProxyClass()); 178 return nullptr; 179 } 180 return FindAnnotationSetForField(*field->GetDexFile(), *class_def, field->GetDexFieldIndex()); 181 } 182 183 const AnnotationItem* SearchAnnotationSet(const DexFile& dex_file, 184 const AnnotationSetItem* annotation_set, 185 const char* descriptor, 186 uint32_t visibility) 187 REQUIRES_SHARED(Locks::mutator_lock_) { 188 const AnnotationItem* result = nullptr; 189 for (uint32_t i = 0; i < annotation_set->size_; ++i) { 190 const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i); 191 if (!IsVisibilityCompatible(annotation_item->visibility_, visibility)) { 192 continue; 193 } 194 const uint8_t* annotation = annotation_item->annotation_; 195 uint32_t type_index = DecodeUnsignedLeb128(&annotation); 196 197 if (strcmp(descriptor, dex_file.StringByTypeIdx(dex::TypeIndex(type_index))) == 0) { 198 result = annotation_item; 199 break; 200 } 201 } 202 return result; 203 } 204 205 bool SkipAnnotationValue(const DexFile& dex_file, const uint8_t** annotation_ptr) 206 REQUIRES_SHARED(Locks::mutator_lock_) { 207 const uint8_t* annotation = *annotation_ptr; 208 uint8_t header_byte = *(annotation++); 209 uint8_t value_type = header_byte & DexFile::kDexAnnotationValueTypeMask; 210 uint8_t value_arg = header_byte >> DexFile::kDexAnnotationValueArgShift; 211 int32_t width = value_arg + 1; 212 213 switch (value_type) { 214 case DexFile::kDexAnnotationByte: 215 case DexFile::kDexAnnotationShort: 216 case DexFile::kDexAnnotationChar: 217 case DexFile::kDexAnnotationInt: 218 case DexFile::kDexAnnotationLong: 219 case DexFile::kDexAnnotationFloat: 220 case DexFile::kDexAnnotationDouble: 221 case DexFile::kDexAnnotationString: 222 case DexFile::kDexAnnotationType: 223 case DexFile::kDexAnnotationMethod: 224 case DexFile::kDexAnnotationField: 225 case DexFile::kDexAnnotationEnum: 226 break; 227 case DexFile::kDexAnnotationArray: 228 { 229 uint32_t size = DecodeUnsignedLeb128(&annotation); 230 for (; size != 0u; --size) { 231 if (!SkipAnnotationValue(dex_file, &annotation)) { 232 return false; 233 } 234 } 235 width = 0; 236 break; 237 } 238 case DexFile::kDexAnnotationAnnotation: 239 { 240 DecodeUnsignedLeb128(&annotation); // unused type_index 241 uint32_t size = DecodeUnsignedLeb128(&annotation); 242 for (; size != 0u; --size) { 243 DecodeUnsignedLeb128(&annotation); // unused element_name_index 244 if (!SkipAnnotationValue(dex_file, &annotation)) { 245 return false; 246 } 247 } 248 width = 0; 249 break; 250 } 251 case DexFile::kDexAnnotationBoolean: 252 case DexFile::kDexAnnotationNull: 253 width = 0; 254 break; 255 default: 256 LOG(FATAL) << StringPrintf("Bad annotation element value byte 0x%02x", value_type); 257 UNREACHABLE(); 258 } 259 260 annotation += width; 261 *annotation_ptr = annotation; 262 return true; 263 } 264 265 const uint8_t* SearchEncodedAnnotation(const DexFile& dex_file, 266 const uint8_t* annotation, 267 const char* name) 268 REQUIRES_SHARED(Locks::mutator_lock_) { 269 DecodeUnsignedLeb128(&annotation); // unused type_index 270 uint32_t size = DecodeUnsignedLeb128(&annotation); 271 272 while (size != 0) { 273 uint32_t element_name_index = DecodeUnsignedLeb128(&annotation); 274 const char* element_name = 275 dex_file.GetStringData(dex_file.GetStringId(dex::StringIndex(element_name_index))); 276 if (strcmp(name, element_name) == 0) { 277 return annotation; 278 } 279 SkipAnnotationValue(dex_file, &annotation); 280 size--; 281 } 282 return nullptr; 283 } 284 285 static const AnnotationSetItem* FindAnnotationSetForMethod(const DexFile& dex_file, 286 const dex::ClassDef& class_def, 287 uint32_t method_index) { 288 const AnnotationsDirectoryItem* annotations_dir = dex_file.GetAnnotationsDirectory(class_def); 289 if (annotations_dir == nullptr) { 290 return nullptr; 291 } 292 const MethodAnnotationsItem* method_annotations = dex_file.GetMethodAnnotations(annotations_dir); 293 if (method_annotations == nullptr) { 294 return nullptr; 295 } 296 uint32_t method_count = annotations_dir->methods_size_; 297 for (uint32_t i = 0; i < method_count; ++i) { 298 if (method_annotations[i].method_idx_ == method_index) { 299 return dex_file.GetMethodAnnotationSetItem(method_annotations[i]); 300 } 301 } 302 return nullptr; 303 } 304 305 inline const AnnotationSetItem* FindAnnotationSetForMethod(ArtMethod* method) 306 REQUIRES_SHARED(Locks::mutator_lock_) { 307 if (method->IsProxyMethod()) { 308 return nullptr; 309 } 310 return FindAnnotationSetForMethod(*method->GetDexFile(), 311 method->GetClassDef(), 312 method->GetDexMethodIndex()); 313 } 314 315 const ParameterAnnotationsItem* FindAnnotationsItemForMethod(ArtMethod* method) 316 REQUIRES_SHARED(Locks::mutator_lock_) { 317 const DexFile* dex_file = method->GetDexFile(); 318 const AnnotationsDirectoryItem* annotations_dir = 319 dex_file->GetAnnotationsDirectory(method->GetClassDef()); 320 if (annotations_dir == nullptr) { 321 return nullptr; 322 } 323 const ParameterAnnotationsItem* parameter_annotations = 324 dex_file->GetParameterAnnotations(annotations_dir); 325 if (parameter_annotations == nullptr) { 326 return nullptr; 327 } 328 uint32_t method_index = method->GetDexMethodIndex(); 329 uint32_t parameter_count = annotations_dir->parameters_size_; 330 for (uint32_t i = 0; i < parameter_count; ++i) { 331 if (parameter_annotations[i].method_idx_ == method_index) { 332 return ¶meter_annotations[i]; 333 } 334 } 335 return nullptr; 336 } 337 338 static const AnnotationSetItem* FindAnnotationSetForClass(const ClassData& klass) 339 REQUIRES_SHARED(Locks::mutator_lock_) { 340 const DexFile& dex_file = klass.GetDexFile(); 341 const dex::ClassDef* class_def = klass.GetClassDef(); 342 if (class_def == nullptr) { 343 DCHECK(klass.GetRealClass()->IsProxyClass()); 344 return nullptr; 345 } 346 const AnnotationsDirectoryItem* annotations_dir = dex_file.GetAnnotationsDirectory(*class_def); 347 if (annotations_dir == nullptr) { 348 return nullptr; 349 } 350 return dex_file.GetClassAnnotationSet(annotations_dir); 351 } 352 353 ObjPtr<mirror::Object> ProcessEncodedAnnotation(const ClassData& klass, const uint8_t** annotation) 354 REQUIRES_SHARED(Locks::mutator_lock_) { 355 uint32_t type_index = DecodeUnsignedLeb128(annotation); 356 uint32_t size = DecodeUnsignedLeb128(annotation); 357 358 Thread* self = Thread::Current(); 359 ScopedObjectAccessUnchecked soa(self); 360 StackHandleScope<4> hs(self); 361 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 362 Handle<mirror::Class> annotation_class(hs.NewHandle( 363 class_linker->ResolveType(dex::TypeIndex(type_index), 364 hs.NewHandle(klass.GetDexCache()), 365 hs.NewHandle(klass.GetClassLoader())))); 366 if (annotation_class == nullptr) { 367 LOG(INFO) << "Unable to resolve " << klass.GetRealClass()->PrettyClass() 368 << " annotation class " << type_index; 369 DCHECK(Thread::Current()->IsExceptionPending()); 370 Thread::Current()->ClearException(); 371 return nullptr; 372 } 373 374 ObjPtr<mirror::Class> annotation_member_class = 375 soa.Decode<mirror::Class>(WellKnownClasses::libcore_reflect_AnnotationMember); 376 ObjPtr<mirror::Class> annotation_member_array_class = 377 class_linker->FindArrayClass(self, annotation_member_class); 378 if (annotation_member_array_class == nullptr) { 379 return nullptr; 380 } 381 ObjPtr<mirror::ObjectArray<mirror::Object>> element_array = nullptr; 382 if (size > 0) { 383 element_array = 384 mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_member_array_class, size); 385 if (element_array == nullptr) { 386 LOG(ERROR) << "Failed to allocate annotation member array (" << size << " elements)"; 387 return nullptr; 388 } 389 } 390 391 Handle<mirror::ObjectArray<mirror::Object>> h_element_array(hs.NewHandle(element_array)); 392 for (uint32_t i = 0; i < size; ++i) { 393 ObjPtr<mirror::Object> new_member = CreateAnnotationMember(klass, annotation_class, annotation); 394 if (new_member == nullptr) { 395 return nullptr; 396 } 397 h_element_array->SetWithoutChecks<false>(i, new_member); 398 } 399 400 JValue result; 401 ArtMethod* create_annotation_method = 402 jni::DecodeArtMethod(WellKnownClasses::libcore_reflect_AnnotationFactory_createAnnotation); 403 uint32_t args[2] = { static_cast<uint32_t>(reinterpret_cast<uintptr_t>(annotation_class.Get())), 404 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(h_element_array.Get())) }; 405 create_annotation_method->Invoke(self, args, sizeof(args), &result, "LLL"); 406 if (self->IsExceptionPending()) { 407 LOG(INFO) << "Exception in AnnotationFactory.createAnnotation"; 408 return nullptr; 409 } 410 411 return result.GetL(); 412 } 413 414 template <bool kTransactionActive> 415 bool ProcessAnnotationValue(const ClassData& klass, 416 const uint8_t** annotation_ptr, 417 DexFile::AnnotationValue* annotation_value, 418 Handle<mirror::Class> array_class, 419 DexFile::AnnotationResultStyle result_style) 420 REQUIRES_SHARED(Locks::mutator_lock_) { 421 const DexFile& dex_file = klass.GetDexFile(); 422 Thread* self = Thread::Current(); 423 ObjPtr<mirror::Object> element_object = nullptr; 424 bool set_object = false; 425 Primitive::Type primitive_type = Primitive::kPrimVoid; 426 const uint8_t* annotation = *annotation_ptr; 427 uint8_t header_byte = *(annotation++); 428 uint8_t value_type = header_byte & DexFile::kDexAnnotationValueTypeMask; 429 uint8_t value_arg = header_byte >> DexFile::kDexAnnotationValueArgShift; 430 int32_t width = value_arg + 1; 431 annotation_value->type_ = value_type; 432 433 switch (value_type) { 434 case DexFile::kDexAnnotationByte: 435 annotation_value->value_.SetB( 436 static_cast<int8_t>(DexFile::ReadSignedInt(annotation, value_arg))); 437 primitive_type = Primitive::kPrimByte; 438 break; 439 case DexFile::kDexAnnotationShort: 440 annotation_value->value_.SetS( 441 static_cast<int16_t>(DexFile::ReadSignedInt(annotation, value_arg))); 442 primitive_type = Primitive::kPrimShort; 443 break; 444 case DexFile::kDexAnnotationChar: 445 annotation_value->value_.SetC( 446 static_cast<uint16_t>(DexFile::ReadUnsignedInt(annotation, value_arg, false))); 447 primitive_type = Primitive::kPrimChar; 448 break; 449 case DexFile::kDexAnnotationInt: 450 annotation_value->value_.SetI(DexFile::ReadSignedInt(annotation, value_arg)); 451 primitive_type = Primitive::kPrimInt; 452 break; 453 case DexFile::kDexAnnotationLong: 454 annotation_value->value_.SetJ(DexFile::ReadSignedLong(annotation, value_arg)); 455 primitive_type = Primitive::kPrimLong; 456 break; 457 case DexFile::kDexAnnotationFloat: 458 annotation_value->value_.SetI(DexFile::ReadUnsignedInt(annotation, value_arg, true)); 459 primitive_type = Primitive::kPrimFloat; 460 break; 461 case DexFile::kDexAnnotationDouble: 462 annotation_value->value_.SetJ(DexFile::ReadUnsignedLong(annotation, value_arg, true)); 463 primitive_type = Primitive::kPrimDouble; 464 break; 465 case DexFile::kDexAnnotationBoolean: 466 annotation_value->value_.SetZ(value_arg != 0); 467 primitive_type = Primitive::kPrimBoolean; 468 width = 0; 469 break; 470 case DexFile::kDexAnnotationString: { 471 uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false); 472 if (result_style == DexFile::kAllRaw) { 473 annotation_value->value_.SetI(index); 474 } else { 475 StackHandleScope<1> hs(self); 476 element_object = Runtime::Current()->GetClassLinker()->ResolveString( 477 dex::StringIndex(index), hs.NewHandle(klass.GetDexCache())); 478 set_object = true; 479 if (element_object == nullptr) { 480 return false; 481 } 482 } 483 break; 484 } 485 case DexFile::kDexAnnotationType: { 486 uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false); 487 if (result_style == DexFile::kAllRaw) { 488 annotation_value->value_.SetI(index); 489 } else { 490 dex::TypeIndex type_index(index); 491 StackHandleScope<2> hs(self); 492 element_object = Runtime::Current()->GetClassLinker()->ResolveType( 493 type_index, 494 hs.NewHandle(klass.GetDexCache()), 495 hs.NewHandle(klass.GetClassLoader())); 496 set_object = true; 497 if (element_object == nullptr) { 498 CHECK(self->IsExceptionPending()); 499 if (result_style == DexFile::kAllObjects) { 500 const char* msg = dex_file.StringByTypeIdx(type_index); 501 self->ThrowNewWrappedException("Ljava/lang/TypeNotPresentException;", msg); 502 element_object = self->GetException(); 503 self->ClearException(); 504 } else { 505 return false; 506 } 507 } 508 } 509 break; 510 } 511 case DexFile::kDexAnnotationMethod: { 512 uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false); 513 if (result_style == DexFile::kAllRaw) { 514 annotation_value->value_.SetI(index); 515 } else { 516 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 517 StackHandleScope<2> hs(self); 518 ArtMethod* method = class_linker->ResolveMethodWithoutInvokeType( 519 index, 520 hs.NewHandle(klass.GetDexCache()), 521 hs.NewHandle(klass.GetClassLoader())); 522 if (method == nullptr) { 523 return false; 524 } 525 PointerSize pointer_size = class_linker->GetImagePointerSize(); 526 set_object = true; 527 if (method->IsConstructor()) { 528 if (pointer_size == PointerSize::k64) { 529 element_object = mirror::Constructor::CreateFromArtMethod<PointerSize::k64, 530 kTransactionActive>(self, method); 531 } else { 532 element_object = mirror::Constructor::CreateFromArtMethod<PointerSize::k32, 533 kTransactionActive>(self, method); 534 } 535 } else { 536 if (pointer_size == PointerSize::k64) { 537 element_object = mirror::Method::CreateFromArtMethod<PointerSize::k64, 538 kTransactionActive>(self, method); 539 } else { 540 element_object = mirror::Method::CreateFromArtMethod<PointerSize::k32, 541 kTransactionActive>(self, method); 542 } 543 } 544 if (element_object == nullptr) { 545 return false; 546 } 547 } 548 break; 549 } 550 case DexFile::kDexAnnotationField: { 551 uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false); 552 if (result_style == DexFile::kAllRaw) { 553 annotation_value->value_.SetI(index); 554 } else { 555 StackHandleScope<2> hs(self); 556 ArtField* field = Runtime::Current()->GetClassLinker()->ResolveFieldJLS( 557 index, 558 hs.NewHandle(klass.GetDexCache()), 559 hs.NewHandle(klass.GetClassLoader())); 560 if (field == nullptr) { 561 return false; 562 } 563 set_object = true; 564 PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 565 if (pointer_size == PointerSize::k64) { 566 element_object = mirror::Field::CreateFromArtField<PointerSize::k64, 567 kTransactionActive>(self, field, true); 568 } else { 569 element_object = mirror::Field::CreateFromArtField<PointerSize::k32, 570 kTransactionActive>(self, field, true); 571 } 572 if (element_object == nullptr) { 573 return false; 574 } 575 } 576 break; 577 } 578 case DexFile::kDexAnnotationEnum: { 579 uint32_t index = DexFile::ReadUnsignedInt(annotation, value_arg, false); 580 if (result_style == DexFile::kAllRaw) { 581 annotation_value->value_.SetI(index); 582 } else { 583 StackHandleScope<3> hs(self); 584 ArtField* enum_field = Runtime::Current()->GetClassLinker()->ResolveField( 585 index, 586 hs.NewHandle(klass.GetDexCache()), 587 hs.NewHandle(klass.GetClassLoader()), 588 true); 589 if (enum_field == nullptr) { 590 return false; 591 } else { 592 Handle<mirror::Class> field_class(hs.NewHandle(enum_field->GetDeclaringClass())); 593 Runtime::Current()->GetClassLinker()->EnsureInitialized(self, field_class, true, true); 594 element_object = enum_field->GetObject(field_class.Get()); 595 set_object = true; 596 } 597 } 598 break; 599 } 600 case DexFile::kDexAnnotationArray: 601 if (result_style == DexFile::kAllRaw || array_class == nullptr) { 602 return false; 603 } else { 604 ScopedObjectAccessUnchecked soa(self); 605 StackHandleScope<2> hs(self); 606 uint32_t size = DecodeUnsignedLeb128(&annotation); 607 Handle<mirror::Class> component_type(hs.NewHandle(array_class->GetComponentType())); 608 Handle<mirror::Array> new_array(hs.NewHandle(mirror::Array::Alloc<true>( 609 self, array_class.Get(), size, array_class->GetComponentSizeShift(), 610 Runtime::Current()->GetHeap()->GetCurrentAllocator()))); 611 if (new_array == nullptr) { 612 LOG(ERROR) << "Annotation element array allocation failed with size " << size; 613 return false; 614 } 615 DexFile::AnnotationValue new_annotation_value; 616 for (uint32_t i = 0; i < size; ++i) { 617 if (!ProcessAnnotationValue<kTransactionActive>(klass, 618 &annotation, 619 &new_annotation_value, 620 component_type, 621 DexFile::kPrimitivesOrObjects)) { 622 return false; 623 } 624 if (!component_type->IsPrimitive()) { 625 ObjPtr<mirror::Object> obj = new_annotation_value.value_.GetL(); 626 new_array->AsObjectArray<mirror::Object>()-> 627 SetWithoutChecks<kTransactionActive>(i, obj); 628 } else { 629 switch (new_annotation_value.type_) { 630 case DexFile::kDexAnnotationByte: 631 new_array->AsByteArray()->SetWithoutChecks<kTransactionActive>( 632 i, new_annotation_value.value_.GetB()); 633 break; 634 case DexFile::kDexAnnotationShort: 635 new_array->AsShortArray()->SetWithoutChecks<kTransactionActive>( 636 i, new_annotation_value.value_.GetS()); 637 break; 638 case DexFile::kDexAnnotationChar: 639 new_array->AsCharArray()->SetWithoutChecks<kTransactionActive>( 640 i, new_annotation_value.value_.GetC()); 641 break; 642 case DexFile::kDexAnnotationInt: 643 new_array->AsIntArray()->SetWithoutChecks<kTransactionActive>( 644 i, new_annotation_value.value_.GetI()); 645 break; 646 case DexFile::kDexAnnotationLong: 647 new_array->AsLongArray()->SetWithoutChecks<kTransactionActive>( 648 i, new_annotation_value.value_.GetJ()); 649 break; 650 case DexFile::kDexAnnotationFloat: 651 new_array->AsFloatArray()->SetWithoutChecks<kTransactionActive>( 652 i, new_annotation_value.value_.GetF()); 653 break; 654 case DexFile::kDexAnnotationDouble: 655 new_array->AsDoubleArray()->SetWithoutChecks<kTransactionActive>( 656 i, new_annotation_value.value_.GetD()); 657 break; 658 case DexFile::kDexAnnotationBoolean: 659 new_array->AsBooleanArray()->SetWithoutChecks<kTransactionActive>( 660 i, new_annotation_value.value_.GetZ()); 661 break; 662 default: 663 LOG(FATAL) << "Found invalid annotation value type while building annotation array"; 664 return false; 665 } 666 } 667 } 668 element_object = new_array.Get(); 669 set_object = true; 670 width = 0; 671 } 672 break; 673 case DexFile::kDexAnnotationAnnotation: 674 if (result_style == DexFile::kAllRaw) { 675 return false; 676 } 677 element_object = ProcessEncodedAnnotation(klass, &annotation); 678 if (element_object == nullptr) { 679 return false; 680 } 681 set_object = true; 682 width = 0; 683 break; 684 case DexFile::kDexAnnotationNull: 685 if (result_style == DexFile::kAllRaw) { 686 annotation_value->value_.SetI(0); 687 } else { 688 CHECK(element_object == nullptr); 689 set_object = true; 690 } 691 width = 0; 692 break; 693 default: 694 LOG(ERROR) << StringPrintf("Bad annotation element value type 0x%02x", value_type); 695 return false; 696 } 697 698 annotation += width; 699 *annotation_ptr = annotation; 700 701 if (result_style == DexFile::kAllObjects && primitive_type != Primitive::kPrimVoid) { 702 element_object = BoxPrimitive(primitive_type, annotation_value->value_); 703 set_object = true; 704 } 705 706 if (set_object) { 707 annotation_value->value_.SetL(element_object); 708 } 709 710 return true; 711 } 712 713 ObjPtr<mirror::Object> CreateAnnotationMember(const ClassData& klass, 714 Handle<mirror::Class> annotation_class, 715 const uint8_t** annotation) { 716 const DexFile& dex_file = klass.GetDexFile(); 717 Thread* self = Thread::Current(); 718 ScopedObjectAccessUnchecked soa(self); 719 StackHandleScope<5> hs(self); 720 uint32_t element_name_index = DecodeUnsignedLeb128(annotation); 721 const char* name = dex_file.StringDataByIdx(dex::StringIndex(element_name_index)); 722 Handle<mirror::String> string_name( 723 hs.NewHandle(mirror::String::AllocFromModifiedUtf8(self, name))); 724 725 PointerSize pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize(); 726 ArtMethod* annotation_method = 727 annotation_class->FindDeclaredVirtualMethodByName(name, pointer_size); 728 if (annotation_method == nullptr) { 729 return nullptr; 730 } 731 Handle<mirror::Class> method_return(hs.NewHandle(annotation_method->ResolveReturnType())); 732 733 DexFile::AnnotationValue annotation_value; 734 if (!ProcessAnnotationValue<false>(klass, 735 annotation, 736 &annotation_value, 737 method_return, 738 DexFile::kAllObjects)) { 739 return nullptr; 740 } 741 Handle<mirror::Object> value_object(hs.NewHandle(annotation_value.value_.GetL())); 742 743 ObjPtr<mirror::Class> annotation_member_class = 744 WellKnownClasses::ToClass(WellKnownClasses::libcore_reflect_AnnotationMember); 745 Handle<mirror::Object> new_member(hs.NewHandle(annotation_member_class->AllocObject(self))); 746 ObjPtr<mirror::Method> method_obj_ptr; 747 DCHECK(!Runtime::Current()->IsActiveTransaction()); 748 if (pointer_size == PointerSize::k64) { 749 method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k64, false>( 750 self, annotation_method); 751 } else { 752 method_obj_ptr = mirror::Method::CreateFromArtMethod<PointerSize::k32, false>( 753 self, annotation_method); 754 } 755 Handle<mirror::Method> method_object(hs.NewHandle(method_obj_ptr)); 756 757 if (new_member == nullptr || string_name == nullptr || 758 method_object == nullptr || method_return == nullptr) { 759 LOG(ERROR) << StringPrintf("Failed creating annotation element (m=%p n=%p a=%p r=%p", 760 new_member.Get(), string_name.Get(), method_object.Get(), method_return.Get()); 761 return nullptr; 762 } 763 764 JValue result; 765 ArtMethod* annotation_member_init = 766 jni::DecodeArtMethod(WellKnownClasses::libcore_reflect_AnnotationMember_init); 767 uint32_t args[5] = { static_cast<uint32_t>(reinterpret_cast<uintptr_t>(new_member.Get())), 768 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(string_name.Get())), 769 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(value_object.Get())), 770 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(method_return.Get())), 771 static_cast<uint32_t>(reinterpret_cast<uintptr_t>(method_object.Get())) 772 }; 773 annotation_member_init->Invoke(self, args, sizeof(args), &result, "VLLLL"); 774 if (self->IsExceptionPending()) { 775 LOG(INFO) << "Exception in AnnotationMember.<init>"; 776 return nullptr; 777 } 778 779 return new_member.Get(); 780 } 781 782 const AnnotationItem* GetAnnotationItemFromAnnotationSet(const ClassData& klass, 783 const AnnotationSetItem* annotation_set, 784 uint32_t visibility, 785 Handle<mirror::Class> annotation_class) 786 REQUIRES_SHARED(Locks::mutator_lock_) { 787 const DexFile& dex_file = klass.GetDexFile(); 788 for (uint32_t i = 0; i < annotation_set->size_; ++i) { 789 const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i); 790 if (!IsVisibilityCompatible(annotation_item->visibility_, visibility)) { 791 continue; 792 } 793 const uint8_t* annotation = annotation_item->annotation_; 794 uint32_t type_index = DecodeUnsignedLeb128(&annotation); 795 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 796 Thread* self = Thread::Current(); 797 StackHandleScope<2> hs(self); 798 ObjPtr<mirror::Class> resolved_class = class_linker->ResolveType( 799 dex::TypeIndex(type_index), 800 hs.NewHandle(klass.GetDexCache()), 801 hs.NewHandle(klass.GetClassLoader())); 802 if (resolved_class == nullptr) { 803 std::string temp; 804 LOG(WARNING) << StringPrintf("Unable to resolve %s annotation class %d", 805 klass.GetRealClass()->GetDescriptor(&temp), type_index); 806 CHECK(self->IsExceptionPending()); 807 self->ClearException(); 808 continue; 809 } 810 if (resolved_class == annotation_class.Get()) { 811 return annotation_item; 812 } 813 } 814 815 return nullptr; 816 } 817 818 ObjPtr<mirror::Object> GetAnnotationObjectFromAnnotationSet(const ClassData& klass, 819 const AnnotationSetItem* annotation_set, 820 uint32_t visibility, 821 Handle<mirror::Class> annotation_class) 822 REQUIRES_SHARED(Locks::mutator_lock_) { 823 const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet( 824 klass, annotation_set, visibility, annotation_class); 825 if (annotation_item == nullptr) { 826 return nullptr; 827 } 828 const uint8_t* annotation = annotation_item->annotation_; 829 return ProcessEncodedAnnotation(klass, &annotation); 830 } 831 832 ObjPtr<mirror::Object> GetAnnotationValue(const ClassData& klass, 833 const AnnotationItem* annotation_item, 834 const char* annotation_name, 835 Handle<mirror::Class> array_class, 836 uint32_t expected_type) 837 REQUIRES_SHARED(Locks::mutator_lock_) { 838 const DexFile& dex_file = klass.GetDexFile(); 839 const uint8_t* annotation = 840 SearchEncodedAnnotation(dex_file, annotation_item->annotation_, annotation_name); 841 if (annotation == nullptr) { 842 return nullptr; 843 } 844 DexFile::AnnotationValue annotation_value; 845 bool result = Runtime::Current()->IsActiveTransaction() 846 ? ProcessAnnotationValue<true>(klass, 847 &annotation, 848 &annotation_value, 849 array_class, 850 DexFile::kAllObjects) 851 : ProcessAnnotationValue<false>(klass, 852 &annotation, 853 &annotation_value, 854 array_class, 855 DexFile::kAllObjects); 856 if (!result) { 857 return nullptr; 858 } 859 if (annotation_value.type_ != expected_type) { 860 return nullptr; 861 } 862 return annotation_value.value_.GetL(); 863 } 864 865 static ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureValue( 866 const ClassData& klass, 867 const AnnotationSetItem* annotation_set) 868 REQUIRES_SHARED(Locks::mutator_lock_) { 869 const DexFile& dex_file = klass.GetDexFile(); 870 StackHandleScope<1> hs(Thread::Current()); 871 const AnnotationItem* annotation_item = 872 SearchAnnotationSet(dex_file, annotation_set, "Ldalvik/annotation/Signature;", 873 DexFile::kDexVisibilitySystem); 874 if (annotation_item == nullptr) { 875 return nullptr; 876 } 877 Handle<mirror::Class> string_array_class = 878 hs.NewHandle(GetClassRoot<mirror::ObjectArray<mirror::String>>()); 879 DCHECK(string_array_class != nullptr); 880 ObjPtr<mirror::Object> obj = 881 GetAnnotationValue(klass, annotation_item, "value", string_array_class, 882 DexFile::kDexAnnotationArray); 883 if (obj == nullptr) { 884 return nullptr; 885 } 886 return obj->AsObjectArray<mirror::String>(); 887 } 888 889 ObjPtr<mirror::ObjectArray<mirror::Class>> GetThrowsValue(const ClassData& klass, 890 const AnnotationSetItem* annotation_set) 891 REQUIRES_SHARED(Locks::mutator_lock_) { 892 const DexFile& dex_file = klass.GetDexFile(); 893 const AnnotationItem* annotation_item = 894 SearchAnnotationSet(dex_file, annotation_set, "Ldalvik/annotation/Throws;", 895 DexFile::kDexVisibilitySystem); 896 if (annotation_item == nullptr) { 897 return nullptr; 898 } 899 StackHandleScope<1> hs(Thread::Current()); 900 Handle<mirror::Class> class_array_class = 901 hs.NewHandle(GetClassRoot<mirror::ObjectArray<mirror::Class>>()); 902 DCHECK(class_array_class != nullptr); 903 ObjPtr<mirror::Object> obj = 904 GetAnnotationValue(klass, annotation_item, "value", class_array_class, 905 DexFile::kDexAnnotationArray); 906 if (obj == nullptr) { 907 return nullptr; 908 } 909 return obj->AsObjectArray<mirror::Class>(); 910 } 911 912 ObjPtr<mirror::ObjectArray<mirror::Object>> ProcessAnnotationSet( 913 const ClassData& klass, 914 const AnnotationSetItem* annotation_set, 915 uint32_t visibility) 916 REQUIRES_SHARED(Locks::mutator_lock_) { 917 const DexFile& dex_file = klass.GetDexFile(); 918 Thread* self = Thread::Current(); 919 ScopedObjectAccessUnchecked soa(self); 920 StackHandleScope<2> hs(self); 921 Handle<mirror::Class> annotation_array_class(hs.NewHandle( 922 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_annotation_Annotation__array))); 923 if (annotation_set == nullptr) { 924 return mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_class.Get(), 0); 925 } 926 927 uint32_t size = annotation_set->size_; 928 Handle<mirror::ObjectArray<mirror::Object>> result(hs.NewHandle( 929 mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_class.Get(), size))); 930 if (result == nullptr) { 931 return nullptr; 932 } 933 934 uint32_t dest_index = 0; 935 for (uint32_t i = 0; i < size; ++i) { 936 const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(annotation_set, i); 937 // Note that we do not use IsVisibilityCompatible here because older code 938 // was correct for this case. 939 if (annotation_item->visibility_ != visibility) { 940 continue; 941 } 942 const uint8_t* annotation = annotation_item->annotation_; 943 ObjPtr<mirror::Object> annotation_obj = ProcessEncodedAnnotation(klass, &annotation); 944 if (annotation_obj != nullptr) { 945 result->SetWithoutChecks<false>(dest_index, annotation_obj); 946 ++dest_index; 947 } else if (self->IsExceptionPending()) { 948 return nullptr; 949 } 950 } 951 952 if (dest_index == size) { 953 return result.Get(); 954 } 955 956 ObjPtr<mirror::ObjectArray<mirror::Object>> trimmed_result = 957 mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_class.Get(), dest_index); 958 if (trimmed_result == nullptr) { 959 return nullptr; 960 } 961 962 for (uint32_t i = 0; i < dest_index; ++i) { 963 ObjPtr<mirror::Object> obj = result->GetWithoutChecks(i); 964 trimmed_result->SetWithoutChecks<false>(i, obj); 965 } 966 967 return trimmed_result; 968 } 969 970 ObjPtr<mirror::ObjectArray<mirror::Object>> ProcessAnnotationSetRefList( 971 const ClassData& klass, 972 const AnnotationSetRefList* set_ref_list, 973 uint32_t size) 974 REQUIRES_SHARED(Locks::mutator_lock_) { 975 const DexFile& dex_file = klass.GetDexFile(); 976 Thread* self = Thread::Current(); 977 ScopedObjectAccessUnchecked soa(self); 978 StackHandleScope<1> hs(self); 979 ObjPtr<mirror::Class> annotation_array_class = 980 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_annotation_Annotation__array); 981 ObjPtr<mirror::Class> annotation_array_array_class = 982 Runtime::Current()->GetClassLinker()->FindArrayClass(self, annotation_array_class); 983 if (annotation_array_array_class == nullptr) { 984 return nullptr; 985 } 986 Handle<mirror::ObjectArray<mirror::Object>> annotation_array_array(hs.NewHandle( 987 mirror::ObjectArray<mirror::Object>::Alloc(self, annotation_array_array_class, size))); 988 if (annotation_array_array == nullptr) { 989 LOG(ERROR) << "Annotation set ref array allocation failed"; 990 return nullptr; 991 } 992 for (uint32_t index = 0; index < size; ++index) { 993 const AnnotationSetRefItem* set_ref_item = &set_ref_list->list_[index]; 994 const AnnotationSetItem* set_item = dex_file.GetSetRefItemItem(set_ref_item); 995 ObjPtr<mirror::Object> annotation_set = ProcessAnnotationSet(klass, 996 set_item, 997 DexFile::kDexVisibilityRuntime); 998 if (annotation_set == nullptr) { 999 return nullptr; 1000 } 1001 annotation_array_array->SetWithoutChecks<false>(index, annotation_set); 1002 } 1003 return annotation_array_array.Get(); 1004 } 1005 } // namespace 1006 1007 namespace annotations { 1008 1009 ObjPtr<mirror::Object> GetAnnotationForField(ArtField* field, 1010 Handle<mirror::Class> annotation_class) { 1011 const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field); 1012 if (annotation_set == nullptr) { 1013 return nullptr; 1014 } 1015 StackHandleScope<1> hs(Thread::Current()); 1016 const ClassData field_class(hs, field); 1017 return GetAnnotationObjectFromAnnotationSet(field_class, 1018 annotation_set, 1019 DexFile::kDexVisibilityRuntime, 1020 annotation_class); 1021 } 1022 1023 ObjPtr<mirror::ObjectArray<mirror::Object>> GetAnnotationsForField(ArtField* field) { 1024 const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field); 1025 StackHandleScope<1> hs(Thread::Current()); 1026 const ClassData field_class(hs, field); 1027 return ProcessAnnotationSet(field_class, annotation_set, DexFile::kDexVisibilityRuntime); 1028 } 1029 1030 ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureAnnotationForField(ArtField* field) { 1031 const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field); 1032 if (annotation_set == nullptr) { 1033 return nullptr; 1034 } 1035 StackHandleScope<1> hs(Thread::Current()); 1036 const ClassData field_class(hs, field); 1037 return GetSignatureValue(field_class, annotation_set); 1038 } 1039 1040 bool IsFieldAnnotationPresent(ArtField* field, Handle<mirror::Class> annotation_class) { 1041 const AnnotationSetItem* annotation_set = FindAnnotationSetForField(field); 1042 if (annotation_set == nullptr) { 1043 return false; 1044 } 1045 StackHandleScope<1> hs(Thread::Current()); 1046 const ClassData field_class(hs, field); 1047 const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet( 1048 field_class, annotation_set, DexFile::kDexVisibilityRuntime, annotation_class); 1049 return annotation_item != nullptr; 1050 } 1051 1052 ObjPtr<mirror::Object> GetAnnotationDefaultValue(ArtMethod* method) { 1053 const ClassData klass(method); 1054 const DexFile* dex_file = &klass.GetDexFile(); 1055 const AnnotationsDirectoryItem* annotations_dir = 1056 dex_file->GetAnnotationsDirectory(*klass.GetClassDef()); 1057 if (annotations_dir == nullptr) { 1058 return nullptr; 1059 } 1060 const AnnotationSetItem* annotation_set = 1061 dex_file->GetClassAnnotationSet(annotations_dir); 1062 if (annotation_set == nullptr) { 1063 return nullptr; 1064 } 1065 const AnnotationItem* annotation_item = SearchAnnotationSet(*dex_file, annotation_set, 1066 "Ldalvik/annotation/AnnotationDefault;", DexFile::kDexVisibilitySystem); 1067 if (annotation_item == nullptr) { 1068 return nullptr; 1069 } 1070 const uint8_t* annotation = 1071 SearchEncodedAnnotation(*dex_file, annotation_item->annotation_, "value"); 1072 if (annotation == nullptr) { 1073 return nullptr; 1074 } 1075 uint8_t header_byte = *(annotation++); 1076 if ((header_byte & DexFile::kDexAnnotationValueTypeMask) != DexFile::kDexAnnotationAnnotation) { 1077 return nullptr; 1078 } 1079 annotation = SearchEncodedAnnotation(*dex_file, annotation, method->GetName()); 1080 if (annotation == nullptr) { 1081 return nullptr; 1082 } 1083 DexFile::AnnotationValue annotation_value; 1084 StackHandleScope<1> hs(Thread::Current()); 1085 Handle<mirror::Class> return_type(hs.NewHandle(method->ResolveReturnType())); 1086 if (!ProcessAnnotationValue<false>(klass, 1087 &annotation, 1088 &annotation_value, 1089 return_type, 1090 DexFile::kAllObjects)) { 1091 return nullptr; 1092 } 1093 return annotation_value.value_.GetL(); 1094 } 1095 1096 ObjPtr<mirror::Object> GetAnnotationForMethod(ArtMethod* method, 1097 Handle<mirror::Class> annotation_class) { 1098 const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method); 1099 if (annotation_set == nullptr) { 1100 return nullptr; 1101 } 1102 return GetAnnotationObjectFromAnnotationSet(ClassData(method), annotation_set, 1103 DexFile::kDexVisibilityRuntime, annotation_class); 1104 } 1105 1106 ObjPtr<mirror::ObjectArray<mirror::Object>> GetAnnotationsForMethod(ArtMethod* method) { 1107 const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method); 1108 return ProcessAnnotationSet(ClassData(method), 1109 annotation_set, 1110 DexFile::kDexVisibilityRuntime); 1111 } 1112 1113 ObjPtr<mirror::ObjectArray<mirror::Class>> GetExceptionTypesForMethod(ArtMethod* method) { 1114 const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method); 1115 if (annotation_set == nullptr) { 1116 return nullptr; 1117 } 1118 return GetThrowsValue(ClassData(method), annotation_set); 1119 } 1120 1121 ObjPtr<mirror::ObjectArray<mirror::Object>> GetParameterAnnotations(ArtMethod* method) { 1122 const DexFile* dex_file = method->GetDexFile(); 1123 const ParameterAnnotationsItem* parameter_annotations = 1124 FindAnnotationsItemForMethod(method); 1125 if (parameter_annotations == nullptr) { 1126 return nullptr; 1127 } 1128 const AnnotationSetRefList* set_ref_list = 1129 dex_file->GetParameterAnnotationSetRefList(parameter_annotations); 1130 if (set_ref_list == nullptr) { 1131 return nullptr; 1132 } 1133 uint32_t size = set_ref_list->size_; 1134 return ProcessAnnotationSetRefList(ClassData(method), set_ref_list, size); 1135 } 1136 1137 uint32_t GetNumberOfAnnotatedMethodParameters(ArtMethod* method) { 1138 const DexFile* dex_file = method->GetDexFile(); 1139 const ParameterAnnotationsItem* parameter_annotations = 1140 FindAnnotationsItemForMethod(method); 1141 if (parameter_annotations == nullptr) { 1142 return 0u; 1143 } 1144 const AnnotationSetRefList* set_ref_list = 1145 dex_file->GetParameterAnnotationSetRefList(parameter_annotations); 1146 if (set_ref_list == nullptr) { 1147 return 0u; 1148 } 1149 return set_ref_list->size_; 1150 } 1151 1152 ObjPtr<mirror::Object> GetAnnotationForMethodParameter(ArtMethod* method, 1153 uint32_t parameter_idx, 1154 Handle<mirror::Class> annotation_class) { 1155 const DexFile* dex_file = method->GetDexFile(); 1156 const ParameterAnnotationsItem* parameter_annotations = FindAnnotationsItemForMethod(method); 1157 if (parameter_annotations == nullptr) { 1158 return nullptr; 1159 } 1160 const AnnotationSetRefList* set_ref_list = 1161 dex_file->GetParameterAnnotationSetRefList(parameter_annotations); 1162 if (set_ref_list == nullptr) { 1163 return nullptr; 1164 } 1165 if (parameter_idx >= set_ref_list->size_) { 1166 return nullptr; 1167 } 1168 const AnnotationSetRefItem* annotation_set_ref = &set_ref_list->list_[parameter_idx]; 1169 const AnnotationSetItem* annotation_set = 1170 dex_file->GetSetRefItemItem(annotation_set_ref); 1171 if (annotation_set == nullptr) { 1172 return nullptr; 1173 } 1174 return GetAnnotationObjectFromAnnotationSet(ClassData(method), 1175 annotation_set, 1176 DexFile::kDexVisibilityRuntime, 1177 annotation_class); 1178 } 1179 1180 bool GetParametersMetadataForMethod( 1181 ArtMethod* method, 1182 /*out*/ MutableHandle<mirror::ObjectArray<mirror::String>>* names, 1183 /*out*/ MutableHandle<mirror::IntArray>* access_flags) { 1184 const AnnotationSetItem* annotation_set = 1185 FindAnnotationSetForMethod(method); 1186 if (annotation_set == nullptr) { 1187 return false; 1188 } 1189 1190 const DexFile* dex_file = method->GetDexFile(); 1191 const AnnotationItem* annotation_item = 1192 SearchAnnotationSet(*dex_file, 1193 annotation_set, 1194 "Ldalvik/annotation/MethodParameters;", 1195 DexFile::kDexVisibilitySystem); 1196 if (annotation_item == nullptr) { 1197 return false; 1198 } 1199 1200 StackHandleScope<4> hs(Thread::Current()); 1201 1202 // Extract the parameters' names String[]. 1203 ClassLinker* class_linker = Runtime::Current()->GetClassLinker(); 1204 Handle<mirror::Class> string_array_class = 1205 hs.NewHandle(GetClassRoot<mirror::ObjectArray<mirror::String>>(class_linker)); 1206 DCHECK(string_array_class != nullptr); 1207 1208 ClassData data(method); 1209 Handle<mirror::Object> names_obj = 1210 hs.NewHandle(GetAnnotationValue(data, 1211 annotation_item, 1212 "names", 1213 string_array_class, 1214 DexFile::kDexAnnotationArray)); 1215 if (names_obj == nullptr) { 1216 return false; 1217 } 1218 1219 // Extract the parameters' access flags int[]. 1220 Handle<mirror::Class> int_array_class(hs.NewHandle(GetClassRoot<mirror::IntArray>(class_linker))); 1221 DCHECK(int_array_class != nullptr); 1222 Handle<mirror::Object> access_flags_obj = 1223 hs.NewHandle(GetAnnotationValue(data, 1224 annotation_item, 1225 "accessFlags", 1226 int_array_class, 1227 DexFile::kDexAnnotationArray)); 1228 if (access_flags_obj == nullptr) { 1229 return false; 1230 } 1231 1232 names->Assign(names_obj->AsObjectArray<mirror::String>()); 1233 access_flags->Assign(access_flags_obj->AsIntArray()); 1234 return true; 1235 } 1236 1237 ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureAnnotationForMethod(ArtMethod* method) { 1238 const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method); 1239 if (annotation_set == nullptr) { 1240 return nullptr; 1241 } 1242 return GetSignatureValue(ClassData(method), annotation_set); 1243 } 1244 1245 bool IsMethodAnnotationPresent(ArtMethod* method, 1246 Handle<mirror::Class> annotation_class, 1247 uint32_t visibility /* = DexFile::kDexVisibilityRuntime */) { 1248 const AnnotationSetItem* annotation_set = FindAnnotationSetForMethod(method); 1249 if (annotation_set == nullptr) { 1250 return false; 1251 } 1252 const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet( 1253 ClassData(method), annotation_set, visibility, annotation_class); 1254 return annotation_item != nullptr; 1255 } 1256 1257 static void DCheckNativeAnnotation(const char* descriptor, jclass cls) { 1258 if (kIsDebugBuild) { 1259 ScopedObjectAccess soa(Thread::Current()); 1260 ObjPtr<mirror::Class> klass = soa.Decode<mirror::Class>(cls); 1261 ClassLinker* linker = Runtime::Current()->GetClassLinker(); 1262 // WellKnownClasses may not be initialized yet, so `klass` may be null. 1263 if (klass != nullptr) { 1264 // Lookup using the boot class path loader should yield the annotation class. 1265 CHECK_EQ(klass, linker->LookupClass(soa.Self(), descriptor, /* class_loader= */ nullptr)); 1266 } 1267 } 1268 } 1269 1270 // Check whether a method from the `dex_file` with the given `annotation_set` 1271 // is annotated with `annotation_descriptor` with build visibility. 1272 static bool IsMethodBuildAnnotationPresent(const DexFile& dex_file, 1273 const AnnotationSetItem& annotation_set, 1274 const char* annotation_descriptor, 1275 jclass annotation_class) { 1276 for (uint32_t i = 0; i < annotation_set.size_; ++i) { 1277 const AnnotationItem* annotation_item = dex_file.GetAnnotationItem(&annotation_set, i); 1278 if (!IsVisibilityCompatible(annotation_item->visibility_, DexFile::kDexVisibilityBuild)) { 1279 continue; 1280 } 1281 const uint8_t* annotation = annotation_item->annotation_; 1282 uint32_t type_index = DecodeUnsignedLeb128(&annotation); 1283 const char* descriptor = dex_file.StringByTypeIdx(dex::TypeIndex(type_index)); 1284 if (strcmp(descriptor, annotation_descriptor) == 0) { 1285 DCheckNativeAnnotation(descriptor, annotation_class); 1286 return true; 1287 } 1288 } 1289 return false; 1290 } 1291 1292 uint32_t GetNativeMethodAnnotationAccessFlags(const DexFile& dex_file, 1293 const dex::ClassDef& class_def, 1294 uint32_t method_index) { 1295 const dex::AnnotationSetItem* annotation_set = 1296 FindAnnotationSetForMethod(dex_file, class_def, method_index); 1297 if (annotation_set == nullptr) { 1298 return 0u; 1299 } 1300 uint32_t access_flags = 0u; 1301 if (IsMethodBuildAnnotationPresent( 1302 dex_file, 1303 *annotation_set, 1304 "Ldalvik/annotation/optimization/FastNative;", 1305 WellKnownClasses::dalvik_annotation_optimization_FastNative)) { 1306 access_flags |= kAccFastNative; 1307 } 1308 if (IsMethodBuildAnnotationPresent( 1309 dex_file, 1310 *annotation_set, 1311 "Ldalvik/annotation/optimization/CriticalNative;", 1312 WellKnownClasses::dalvik_annotation_optimization_CriticalNative)) { 1313 access_flags |= kAccCriticalNative; 1314 } 1315 CHECK_NE(access_flags, kAccFastNative | kAccCriticalNative); 1316 return access_flags; 1317 } 1318 1319 bool FieldIsReachabilitySensitive(const DexFile& dex_file, 1320 const dex::ClassDef& class_def, 1321 uint32_t field_index) 1322 REQUIRES_SHARED(Locks::mutator_lock_) { 1323 const AnnotationSetItem* annotation_set = 1324 FindAnnotationSetForField(dex_file, class_def, field_index); 1325 if (annotation_set == nullptr) { 1326 return false; 1327 } 1328 const AnnotationItem* annotation_item = SearchAnnotationSet(dex_file, annotation_set, 1329 "Ldalvik/annotation/optimization/ReachabilitySensitive;", DexFile::kDexVisibilityRuntime); 1330 // TODO: We're missing the equivalent of DCheckNativeAnnotation (not a DCHECK). Does it matter? 1331 return annotation_item != nullptr; 1332 } 1333 1334 bool MethodIsReachabilitySensitive(const DexFile& dex_file, 1335 const dex::ClassDef& class_def, 1336 uint32_t method_index) 1337 REQUIRES_SHARED(Locks::mutator_lock_) { 1338 const AnnotationSetItem* annotation_set = 1339 FindAnnotationSetForMethod(dex_file, class_def, method_index); 1340 if (annotation_set == nullptr) { 1341 return false; 1342 } 1343 const AnnotationItem* annotation_item = SearchAnnotationSet(dex_file, annotation_set, 1344 "Ldalvik/annotation/optimization/ReachabilitySensitive;", DexFile::kDexVisibilityRuntime); 1345 return annotation_item != nullptr; 1346 } 1347 1348 static bool MethodIsReachabilitySensitive(const DexFile& dex_file, 1349 uint32_t method_index) 1350 REQUIRES_SHARED(Locks::mutator_lock_) { 1351 DCHECK(method_index < dex_file.NumMethodIds()); 1352 const dex::MethodId& method_id = dex_file.GetMethodId(method_index); 1353 dex::TypeIndex class_index = method_id.class_idx_; 1354 const dex::ClassDef * class_def = dex_file.FindClassDef(class_index); 1355 return class_def != nullptr 1356 && MethodIsReachabilitySensitive(dex_file, *class_def, method_index); 1357 } 1358 1359 bool MethodContainsRSensitiveAccess(const DexFile& dex_file, 1360 const dex::ClassDef& class_def, 1361 uint32_t method_index) 1362 REQUIRES_SHARED(Locks::mutator_lock_) { 1363 // TODO: This is too slow to run very regularly. Currently this is only invoked in the 1364 // presence of @DeadReferenceSafe, which will be rare. In the long run, we need to quickly 1365 // check once whether a class has any @ReachabilitySensitive annotations. If not, we can 1366 // immediately return false here for any method in that class. 1367 uint32_t code_item_offset = dex_file.FindCodeItemOffset(class_def, method_index); 1368 const dex::CodeItem* code_item = dex_file.GetCodeItem(code_item_offset); 1369 CodeItemInstructionAccessor accessor(dex_file, code_item); 1370 if (!accessor.HasCodeItem()) { 1371 return false; 1372 } 1373 ArrayRef<const uint8_t> quicken_data; 1374 const OatDexFile* oat_dex_file = dex_file.GetOatDexFile(); 1375 if (oat_dex_file != nullptr) { 1376 quicken_data = oat_dex_file->GetQuickenedInfoOf(dex_file, method_index); 1377 } 1378 const QuickenInfoTable quicken_info(quicken_data); 1379 uint32_t quicken_index = 0; 1380 for (DexInstructionIterator iter = accessor.begin(); iter != accessor.end(); ++iter) { 1381 switch (iter->Opcode()) { 1382 case Instruction::IGET: 1383 case Instruction::IGET_QUICK: 1384 case Instruction::IGET_WIDE: 1385 case Instruction::IGET_WIDE_QUICK: 1386 case Instruction::IGET_OBJECT: 1387 case Instruction::IGET_OBJECT_QUICK: 1388 case Instruction::IGET_BOOLEAN: 1389 case Instruction::IGET_BOOLEAN_QUICK: 1390 case Instruction::IGET_BYTE: 1391 case Instruction::IGET_BYTE_QUICK: 1392 case Instruction::IGET_CHAR: 1393 case Instruction::IGET_CHAR_QUICK: 1394 case Instruction::IGET_SHORT: 1395 case Instruction::IGET_SHORT_QUICK: 1396 case Instruction::IPUT: 1397 case Instruction::IPUT_QUICK: 1398 case Instruction::IPUT_WIDE: 1399 case Instruction::IPUT_WIDE_QUICK: 1400 case Instruction::IPUT_OBJECT: 1401 case Instruction::IPUT_OBJECT_QUICK: 1402 case Instruction::IPUT_BOOLEAN: 1403 case Instruction::IPUT_BOOLEAN_QUICK: 1404 case Instruction::IPUT_BYTE: 1405 case Instruction::IPUT_BYTE_QUICK: 1406 case Instruction::IPUT_CHAR: 1407 case Instruction::IPUT_CHAR_QUICK: 1408 case Instruction::IPUT_SHORT: 1409 case Instruction::IPUT_SHORT_QUICK: 1410 { 1411 uint32_t field_index; 1412 if (iter->IsQuickened()) { 1413 field_index = quicken_info.GetData(quicken_index); 1414 } else { 1415 field_index = iter->VRegC_22c(); 1416 } 1417 DCHECK(field_index < dex_file.NumFieldIds()); 1418 // We only guarantee to pay attention to the annotation if it's in the same class, 1419 // or a containing class, but it's OK to do so in other cases. 1420 const dex::FieldId& field_id = dex_file.GetFieldId(field_index); 1421 dex::TypeIndex class_index = field_id.class_idx_; 1422 const dex::ClassDef * field_class_def = dex_file.FindClassDef(class_index); 1423 // We do not handle the case in which the field is declared in a superclass, and 1424 // don't claim to do so. The annotated field should normally be private. 1425 if (field_class_def != nullptr 1426 && FieldIsReachabilitySensitive(dex_file, *field_class_def, field_index)) { 1427 return true; 1428 } 1429 } 1430 break; 1431 case Instruction::INVOKE_SUPER: 1432 // Cannot call method in same class. TODO: Try an explicit superclass lookup for 1433 // better "best effort"? 1434 break; 1435 case Instruction::INVOKE_INTERFACE: 1436 // We handle an interface call just like a virtual call. We will find annotations 1437 // on interface methods/fields visible to us, but not of the annotation is in a 1438 // super-interface. Again, we could just ignore it. 1439 case Instruction::INVOKE_VIRTUAL: 1440 case Instruction::INVOKE_DIRECT: 1441 { 1442 uint32_t called_method_index = iter->VRegB_35c(); 1443 if (MethodIsReachabilitySensitive(dex_file, called_method_index)) { 1444 return true; 1445 } 1446 } 1447 break; 1448 case Instruction::INVOKE_INTERFACE_RANGE: 1449 case Instruction::INVOKE_VIRTUAL_RANGE: 1450 case Instruction::INVOKE_DIRECT_RANGE: 1451 { 1452 uint32_t called_method_index = iter->VRegB_3rc(); 1453 if (MethodIsReachabilitySensitive(dex_file, called_method_index)) { 1454 return true; 1455 } 1456 } 1457 break; 1458 case Instruction::INVOKE_VIRTUAL_QUICK: 1459 case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: 1460 { 1461 uint32_t called_method_index = quicken_info.GetData(quicken_index); 1462 if (MethodIsReachabilitySensitive(dex_file, called_method_index)) { 1463 return true; 1464 } 1465 } 1466 break; 1467 // We explicitly do not handle indirect ReachabilitySensitive accesses through VarHandles, 1468 // etc. Thus we ignore INVOKE_CUSTOM / INVOKE_CUSTOM_RANGE / INVOKE_POLYMORPHIC / 1469 // INVOKE_POLYMORPHIC_RANGE. 1470 default: 1471 // There is no way to add an annotation to array elements, and so far we've encountered no 1472 // need for that, so we ignore AGET and APUT. 1473 // It's impractical or impossible to garbage collect a class while one of its methods is 1474 // on the call stack. We allow ReachabilitySensitive annotations on static methods and 1475 // fields, but they can be safely ignored. 1476 break; 1477 } 1478 if (QuickenInfoTable::NeedsIndexForInstruction(&iter.Inst())) { 1479 ++quicken_index; 1480 } 1481 } 1482 return false; 1483 } 1484 1485 bool HasDeadReferenceSafeAnnotation(const DexFile& dex_file, 1486 const dex::ClassDef& class_def) 1487 // TODO: This should check outer classes as well. 1488 // It's conservatively correct not to do so. 1489 REQUIRES_SHARED(Locks::mutator_lock_) { 1490 const AnnotationsDirectoryItem* annotations_dir = 1491 dex_file.GetAnnotationsDirectory(class_def); 1492 if (annotations_dir == nullptr) { 1493 return false; 1494 } 1495 const AnnotationSetItem* annotation_set = dex_file.GetClassAnnotationSet(annotations_dir); 1496 if (annotation_set == nullptr) { 1497 return false; 1498 } 1499 const AnnotationItem* annotation_item = SearchAnnotationSet(dex_file, annotation_set, 1500 "Ldalvik/annotation/optimization/DeadReferenceSafe;", DexFile::kDexVisibilityRuntime); 1501 return annotation_item != nullptr; 1502 } 1503 1504 ObjPtr<mirror::Object> GetAnnotationForClass(Handle<mirror::Class> klass, 1505 Handle<mirror::Class> annotation_class) { 1506 ClassData data(klass); 1507 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1508 if (annotation_set == nullptr) { 1509 return nullptr; 1510 } 1511 return GetAnnotationObjectFromAnnotationSet(data, 1512 annotation_set, 1513 DexFile::kDexVisibilityRuntime, 1514 annotation_class); 1515 } 1516 1517 ObjPtr<mirror::ObjectArray<mirror::Object>> GetAnnotationsForClass(Handle<mirror::Class> klass) { 1518 ClassData data(klass); 1519 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1520 return ProcessAnnotationSet(data, annotation_set, DexFile::kDexVisibilityRuntime); 1521 } 1522 1523 ObjPtr<mirror::ObjectArray<mirror::Class>> GetDeclaredClasses(Handle<mirror::Class> klass) { 1524 ClassData data(klass); 1525 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1526 if (annotation_set == nullptr) { 1527 return nullptr; 1528 } 1529 const AnnotationItem* annotation_item = 1530 SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/MemberClasses;", 1531 DexFile::kDexVisibilitySystem); 1532 if (annotation_item == nullptr) { 1533 return nullptr; 1534 } 1535 StackHandleScope<1> hs(Thread::Current()); 1536 Handle<mirror::Class> class_array_class = 1537 hs.NewHandle(GetClassRoot<mirror::ObjectArray<mirror::Class>>()); 1538 DCHECK(class_array_class != nullptr); 1539 ObjPtr<mirror::Object> obj = 1540 GetAnnotationValue(data, annotation_item, "value", class_array_class, 1541 DexFile::kDexAnnotationArray); 1542 if (obj == nullptr) { 1543 return nullptr; 1544 } 1545 return obj->AsObjectArray<mirror::Class>(); 1546 } 1547 1548 ObjPtr<mirror::Class> GetDeclaringClass(Handle<mirror::Class> klass) { 1549 ClassData data(klass); 1550 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1551 if (annotation_set == nullptr) { 1552 return nullptr; 1553 } 1554 const AnnotationItem* annotation_item = 1555 SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/EnclosingClass;", 1556 DexFile::kDexVisibilitySystem); 1557 if (annotation_item == nullptr) { 1558 return nullptr; 1559 } 1560 ObjPtr<mirror::Object> obj = GetAnnotationValue(data, 1561 annotation_item, 1562 "value", 1563 ScopedNullHandle<mirror::Class>(), 1564 DexFile::kDexAnnotationType); 1565 if (obj == nullptr) { 1566 return nullptr; 1567 } 1568 return obj->AsClass(); 1569 } 1570 1571 ObjPtr<mirror::Class> GetEnclosingClass(Handle<mirror::Class> klass) { 1572 ObjPtr<mirror::Class> declaring_class = GetDeclaringClass(klass); 1573 if (declaring_class != nullptr) { 1574 return declaring_class; 1575 } 1576 ClassData data(klass); 1577 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1578 if (annotation_set == nullptr) { 1579 return nullptr; 1580 } 1581 const AnnotationItem* annotation_item = 1582 SearchAnnotationSet(data.GetDexFile(), 1583 annotation_set, 1584 "Ldalvik/annotation/EnclosingMethod;", 1585 DexFile::kDexVisibilitySystem); 1586 if (annotation_item == nullptr) { 1587 return nullptr; 1588 } 1589 const uint8_t* annotation = 1590 SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "value"); 1591 if (annotation == nullptr) { 1592 return nullptr; 1593 } 1594 DexFile::AnnotationValue annotation_value; 1595 if (!ProcessAnnotationValue<false>(data, 1596 &annotation, 1597 &annotation_value, 1598 ScopedNullHandle<mirror::Class>(), 1599 DexFile::kAllRaw)) { 1600 return nullptr; 1601 } 1602 if (annotation_value.type_ != DexFile::kDexAnnotationMethod) { 1603 return nullptr; 1604 } 1605 StackHandleScope<2> hs(Thread::Current()); 1606 ArtMethod* method = Runtime::Current()->GetClassLinker()->ResolveMethodWithoutInvokeType( 1607 annotation_value.value_.GetI(), 1608 hs.NewHandle(data.GetDexCache()), 1609 hs.NewHandle(data.GetClassLoader())); 1610 if (method == nullptr) { 1611 return nullptr; 1612 } 1613 return method->GetDeclaringClass(); 1614 } 1615 1616 ObjPtr<mirror::Object> GetEnclosingMethod(Handle<mirror::Class> klass) { 1617 ClassData data(klass); 1618 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1619 if (annotation_set == nullptr) { 1620 return nullptr; 1621 } 1622 const AnnotationItem* annotation_item = 1623 SearchAnnotationSet(data.GetDexFile(), 1624 annotation_set, 1625 "Ldalvik/annotation/EnclosingMethod;", 1626 DexFile::kDexVisibilitySystem); 1627 if (annotation_item == nullptr) { 1628 return nullptr; 1629 } 1630 return GetAnnotationValue(data, annotation_item, "value", ScopedNullHandle<mirror::Class>(), 1631 DexFile::kDexAnnotationMethod); 1632 } 1633 1634 bool GetInnerClass(Handle<mirror::Class> klass, /*out*/ ObjPtr<mirror::String>* name) { 1635 ClassData data(klass); 1636 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1637 if (annotation_set == nullptr) { 1638 return false; 1639 } 1640 const AnnotationItem* annotation_item = SearchAnnotationSet( 1641 data.GetDexFile(), 1642 annotation_set, 1643 "Ldalvik/annotation/InnerClass;", 1644 DexFile::kDexVisibilitySystem); 1645 if (annotation_item == nullptr) { 1646 return false; 1647 } 1648 const uint8_t* annotation = 1649 SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "name"); 1650 if (annotation == nullptr) { 1651 return false; 1652 } 1653 DexFile::AnnotationValue annotation_value; 1654 if (!ProcessAnnotationValue<false>(data, 1655 &annotation, 1656 &annotation_value, 1657 ScopedNullHandle<mirror::Class>(), 1658 DexFile::kAllObjects)) { 1659 return false; 1660 } 1661 if (annotation_value.type_ != DexFile::kDexAnnotationNull && 1662 annotation_value.type_ != DexFile::kDexAnnotationString) { 1663 return false; 1664 } 1665 *name = down_cast<mirror::String*>(annotation_value.value_.GetL()); 1666 return true; 1667 } 1668 1669 bool GetInnerClassFlags(Handle<mirror::Class> klass, uint32_t* flags) { 1670 ClassData data(klass); 1671 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1672 if (annotation_set == nullptr) { 1673 return false; 1674 } 1675 const AnnotationItem* annotation_item = 1676 SearchAnnotationSet(data.GetDexFile(), annotation_set, "Ldalvik/annotation/InnerClass;", 1677 DexFile::kDexVisibilitySystem); 1678 if (annotation_item == nullptr) { 1679 return false; 1680 } 1681 const uint8_t* annotation = 1682 SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "accessFlags"); 1683 if (annotation == nullptr) { 1684 return false; 1685 } 1686 DexFile::AnnotationValue annotation_value; 1687 if (!ProcessAnnotationValue<false>(data, 1688 &annotation, 1689 &annotation_value, 1690 ScopedNullHandle<mirror::Class>(), 1691 DexFile::kAllRaw)) { 1692 return false; 1693 } 1694 if (annotation_value.type_ != DexFile::kDexAnnotationInt) { 1695 return false; 1696 } 1697 *flags = annotation_value.value_.GetI(); 1698 return true; 1699 } 1700 1701 ObjPtr<mirror::ObjectArray<mirror::String>> GetSignatureAnnotationForClass( 1702 Handle<mirror::Class> klass) { 1703 ClassData data(klass); 1704 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1705 if (annotation_set == nullptr) { 1706 return nullptr; 1707 } 1708 return GetSignatureValue(data, annotation_set); 1709 } 1710 1711 const char* GetSourceDebugExtension(Handle<mirror::Class> klass) { 1712 // Before instantiating ClassData, check that klass has a DexCache 1713 // assigned. The ClassData constructor indirectly dereferences it 1714 // when calling klass->GetDexFile(). 1715 if (klass->GetDexCache() == nullptr) { 1716 DCHECK(klass->IsPrimitive() || klass->IsArrayClass()); 1717 return nullptr; 1718 } 1719 1720 ClassData data(klass); 1721 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1722 if (annotation_set == nullptr) { 1723 return nullptr; 1724 } 1725 1726 const AnnotationItem* annotation_item = SearchAnnotationSet( 1727 data.GetDexFile(), 1728 annotation_set, 1729 "Ldalvik/annotation/SourceDebugExtension;", 1730 DexFile::kDexVisibilitySystem); 1731 if (annotation_item == nullptr) { 1732 return nullptr; 1733 } 1734 1735 const uint8_t* annotation = 1736 SearchEncodedAnnotation(data.GetDexFile(), annotation_item->annotation_, "value"); 1737 if (annotation == nullptr) { 1738 return nullptr; 1739 } 1740 DexFile::AnnotationValue annotation_value; 1741 if (!ProcessAnnotationValue<false>(data, 1742 &annotation, 1743 &annotation_value, 1744 ScopedNullHandle<mirror::Class>(), 1745 DexFile::kAllRaw)) { 1746 return nullptr; 1747 } 1748 if (annotation_value.type_ != DexFile::kDexAnnotationString) { 1749 return nullptr; 1750 } 1751 dex::StringIndex index(static_cast<uint32_t>(annotation_value.value_.GetI())); 1752 return data.GetDexFile().StringDataByIdx(index); 1753 } 1754 1755 bool IsClassAnnotationPresent(Handle<mirror::Class> klass, Handle<mirror::Class> annotation_class) { 1756 ClassData data(klass); 1757 const AnnotationSetItem* annotation_set = FindAnnotationSetForClass(data); 1758 if (annotation_set == nullptr) { 1759 return false; 1760 } 1761 const AnnotationItem* annotation_item = GetAnnotationItemFromAnnotationSet( 1762 data, annotation_set, DexFile::kDexVisibilityRuntime, annotation_class); 1763 return annotation_item != nullptr; 1764 } 1765 1766 int32_t GetLineNumFromPC(const DexFile* dex_file, ArtMethod* method, uint32_t rel_pc) { 1767 // For native method, lineno should be -2 to indicate it is native. Note that 1768 // "line number == -2" is how libcore tells from StackTraceElement. 1769 if (method->GetCodeItemOffset() == 0) { 1770 return -2; 1771 } 1772 1773 CodeItemDebugInfoAccessor accessor(method->DexInstructionDebugInfo()); 1774 DCHECK(accessor.HasCodeItem()) << method->PrettyMethod() << " " << dex_file->GetLocation(); 1775 1776 // A method with no line number info should return -1 1777 uint32_t line_num = -1; 1778 accessor.GetLineNumForPc(rel_pc, &line_num); 1779 return line_num; 1780 } 1781 1782 template<bool kTransactionActive> 1783 void RuntimeEncodedStaticFieldValueIterator::ReadValueToField(ArtField* field) const { 1784 DCHECK(dex_cache_ != nullptr); 1785 switch (type_) { 1786 case kBoolean: field->SetBoolean<kTransactionActive>(field->GetDeclaringClass(), jval_.z); 1787 break; 1788 case kByte: field->SetByte<kTransactionActive>(field->GetDeclaringClass(), jval_.b); break; 1789 case kShort: field->SetShort<kTransactionActive>(field->GetDeclaringClass(), jval_.s); break; 1790 case kChar: field->SetChar<kTransactionActive>(field->GetDeclaringClass(), jval_.c); break; 1791 case kInt: field->SetInt<kTransactionActive>(field->GetDeclaringClass(), jval_.i); break; 1792 case kLong: field->SetLong<kTransactionActive>(field->GetDeclaringClass(), jval_.j); break; 1793 case kFloat: field->SetFloat<kTransactionActive>(field->GetDeclaringClass(), jval_.f); break; 1794 case kDouble: field->SetDouble<kTransactionActive>(field->GetDeclaringClass(), jval_.d); break; 1795 case kNull: field->SetObject<kTransactionActive>(field->GetDeclaringClass(), nullptr); break; 1796 case kString: { 1797 ObjPtr<mirror::String> resolved = linker_->ResolveString(dex::StringIndex(jval_.i), 1798 dex_cache_); 1799 field->SetObject<kTransactionActive>(field->GetDeclaringClass(), resolved); 1800 break; 1801 } 1802 case kType: { 1803 ObjPtr<mirror::Class> resolved = linker_->ResolveType(dex::TypeIndex(jval_.i), 1804 dex_cache_, 1805 class_loader_); 1806 field->SetObject<kTransactionActive>(field->GetDeclaringClass(), resolved); 1807 break; 1808 } 1809 default: UNIMPLEMENTED(FATAL) << ": type " << type_; 1810 } 1811 } 1812 template 1813 void RuntimeEncodedStaticFieldValueIterator::ReadValueToField<true>(ArtField* field) const; 1814 template 1815 void RuntimeEncodedStaticFieldValueIterator::ReadValueToField<false>(ArtField* field) const; 1816 1817 } // namespace annotations 1818 1819 } // namespace art 1820
