dex_file.h revision 03b6eafba8ace9a9c4d5ee9c47723d1910ccd7a8
1/* 2 * Copyright (C) 2011 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#ifndef ART_RUNTIME_DEX_FILE_H_ 18#define ART_RUNTIME_DEX_FILE_H_ 19 20#include <memory> 21#include <string> 22#include <unordered_map> 23#include <vector> 24 25#include "base/logging.h" 26#include "base/mutex.h" // For Locks::mutator_lock_. 27#include "base/value_object.h" 28#include "globals.h" 29#include "invoke_type.h" 30#include "jni.h" 31#include "modifiers.h" 32#include "utf.h" 33 34namespace art { 35 36// TODO: remove dependencies on mirror classes, primarily by moving 37// EncodedStaticFieldValueIterator to its own file. 38namespace mirror { 39 class ArtField; 40 class ArtMethod; 41 class ClassLoader; 42 class DexCache; 43} // namespace mirror 44class ClassLinker; 45class MemMap; 46class Signature; 47template<class T> class Handle; 48class StringPiece; 49class ZipArchive; 50 51// TODO: move all of the macro functionality into the DexCache class. 52class DexFile { 53 public: 54 static const uint8_t kDexMagic[]; 55 static const uint8_t kDexMagicVersion[]; 56 static constexpr size_t kSha1DigestSize = 20; 57 static constexpr uint32_t kDexEndianConstant = 0x12345678; 58 59 // name of the DexFile entry within a zip archive 60 static const char* kClassesDex; 61 62 // The value of an invalid index. 63 static const uint32_t kDexNoIndex = 0xFFFFFFFF; 64 65 // The value of an invalid index. 66 static const uint16_t kDexNoIndex16 = 0xFFFF; 67 68 // The separator charactor in MultiDex locations. 69 static constexpr char kMultiDexSeparator = ':'; 70 71 // A string version of the previous. This is a define so that we can merge string literals in the 72 // preprocessor. 73 #define kMultiDexSeparatorString ":" 74 75 // Raw header_item. 76 struct Header { 77 uint8_t magic_[8]; 78 uint32_t checksum_; // See also location_checksum_ 79 uint8_t signature_[kSha1DigestSize]; 80 uint32_t file_size_; // size of entire file 81 uint32_t header_size_; // offset to start of next section 82 uint32_t endian_tag_; 83 uint32_t link_size_; // unused 84 uint32_t link_off_; // unused 85 uint32_t map_off_; // unused 86 uint32_t string_ids_size_; // number of StringIds 87 uint32_t string_ids_off_; // file offset of StringIds array 88 uint32_t type_ids_size_; // number of TypeIds, we don't support more than 65535 89 uint32_t type_ids_off_; // file offset of TypeIds array 90 uint32_t proto_ids_size_; // number of ProtoIds, we don't support more than 65535 91 uint32_t proto_ids_off_; // file offset of ProtoIds array 92 uint32_t field_ids_size_; // number of FieldIds 93 uint32_t field_ids_off_; // file offset of FieldIds array 94 uint32_t method_ids_size_; // number of MethodIds 95 uint32_t method_ids_off_; // file offset of MethodIds array 96 uint32_t class_defs_size_; // number of ClassDefs 97 uint32_t class_defs_off_; // file offset of ClassDef array 98 uint32_t data_size_; // unused 99 uint32_t data_off_; // unused 100 101 private: 102 DISALLOW_COPY_AND_ASSIGN(Header); 103 }; 104 105 // Map item type codes. 106 enum { 107 kDexTypeHeaderItem = 0x0000, 108 kDexTypeStringIdItem = 0x0001, 109 kDexTypeTypeIdItem = 0x0002, 110 kDexTypeProtoIdItem = 0x0003, 111 kDexTypeFieldIdItem = 0x0004, 112 kDexTypeMethodIdItem = 0x0005, 113 kDexTypeClassDefItem = 0x0006, 114 kDexTypeMapList = 0x1000, 115 kDexTypeTypeList = 0x1001, 116 kDexTypeAnnotationSetRefList = 0x1002, 117 kDexTypeAnnotationSetItem = 0x1003, 118 kDexTypeClassDataItem = 0x2000, 119 kDexTypeCodeItem = 0x2001, 120 kDexTypeStringDataItem = 0x2002, 121 kDexTypeDebugInfoItem = 0x2003, 122 kDexTypeAnnotationItem = 0x2004, 123 kDexTypeEncodedArrayItem = 0x2005, 124 kDexTypeAnnotationsDirectoryItem = 0x2006, 125 }; 126 127 struct MapItem { 128 uint16_t type_; 129 uint16_t unused_; 130 uint32_t size_; 131 uint32_t offset_; 132 133 private: 134 DISALLOW_COPY_AND_ASSIGN(MapItem); 135 }; 136 137 struct MapList { 138 uint32_t size_; 139 MapItem list_[1]; 140 141 private: 142 DISALLOW_COPY_AND_ASSIGN(MapList); 143 }; 144 145 // Raw string_id_item. 146 struct StringId { 147 uint32_t string_data_off_; // offset in bytes from the base address 148 149 private: 150 DISALLOW_COPY_AND_ASSIGN(StringId); 151 }; 152 153 // Raw type_id_item. 154 struct TypeId { 155 uint32_t descriptor_idx_; // index into string_ids 156 157 private: 158 DISALLOW_COPY_AND_ASSIGN(TypeId); 159 }; 160 161 // Raw field_id_item. 162 struct FieldId { 163 uint16_t class_idx_; // index into type_ids_ array for defining class 164 uint16_t type_idx_; // index into type_ids_ array for field type 165 uint32_t name_idx_; // index into string_ids_ array for field name 166 167 private: 168 DISALLOW_COPY_AND_ASSIGN(FieldId); 169 }; 170 171 // Raw method_id_item. 172 struct MethodId { 173 uint16_t class_idx_; // index into type_ids_ array for defining class 174 uint16_t proto_idx_; // index into proto_ids_ array for method prototype 175 uint32_t name_idx_; // index into string_ids_ array for method name 176 177 private: 178 DISALLOW_COPY_AND_ASSIGN(MethodId); 179 }; 180 181 // Raw proto_id_item. 182 struct ProtoId { 183 uint32_t shorty_idx_; // index into string_ids array for shorty descriptor 184 uint16_t return_type_idx_; // index into type_ids array for return type 185 uint16_t pad_; // padding = 0 186 uint32_t parameters_off_; // file offset to type_list for parameter types 187 188 private: 189 DISALLOW_COPY_AND_ASSIGN(ProtoId); 190 }; 191 192 // Raw class_def_item. 193 struct ClassDef { 194 uint16_t class_idx_; // index into type_ids_ array for this class 195 uint16_t pad1_; // padding = 0 196 uint32_t access_flags_; 197 uint16_t superclass_idx_; // index into type_ids_ array for superclass 198 uint16_t pad2_; // padding = 0 199 uint32_t interfaces_off_; // file offset to TypeList 200 uint32_t source_file_idx_; // index into string_ids_ for source file name 201 uint32_t annotations_off_; // file offset to annotations_directory_item 202 uint32_t class_data_off_; // file offset to class_data_item 203 uint32_t static_values_off_; // file offset to EncodedArray 204 205 // Returns the valid access flags, that is, Java modifier bits relevant to the ClassDef type 206 // (class or interface). These are all in the lower 16b and do not contain runtime flags. 207 uint32_t GetJavaAccessFlags() const { 208 // Make sure that none of our runtime-only flags are set. 209 COMPILE_ASSERT((kAccValidClassFlags & kAccJavaFlagsMask) == kAccValidClassFlags, 210 valid_class_flags_not_subset_of_java_flags); 211 COMPILE_ASSERT((kAccValidInterfaceFlags & kAccJavaFlagsMask) == kAccValidInterfaceFlags, 212 valid_interface_flags_not_subset_of_java_flags); 213 214 if ((access_flags_ & kAccInterface) != 0) { 215 // Interface. 216 return access_flags_ & kAccValidInterfaceFlags; 217 } else { 218 // Class. 219 return access_flags_ & kAccValidClassFlags; 220 } 221 } 222 223 private: 224 DISALLOW_COPY_AND_ASSIGN(ClassDef); 225 }; 226 227 // Raw type_item. 228 struct TypeItem { 229 uint16_t type_idx_; // index into type_ids section 230 231 private: 232 DISALLOW_COPY_AND_ASSIGN(TypeItem); 233 }; 234 235 // Raw type_list. 236 class TypeList { 237 public: 238 uint32_t Size() const { 239 return size_; 240 } 241 242 const TypeItem& GetTypeItem(uint32_t idx) const { 243 DCHECK_LT(idx, this->size_); 244 return this->list_[idx]; 245 } 246 247 // Size in bytes of the part of the list that is common. 248 static constexpr size_t GetHeaderSize() { 249 return 4U; 250 } 251 252 // Size in bytes of the whole type list including all the stored elements. 253 static constexpr size_t GetListSize(size_t count) { 254 return GetHeaderSize() + sizeof(TypeItem) * count; 255 } 256 257 private: 258 uint32_t size_; // size of the list, in entries 259 TypeItem list_[1]; // elements of the list 260 DISALLOW_COPY_AND_ASSIGN(TypeList); 261 }; 262 263 // Raw code_item. 264 struct CodeItem { 265 uint16_t registers_size_; 266 uint16_t ins_size_; 267 uint16_t outs_size_; 268 uint16_t tries_size_; 269 uint32_t debug_info_off_; // file offset to debug info stream 270 uint32_t insns_size_in_code_units_; // size of the insns array, in 2 byte code units 271 uint16_t insns_[1]; 272 273 private: 274 DISALLOW_COPY_AND_ASSIGN(CodeItem); 275 }; 276 277 // Raw try_item. 278 struct TryItem { 279 uint32_t start_addr_; 280 uint16_t insn_count_; 281 uint16_t handler_off_; 282 283 private: 284 DISALLOW_COPY_AND_ASSIGN(TryItem); 285 }; 286 287 // Annotation constants. 288 enum { 289 kDexVisibilityBuild = 0x00, /* annotation visibility */ 290 kDexVisibilityRuntime = 0x01, 291 kDexVisibilitySystem = 0x02, 292 293 kDexAnnotationByte = 0x00, 294 kDexAnnotationShort = 0x02, 295 kDexAnnotationChar = 0x03, 296 kDexAnnotationInt = 0x04, 297 kDexAnnotationLong = 0x06, 298 kDexAnnotationFloat = 0x10, 299 kDexAnnotationDouble = 0x11, 300 kDexAnnotationString = 0x17, 301 kDexAnnotationType = 0x18, 302 kDexAnnotationField = 0x19, 303 kDexAnnotationMethod = 0x1a, 304 kDexAnnotationEnum = 0x1b, 305 kDexAnnotationArray = 0x1c, 306 kDexAnnotationAnnotation = 0x1d, 307 kDexAnnotationNull = 0x1e, 308 kDexAnnotationBoolean = 0x1f, 309 310 kDexAnnotationValueTypeMask = 0x1f, /* low 5 bits */ 311 kDexAnnotationValueArgShift = 5, 312 }; 313 314 struct AnnotationsDirectoryItem { 315 uint32_t class_annotations_off_; 316 uint32_t fields_size_; 317 uint32_t methods_size_; 318 uint32_t parameters_size_; 319 320 private: 321 DISALLOW_COPY_AND_ASSIGN(AnnotationsDirectoryItem); 322 }; 323 324 struct FieldAnnotationsItem { 325 uint32_t field_idx_; 326 uint32_t annotations_off_; 327 328 private: 329 DISALLOW_COPY_AND_ASSIGN(FieldAnnotationsItem); 330 }; 331 332 struct MethodAnnotationsItem { 333 uint32_t method_idx_; 334 uint32_t annotations_off_; 335 336 private: 337 DISALLOW_COPY_AND_ASSIGN(MethodAnnotationsItem); 338 }; 339 340 struct ParameterAnnotationsItem { 341 uint32_t method_idx_; 342 uint32_t annotations_off_; 343 344 private: 345 DISALLOW_COPY_AND_ASSIGN(ParameterAnnotationsItem); 346 }; 347 348 struct AnnotationSetRefItem { 349 uint32_t annotations_off_; 350 351 private: 352 DISALLOW_COPY_AND_ASSIGN(AnnotationSetRefItem); 353 }; 354 355 struct AnnotationSetRefList { 356 uint32_t size_; 357 AnnotationSetRefItem list_[1]; 358 359 private: 360 DISALLOW_COPY_AND_ASSIGN(AnnotationSetRefList); 361 }; 362 363 struct AnnotationSetItem { 364 uint32_t size_; 365 uint32_t entries_[1]; 366 367 private: 368 DISALLOW_COPY_AND_ASSIGN(AnnotationSetItem); 369 }; 370 371 struct AnnotationItem { 372 uint8_t visibility_; 373 uint8_t annotation_[1]; 374 375 private: 376 DISALLOW_COPY_AND_ASSIGN(AnnotationItem); 377 }; 378 379 // Returns the checksum of a file for comparison with GetLocationChecksum(). 380 // For .dex files, this is the header checksum. 381 // For zip files, this is the classes.dex zip entry CRC32 checksum. 382 // Return true if the checksum could be found, false otherwise. 383 static bool GetChecksum(const char* filename, uint32_t* checksum, std::string* error_msg); 384 385 // Opens .dex files found in the container, guessing the container format based on file extension. 386 static bool Open(const char* filename, const char* location, std::string* error_msg, 387 std::vector<const DexFile*>* dex_files); 388 389 // Opens .dex file, backed by existing memory 390 static const DexFile* Open(const uint8_t* base, size_t size, 391 const std::string& location, 392 uint32_t location_checksum, 393 std::string* error_msg) { 394 return OpenMemory(base, size, location, location_checksum, NULL, error_msg); 395 } 396 397 // Open all classesXXX.dex files from a zip archive. 398 static bool OpenFromZip(const ZipArchive& zip_archive, const std::string& location, 399 std::string* error_msg, std::vector<const DexFile*>* dex_files); 400 401 // Closes a .dex file. 402 virtual ~DexFile(); 403 404 const std::string& GetLocation() const { 405 return location_; 406 } 407 408 // For normal dex files, location and base location coincide. If a dex file is part of a multidex 409 // archive, the base location is the name of the originating jar/apk, stripped of any internal 410 // classes*.dex path. 411 static std::string GetBaseLocation(const char* location) { 412 const char* pos = strrchr(location, kMultiDexSeparator); 413 if (pos == nullptr) { 414 return location; 415 } else { 416 return std::string(location, pos - location); 417 } 418 } 419 420 std::string GetBaseLocation() const { 421 size_t pos = location_.rfind(kMultiDexSeparator); 422 if (pos == std::string::npos) { 423 return location_; 424 } else { 425 return location_.substr(0, pos); 426 } 427 } 428 429 // For DexFiles directly from .dex files, this is the checksum from the DexFile::Header. 430 // For DexFiles opened from a zip files, this will be the ZipEntry CRC32 of classes.dex. 431 uint32_t GetLocationChecksum() const { 432 return location_checksum_; 433 } 434 435 const Header& GetHeader() const { 436 DCHECK(header_ != NULL) << GetLocation(); 437 return *header_; 438 } 439 440 // Decode the dex magic version 441 uint32_t GetVersion() const; 442 443 // Returns true if the byte string points to the magic value. 444 static bool IsMagicValid(const uint8_t* magic); 445 446 // Returns true if the byte string after the magic is the correct value. 447 static bool IsVersionValid(const uint8_t* magic); 448 449 // Returns the number of string identifiers in the .dex file. 450 size_t NumStringIds() const { 451 DCHECK(header_ != NULL) << GetLocation(); 452 return header_->string_ids_size_; 453 } 454 455 // Returns the StringId at the specified index. 456 const StringId& GetStringId(uint32_t idx) const { 457 DCHECK_LT(idx, NumStringIds()) << GetLocation(); 458 return string_ids_[idx]; 459 } 460 461 uint32_t GetIndexForStringId(const StringId& string_id) const { 462 CHECK_GE(&string_id, string_ids_) << GetLocation(); 463 CHECK_LT(&string_id, string_ids_ + header_->string_ids_size_) << GetLocation(); 464 return &string_id - string_ids_; 465 } 466 467 int32_t GetStringLength(const StringId& string_id) const; 468 469 // Returns a pointer to the UTF-8 string data referred to by the given string_id as well as the 470 // length of the string when decoded as a UTF-16 string. Note the UTF-16 length is not the same 471 // as the string length of the string data. 472 const char* GetStringDataAndUtf16Length(const StringId& string_id, uint32_t* utf16_length) const; 473 474 const char* GetStringData(const StringId& string_id) const { 475 uint32_t ignored; 476 return GetStringDataAndUtf16Length(string_id, &ignored); 477 } 478 479 // Index version of GetStringDataAndUtf16Length. 480 const char* StringDataAndUtf16LengthByIdx(uint32_t idx, uint32_t* utf16_length) const { 481 if (idx == kDexNoIndex) { 482 *utf16_length = 0; 483 return NULL; 484 } 485 const StringId& string_id = GetStringId(idx); 486 return GetStringDataAndUtf16Length(string_id, utf16_length); 487 } 488 489 const char* StringDataByIdx(uint32_t idx) const { 490 uint32_t unicode_length; 491 return StringDataAndUtf16LengthByIdx(idx, &unicode_length); 492 } 493 494 // Looks up a string id for a given modified utf8 string. 495 const StringId* FindStringId(const char* string) const; 496 497 // Looks up a string id for a given utf16 string. 498 const StringId* FindStringId(const uint16_t* string) const; 499 500 // Returns the number of type identifiers in the .dex file. 501 uint32_t NumTypeIds() const { 502 DCHECK(header_ != NULL) << GetLocation(); 503 return header_->type_ids_size_; 504 } 505 506 // Returns the TypeId at the specified index. 507 const TypeId& GetTypeId(uint32_t idx) const { 508 DCHECK_LT(idx, NumTypeIds()) << GetLocation(); 509 return type_ids_[idx]; 510 } 511 512 uint16_t GetIndexForTypeId(const TypeId& type_id) const { 513 CHECK_GE(&type_id, type_ids_) << GetLocation(); 514 CHECK_LT(&type_id, type_ids_ + header_->type_ids_size_) << GetLocation(); 515 size_t result = &type_id - type_ids_; 516 DCHECK_LT(result, 65536U) << GetLocation(); 517 return static_cast<uint16_t>(result); 518 } 519 520 // Get the descriptor string associated with a given type index. 521 const char* StringByTypeIdx(uint32_t idx, uint32_t* unicode_length) const { 522 const TypeId& type_id = GetTypeId(idx); 523 return StringDataAndUtf16LengthByIdx(type_id.descriptor_idx_, unicode_length); 524 } 525 526 const char* StringByTypeIdx(uint32_t idx) const { 527 const TypeId& type_id = GetTypeId(idx); 528 return StringDataByIdx(type_id.descriptor_idx_); 529 } 530 531 // Returns the type descriptor string of a type id. 532 const char* GetTypeDescriptor(const TypeId& type_id) const { 533 return StringDataByIdx(type_id.descriptor_idx_); 534 } 535 536 // Looks up a type for the given string index 537 const TypeId* FindTypeId(uint32_t string_idx) const; 538 539 // Returns the number of field identifiers in the .dex file. 540 size_t NumFieldIds() const { 541 DCHECK(header_ != NULL) << GetLocation(); 542 return header_->field_ids_size_; 543 } 544 545 // Returns the FieldId at the specified index. 546 const FieldId& GetFieldId(uint32_t idx) const { 547 DCHECK_LT(idx, NumFieldIds()) << GetLocation(); 548 return field_ids_[idx]; 549 } 550 551 uint32_t GetIndexForFieldId(const FieldId& field_id) const { 552 CHECK_GE(&field_id, field_ids_) << GetLocation(); 553 CHECK_LT(&field_id, field_ids_ + header_->field_ids_size_) << GetLocation(); 554 return &field_id - field_ids_; 555 } 556 557 // Looks up a field by its declaring class, name and type 558 const FieldId* FindFieldId(const DexFile::TypeId& declaring_klass, 559 const DexFile::StringId& name, 560 const DexFile::TypeId& type) const; 561 562 // Returns the declaring class descriptor string of a field id. 563 const char* GetFieldDeclaringClassDescriptor(const FieldId& field_id) const { 564 const DexFile::TypeId& type_id = GetTypeId(field_id.class_idx_); 565 return GetTypeDescriptor(type_id); 566 } 567 568 // Returns the class descriptor string of a field id. 569 const char* GetFieldTypeDescriptor(const FieldId& field_id) const { 570 const DexFile::TypeId& type_id = GetTypeId(field_id.type_idx_); 571 return GetTypeDescriptor(type_id); 572 } 573 574 // Returns the name of a field id. 575 const char* GetFieldName(const FieldId& field_id) const { 576 return StringDataByIdx(field_id.name_idx_); 577 } 578 579 // Returns the number of method identifiers in the .dex file. 580 size_t NumMethodIds() const { 581 DCHECK(header_ != NULL) << GetLocation(); 582 return header_->method_ids_size_; 583 } 584 585 // Returns the MethodId at the specified index. 586 const MethodId& GetMethodId(uint32_t idx) const { 587 DCHECK_LT(idx, NumMethodIds()) << GetLocation(); 588 return method_ids_[idx]; 589 } 590 591 uint32_t GetIndexForMethodId(const MethodId& method_id) const { 592 CHECK_GE(&method_id, method_ids_) << GetLocation(); 593 CHECK_LT(&method_id, method_ids_ + header_->method_ids_size_) << GetLocation(); 594 return &method_id - method_ids_; 595 } 596 597 // Looks up a method by its declaring class, name and proto_id 598 const MethodId* FindMethodId(const DexFile::TypeId& declaring_klass, 599 const DexFile::StringId& name, 600 const DexFile::ProtoId& signature) const; 601 602 // Returns the declaring class descriptor string of a method id. 603 const char* GetMethodDeclaringClassDescriptor(const MethodId& method_id) const { 604 const DexFile::TypeId& type_id = GetTypeId(method_id.class_idx_); 605 return GetTypeDescriptor(type_id); 606 } 607 608 // Returns the prototype of a method id. 609 const ProtoId& GetMethodPrototype(const MethodId& method_id) const { 610 return GetProtoId(method_id.proto_idx_); 611 } 612 613 // Returns a representation of the signature of a method id. 614 const Signature GetMethodSignature(const MethodId& method_id) const; 615 616 // Returns the name of a method id. 617 const char* GetMethodName(const MethodId& method_id) const { 618 return StringDataByIdx(method_id.name_idx_); 619 } 620 621 // Returns the shorty of a method id. 622 const char* GetMethodShorty(const MethodId& method_id) const { 623 return StringDataByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_); 624 } 625 const char* GetMethodShorty(const MethodId& method_id, uint32_t* length) const { 626 // Using the UTF16 length is safe here as shorties are guaranteed to be ASCII characters. 627 return StringDataAndUtf16LengthByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_, length); 628 } 629 // Returns the number of class definitions in the .dex file. 630 uint32_t NumClassDefs() const { 631 DCHECK(header_ != NULL) << GetLocation(); 632 return header_->class_defs_size_; 633 } 634 635 // Returns the ClassDef at the specified index. 636 const ClassDef& GetClassDef(uint16_t idx) const { 637 DCHECK_LT(idx, NumClassDefs()) << GetLocation(); 638 return class_defs_[idx]; 639 } 640 641 uint16_t GetIndexForClassDef(const ClassDef& class_def) const { 642 CHECK_GE(&class_def, class_defs_) << GetLocation(); 643 CHECK_LT(&class_def, class_defs_ + header_->class_defs_size_) << GetLocation(); 644 return &class_def - class_defs_; 645 } 646 647 // Returns the class descriptor string of a class definition. 648 const char* GetClassDescriptor(const ClassDef& class_def) const { 649 return StringByTypeIdx(class_def.class_idx_); 650 } 651 652 // Looks up a class definition by its class descriptor. 653 const ClassDef* FindClassDef(const char* descriptor) const; 654 655 // Looks up a class definition by its type index. 656 const ClassDef* FindClassDef(uint16_t type_idx) const; 657 658 const TypeList* GetInterfacesList(const ClassDef& class_def) const { 659 if (class_def.interfaces_off_ == 0) { 660 return NULL; 661 } else { 662 const uint8_t* addr = begin_ + class_def.interfaces_off_; 663 return reinterpret_cast<const TypeList*>(addr); 664 } 665 } 666 667 // Returns a pointer to the raw memory mapped class_data_item 668 const uint8_t* GetClassData(const ClassDef& class_def) const { 669 if (class_def.class_data_off_ == 0) { 670 return NULL; 671 } else { 672 return begin_ + class_def.class_data_off_; 673 } 674 } 675 676 // 677 const CodeItem* GetCodeItem(const uint32_t code_off) const { 678 if (code_off == 0) { 679 return NULL; // native or abstract method 680 } else { 681 const uint8_t* addr = begin_ + code_off; 682 return reinterpret_cast<const CodeItem*>(addr); 683 } 684 } 685 686 const char* GetReturnTypeDescriptor(const ProtoId& proto_id) const { 687 return StringByTypeIdx(proto_id.return_type_idx_); 688 } 689 690 // Returns the number of prototype identifiers in the .dex file. 691 size_t NumProtoIds() const { 692 DCHECK(header_ != NULL) << GetLocation(); 693 return header_->proto_ids_size_; 694 } 695 696 // Returns the ProtoId at the specified index. 697 const ProtoId& GetProtoId(uint32_t idx) const { 698 DCHECK_LT(idx, NumProtoIds()) << GetLocation(); 699 return proto_ids_[idx]; 700 } 701 702 uint16_t GetIndexForProtoId(const ProtoId& proto_id) const { 703 CHECK_GE(&proto_id, proto_ids_) << GetLocation(); 704 CHECK_LT(&proto_id, proto_ids_ + header_->proto_ids_size_) << GetLocation(); 705 return &proto_id - proto_ids_; 706 } 707 708 // Looks up a proto id for a given return type and signature type list 709 const ProtoId* FindProtoId(uint16_t return_type_idx, 710 const uint16_t* signature_type_idxs, uint32_t signature_length) const; 711 const ProtoId* FindProtoId(uint16_t return_type_idx, 712 const std::vector<uint16_t>& signature_type_idxs) const { 713 return FindProtoId(return_type_idx, &signature_type_idxs[0], signature_type_idxs.size()); 714 } 715 716 // Given a signature place the type ids into the given vector, returns true on success 717 bool CreateTypeList(const StringPiece& signature, uint16_t* return_type_idx, 718 std::vector<uint16_t>* param_type_idxs) const; 719 720 // Create a Signature from the given string signature or return Signature::NoSignature if not 721 // possible. 722 const Signature CreateSignature(const StringPiece& signature) const; 723 724 // Returns the short form method descriptor for the given prototype. 725 const char* GetShorty(uint32_t proto_idx) const { 726 const ProtoId& proto_id = GetProtoId(proto_idx); 727 return StringDataByIdx(proto_id.shorty_idx_); 728 } 729 730 const TypeList* GetProtoParameters(const ProtoId& proto_id) const { 731 if (proto_id.parameters_off_ == 0) { 732 return NULL; 733 } else { 734 const uint8_t* addr = begin_ + proto_id.parameters_off_; 735 return reinterpret_cast<const TypeList*>(addr); 736 } 737 } 738 739 const uint8_t* GetEncodedStaticFieldValuesArray(const ClassDef& class_def) const { 740 if (class_def.static_values_off_ == 0) { 741 return 0; 742 } else { 743 return begin_ + class_def.static_values_off_; 744 } 745 } 746 747 static const TryItem* GetTryItems(const CodeItem& code_item, uint32_t offset); 748 749 // Get the base of the encoded data for the given DexCode. 750 static const uint8_t* GetCatchHandlerData(const CodeItem& code_item, uint32_t offset) { 751 const uint8_t* handler_data = 752 reinterpret_cast<const uint8_t*>(GetTryItems(code_item, code_item.tries_size_)); 753 return handler_data + offset; 754 } 755 756 // Find which try region is associated with the given address (ie dex pc). Returns -1 if none. 757 static int32_t FindTryItem(const CodeItem &code_item, uint32_t address); 758 759 // Find the handler offset associated with the given address (ie dex pc). Returns -1 if none. 760 static int32_t FindCatchHandlerOffset(const CodeItem &code_item, uint32_t address); 761 762 // Get the pointer to the start of the debugging data 763 const uint8_t* GetDebugInfoStream(const CodeItem* code_item) const { 764 if (code_item->debug_info_off_ == 0) { 765 return NULL; 766 } else { 767 return begin_ + code_item->debug_info_off_; 768 } 769 } 770 771 // Callback for "new position table entry". 772 // Returning true causes the decoder to stop early. 773 typedef bool (*DexDebugNewPositionCb)(void* context, uint32_t address, uint32_t line_num); 774 775 // Callback for "new locals table entry". "signature" is an empty string 776 // if no signature is available for an entry. 777 typedef void (*DexDebugNewLocalCb)(void* context, uint16_t reg, 778 uint32_t start_address, 779 uint32_t end_address, 780 const char* name, 781 const char* descriptor, 782 const char* signature); 783 784 static bool LineNumForPcCb(void* context, uint32_t address, uint32_t line_num); 785 786 // Debug info opcodes and constants 787 enum { 788 DBG_END_SEQUENCE = 0x00, 789 DBG_ADVANCE_PC = 0x01, 790 DBG_ADVANCE_LINE = 0x02, 791 DBG_START_LOCAL = 0x03, 792 DBG_START_LOCAL_EXTENDED = 0x04, 793 DBG_END_LOCAL = 0x05, 794 DBG_RESTART_LOCAL = 0x06, 795 DBG_SET_PROLOGUE_END = 0x07, 796 DBG_SET_EPILOGUE_BEGIN = 0x08, 797 DBG_SET_FILE = 0x09, 798 DBG_FIRST_SPECIAL = 0x0a, 799 DBG_LINE_BASE = -4, 800 DBG_LINE_RANGE = 15, 801 }; 802 803 struct LocalInfo { 804 LocalInfo() 805 : name_(NULL), descriptor_(NULL), signature_(NULL), start_address_(0), is_live_(false) {} 806 807 const char* name_; // E.g., list 808 const char* descriptor_; // E.g., Ljava/util/LinkedList; 809 const char* signature_; // E.g., java.util.LinkedList<java.lang.Integer> 810 uint16_t start_address_; // PC location where the local is first defined. 811 bool is_live_; // Is the local defined and live. 812 813 private: 814 DISALLOW_COPY_AND_ASSIGN(LocalInfo); 815 }; 816 817 struct LineNumFromPcContext { 818 LineNumFromPcContext(uint32_t address, uint32_t line_num) 819 : address_(address), line_num_(line_num) {} 820 uint32_t address_; 821 uint32_t line_num_; 822 private: 823 DISALLOW_COPY_AND_ASSIGN(LineNumFromPcContext); 824 }; 825 826 void InvokeLocalCbIfLive(void* context, int reg, uint32_t end_address, 827 LocalInfo* local_in_reg, DexDebugNewLocalCb local_cb) const { 828 if (local_cb != NULL && local_in_reg[reg].is_live_) { 829 local_cb(context, reg, local_in_reg[reg].start_address_, end_address, 830 local_in_reg[reg].name_, local_in_reg[reg].descriptor_, 831 local_in_reg[reg].signature_ != NULL ? local_in_reg[reg].signature_ : ""); 832 } 833 } 834 835 // Determine the source file line number based on the program counter. 836 // "pc" is an offset, in 16-bit units, from the start of the method's code. 837 // 838 // Returns -1 if no match was found (possibly because the source files were 839 // compiled without "-g", so no line number information is present). 840 // Returns -2 for native methods (as expected in exception traces). 841 // 842 // This is used by runtime; therefore use art::Method not art::DexFile::Method. 843 int32_t GetLineNumFromPC(mirror::ArtMethod* method, uint32_t rel_pc) const 844 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 845 846 void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx, 847 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb, 848 void* context) const; 849 850 const char* GetSourceFile(const ClassDef& class_def) const { 851 if (class_def.source_file_idx_ == 0xffffffff) { 852 return NULL; 853 } else { 854 return StringDataByIdx(class_def.source_file_idx_); 855 } 856 } 857 858 int GetPermissions() const; 859 860 bool IsReadOnly() const; 861 862 bool EnableWrite() const; 863 864 bool DisableWrite() const; 865 866 const uint8_t* Begin() const { 867 return begin_; 868 } 869 870 size_t Size() const { 871 return size_; 872 } 873 874 static std::string GetMultiDexClassesDexName(size_t number, const char* dex_location); 875 876 // Returns the canonical form of the given dex location. 877 // 878 // There are different flavors of "dex locations" as follows: 879 // the file name of a dex file: 880 // The actual file path that the dex file has on disk. 881 // dex_location: 882 // This acts as a key for the class linker to know which dex file to load. 883 // It may correspond to either an old odex file or a particular dex file 884 // inside an oat file. In the first case it will also match the file name 885 // of the dex file. In the second case (oat) it will include the file name 886 // and possibly some multidex annotation to uniquely identify it. 887 // canonical_dex_location: 888 // the dex_location where it's file name part has been made canonical. 889 static std::string GetDexCanonicalLocation(const char* dex_location); 890 891 private: 892 // Opens a .dex file 893 static const DexFile* OpenFile(int fd, const char* location, bool verify, std::string* error_msg); 894 895 // Opens dex files from within a .jar, .zip, or .apk file 896 static bool OpenZip(int fd, const std::string& location, std::string* error_msg, 897 std::vector<const DexFile*>* dex_files); 898 899 enum class ZipOpenErrorCode { // private 900 kNoError, 901 kEntryNotFound, 902 kExtractToMemoryError, 903 kDexFileError, 904 kMakeReadOnlyError, 905 kVerifyError 906 }; 907 908 // Opens .dex file from the entry_name in a zip archive. error_code is undefined when non-nullptr 909 // return. 910 static const DexFile* Open(const ZipArchive& zip_archive, const char* entry_name, 911 const std::string& location, std::string* error_msg, 912 ZipOpenErrorCode* error_code); 913 914 // Opens a .dex file at the given address backed by a MemMap 915 static const DexFile* OpenMemory(const std::string& location, 916 uint32_t location_checksum, 917 MemMap* mem_map, 918 std::string* error_msg); 919 920 // Opens a .dex file at the given address, optionally backed by a MemMap 921 static const DexFile* OpenMemory(const uint8_t* dex_file, 922 size_t size, 923 const std::string& location, 924 uint32_t location_checksum, 925 MemMap* mem_map, 926 std::string* error_msg); 927 928 DexFile(const uint8_t* base, size_t size, 929 const std::string& location, 930 uint32_t location_checksum, 931 MemMap* mem_map); 932 933 // Top-level initializer that calls other Init methods. 934 bool Init(std::string* error_msg); 935 936 // Returns true if the header magic and version numbers are of the expected values. 937 bool CheckMagicAndVersion(std::string* error_msg) const; 938 939 void DecodeDebugInfo0(const CodeItem* code_item, bool is_static, uint32_t method_idx, 940 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb, 941 void* context, const uint8_t* stream, LocalInfo* local_in_reg) const; 942 943 // Check whether a location denotes a multidex dex file. This is a very simple check: returns 944 // whether the string contains the separator character. 945 static bool IsMultiDexLocation(const char* location); 946 947 948 // The base address of the memory mapping. 949 const uint8_t* const begin_; 950 951 // The size of the underlying memory allocation in bytes. 952 const size_t size_; 953 954 // Typically the dex file name when available, alternatively some identifying string. 955 // 956 // The ClassLinker will use this to match DexFiles the boot class 957 // path to DexCache::GetLocation when loading from an image. 958 const std::string location_; 959 960 const uint32_t location_checksum_; 961 962 // Manages the underlying memory allocation. 963 std::unique_ptr<MemMap> mem_map_; 964 965 // Points to the header section. 966 const Header* const header_; 967 968 // Points to the base of the string identifier list. 969 const StringId* const string_ids_; 970 971 // Points to the base of the type identifier list. 972 const TypeId* const type_ids_; 973 974 // Points to the base of the field identifier list. 975 const FieldId* const field_ids_; 976 977 // Points to the base of the method identifier list. 978 const MethodId* const method_ids_; 979 980 // Points to the base of the prototype identifier list. 981 const ProtoId* const proto_ids_; 982 983 // Points to the base of the class definition list. 984 const ClassDef* const class_defs_; 985 986 // Number of misses finding a class def from a descriptor. 987 mutable Atomic<uint32_t> find_class_def_misses_; 988 989 struct UTF16HashCmp { 990 // Hash function. 991 size_t operator()(const char* key) const { 992 return ComputeUtf8Hash(key); 993 } 994 // std::equal function. 995 bool operator()(const char* a, const char* b) const { 996 return CompareModifiedUtf8ToModifiedUtf8AsUtf16CodePointValues(a, b) == 0; 997 } 998 }; 999 typedef std::unordered_map<const char*, const ClassDef*, UTF16HashCmp, UTF16HashCmp> Index; 1000 mutable Atomic<Index*> class_def_index_; 1001}; 1002std::ostream& operator<<(std::ostream& os, const DexFile& dex_file); 1003 1004// Iterate over a dex file's ProtoId's paramters 1005class DexFileParameterIterator { 1006 public: 1007 DexFileParameterIterator(const DexFile& dex_file, const DexFile::ProtoId& proto_id) 1008 : dex_file_(dex_file), size_(0), pos_(0) { 1009 type_list_ = dex_file_.GetProtoParameters(proto_id); 1010 if (type_list_ != NULL) { 1011 size_ = type_list_->Size(); 1012 } 1013 } 1014 bool HasNext() const { return pos_ < size_; } 1015 void Next() { ++pos_; } 1016 uint16_t GetTypeIdx() { 1017 return type_list_->GetTypeItem(pos_).type_idx_; 1018 } 1019 const char* GetDescriptor() { 1020 return dex_file_.StringByTypeIdx(GetTypeIdx()); 1021 } 1022 private: 1023 const DexFile& dex_file_; 1024 const DexFile::TypeList* type_list_; 1025 uint32_t size_; 1026 uint32_t pos_; 1027 DISALLOW_IMPLICIT_CONSTRUCTORS(DexFileParameterIterator); 1028}; 1029 1030// Abstract the signature of a method. 1031class Signature : public ValueObject { 1032 public: 1033 std::string ToString() const; 1034 1035 static Signature NoSignature() { 1036 return Signature(); 1037 } 1038 1039 bool operator==(const Signature& rhs) const; 1040 bool operator!=(const Signature& rhs) const { 1041 return !(*this == rhs); 1042 } 1043 1044 bool operator==(const StringPiece& rhs) const; 1045 1046 private: 1047 Signature(const DexFile* dex, const DexFile::ProtoId& proto) : dex_file_(dex), proto_id_(&proto) { 1048 } 1049 1050 Signature() : dex_file_(nullptr), proto_id_(nullptr) { 1051 } 1052 1053 friend class DexFile; 1054 1055 const DexFile* const dex_file_; 1056 const DexFile::ProtoId* const proto_id_; 1057}; 1058std::ostream& operator<<(std::ostream& os, const Signature& sig); 1059 1060// Iterate and decode class_data_item 1061class ClassDataItemIterator { 1062 public: 1063 ClassDataItemIterator(const DexFile& dex_file, const uint8_t* raw_class_data_item) 1064 : dex_file_(dex_file), pos_(0), ptr_pos_(raw_class_data_item), last_idx_(0) { 1065 ReadClassDataHeader(); 1066 if (EndOfInstanceFieldsPos() > 0) { 1067 ReadClassDataField(); 1068 } else if (EndOfVirtualMethodsPos() > 0) { 1069 ReadClassDataMethod(); 1070 } 1071 } 1072 uint32_t NumStaticFields() const { 1073 return header_.static_fields_size_; 1074 } 1075 uint32_t NumInstanceFields() const { 1076 return header_.instance_fields_size_; 1077 } 1078 uint32_t NumDirectMethods() const { 1079 return header_.direct_methods_size_; 1080 } 1081 uint32_t NumVirtualMethods() const { 1082 return header_.virtual_methods_size_; 1083 } 1084 bool HasNextStaticField() const { 1085 return pos_ < EndOfStaticFieldsPos(); 1086 } 1087 bool HasNextInstanceField() const { 1088 return pos_ >= EndOfStaticFieldsPos() && pos_ < EndOfInstanceFieldsPos(); 1089 } 1090 bool HasNextDirectMethod() const { 1091 return pos_ >= EndOfInstanceFieldsPos() && pos_ < EndOfDirectMethodsPos(); 1092 } 1093 bool HasNextVirtualMethod() const { 1094 return pos_ >= EndOfDirectMethodsPos() && pos_ < EndOfVirtualMethodsPos(); 1095 } 1096 bool HasNext() const { 1097 return pos_ < EndOfVirtualMethodsPos(); 1098 } 1099 inline void Next() { 1100 pos_++; 1101 if (pos_ < EndOfStaticFieldsPos()) { 1102 last_idx_ = GetMemberIndex(); 1103 ReadClassDataField(); 1104 } else if (pos_ == EndOfStaticFieldsPos() && NumInstanceFields() > 0) { 1105 last_idx_ = 0; // transition to next array, reset last index 1106 ReadClassDataField(); 1107 } else if (pos_ < EndOfInstanceFieldsPos()) { 1108 last_idx_ = GetMemberIndex(); 1109 ReadClassDataField(); 1110 } else if (pos_ == EndOfInstanceFieldsPos() && NumDirectMethods() > 0) { 1111 last_idx_ = 0; // transition to next array, reset last index 1112 ReadClassDataMethod(); 1113 } else if (pos_ < EndOfDirectMethodsPos()) { 1114 last_idx_ = GetMemberIndex(); 1115 ReadClassDataMethod(); 1116 } else if (pos_ == EndOfDirectMethodsPos() && NumVirtualMethods() > 0) { 1117 last_idx_ = 0; // transition to next array, reset last index 1118 ReadClassDataMethod(); 1119 } else if (pos_ < EndOfVirtualMethodsPos()) { 1120 last_idx_ = GetMemberIndex(); 1121 ReadClassDataMethod(); 1122 } else { 1123 DCHECK(!HasNext()); 1124 } 1125 } 1126 uint32_t GetMemberIndex() const { 1127 if (pos_ < EndOfInstanceFieldsPos()) { 1128 return last_idx_ + field_.field_idx_delta_; 1129 } else { 1130 DCHECK_LT(pos_, EndOfVirtualMethodsPos()); 1131 return last_idx_ + method_.method_idx_delta_; 1132 } 1133 } 1134 uint32_t GetRawMemberAccessFlags() const { 1135 if (pos_ < EndOfInstanceFieldsPos()) { 1136 return field_.access_flags_; 1137 } else { 1138 DCHECK_LT(pos_, EndOfVirtualMethodsPos()); 1139 return method_.access_flags_; 1140 } 1141 } 1142 uint32_t GetFieldAccessFlags() const { 1143 return GetRawMemberAccessFlags() & kAccValidFieldFlags; 1144 } 1145 uint32_t GetMethodAccessFlags() const { 1146 return GetRawMemberAccessFlags() & kAccValidMethodFlags; 1147 } 1148 bool MemberIsNative() const { 1149 return GetRawMemberAccessFlags() & kAccNative; 1150 } 1151 bool MemberIsFinal() const { 1152 return GetRawMemberAccessFlags() & kAccFinal; 1153 } 1154 InvokeType GetMethodInvokeType(const DexFile::ClassDef& class_def) const { 1155 if (HasNextDirectMethod()) { 1156 if ((GetRawMemberAccessFlags() & kAccStatic) != 0) { 1157 return kStatic; 1158 } else { 1159 return kDirect; 1160 } 1161 } else { 1162 DCHECK_EQ(GetRawMemberAccessFlags() & kAccStatic, 0U); 1163 if ((class_def.access_flags_ & kAccInterface) != 0) { 1164 return kInterface; 1165 } else if ((GetRawMemberAccessFlags() & kAccConstructor) != 0) { 1166 return kSuper; 1167 } else { 1168 return kVirtual; 1169 } 1170 } 1171 } 1172 const DexFile::CodeItem* GetMethodCodeItem() const { 1173 return dex_file_.GetCodeItem(method_.code_off_); 1174 } 1175 uint32_t GetMethodCodeItemOffset() const { 1176 return method_.code_off_; 1177 } 1178 const uint8_t* EndDataPointer() const { 1179 CHECK(!HasNext()); 1180 return ptr_pos_; 1181 } 1182 1183 private: 1184 // A dex file's class_data_item is leb128 encoded, this structure holds a decoded form of the 1185 // header for a class_data_item 1186 struct ClassDataHeader { 1187 uint32_t static_fields_size_; // the number of static fields 1188 uint32_t instance_fields_size_; // the number of instance fields 1189 uint32_t direct_methods_size_; // the number of direct methods 1190 uint32_t virtual_methods_size_; // the number of virtual methods 1191 } header_; 1192 1193 // Read and decode header from a class_data_item stream into header 1194 void ReadClassDataHeader(); 1195 1196 uint32_t EndOfStaticFieldsPos() const { 1197 return header_.static_fields_size_; 1198 } 1199 uint32_t EndOfInstanceFieldsPos() const { 1200 return EndOfStaticFieldsPos() + header_.instance_fields_size_; 1201 } 1202 uint32_t EndOfDirectMethodsPos() const { 1203 return EndOfInstanceFieldsPos() + header_.direct_methods_size_; 1204 } 1205 uint32_t EndOfVirtualMethodsPos() const { 1206 return EndOfDirectMethodsPos() + header_.virtual_methods_size_; 1207 } 1208 1209 // A decoded version of the field of a class_data_item 1210 struct ClassDataField { 1211 uint32_t field_idx_delta_; // delta of index into the field_ids array for FieldId 1212 uint32_t access_flags_; // access flags for the field 1213 ClassDataField() : field_idx_delta_(0), access_flags_(0) {} 1214 1215 private: 1216 DISALLOW_COPY_AND_ASSIGN(ClassDataField); 1217 }; 1218 ClassDataField field_; 1219 1220 // Read and decode a field from a class_data_item stream into field 1221 void ReadClassDataField(); 1222 1223 // A decoded version of the method of a class_data_item 1224 struct ClassDataMethod { 1225 uint32_t method_idx_delta_; // delta of index into the method_ids array for MethodId 1226 uint32_t access_flags_; 1227 uint32_t code_off_; 1228 ClassDataMethod() : method_idx_delta_(0), access_flags_(0), code_off_(0) {} 1229 1230 private: 1231 DISALLOW_COPY_AND_ASSIGN(ClassDataMethod); 1232 }; 1233 ClassDataMethod method_; 1234 1235 // Read and decode a method from a class_data_item stream into method 1236 void ReadClassDataMethod(); 1237 1238 const DexFile& dex_file_; 1239 size_t pos_; // integral number of items passed 1240 const uint8_t* ptr_pos_; // pointer into stream of class_data_item 1241 uint32_t last_idx_; // last read field or method index to apply delta to 1242 DISALLOW_IMPLICIT_CONSTRUCTORS(ClassDataItemIterator); 1243}; 1244 1245class EncodedStaticFieldValueIterator { 1246 public: 1247 EncodedStaticFieldValueIterator(const DexFile& dex_file, Handle<mirror::DexCache>* dex_cache, 1248 Handle<mirror::ClassLoader>* class_loader, 1249 ClassLinker* linker, const DexFile::ClassDef& class_def) 1250 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1251 1252 template<bool kTransactionActive> 1253 void ReadValueToField(Handle<mirror::ArtField> field) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_); 1254 1255 bool HasNext() { return pos_ < array_size_; } 1256 1257 void Next(); 1258 1259 enum ValueType { 1260 kByte = 0x00, 1261 kShort = 0x02, 1262 kChar = 0x03, 1263 kInt = 0x04, 1264 kLong = 0x06, 1265 kFloat = 0x10, 1266 kDouble = 0x11, 1267 kString = 0x17, 1268 kType = 0x18, 1269 kField = 0x19, 1270 kMethod = 0x1a, 1271 kEnum = 0x1b, 1272 kArray = 0x1c, 1273 kAnnotation = 0x1d, 1274 kNull = 0x1e, 1275 kBoolean = 0x1f 1276 }; 1277 1278 private: 1279 static constexpr uint8_t kEncodedValueTypeMask = 0x1f; // 0b11111 1280 static constexpr uint8_t kEncodedValueArgShift = 5; 1281 1282 const DexFile& dex_file_; 1283 Handle<mirror::DexCache>* const dex_cache_; // Dex cache to resolve literal objects. 1284 Handle<mirror::ClassLoader>* const class_loader_; // ClassLoader to resolve types. 1285 ClassLinker* linker_; // Linker to resolve literal objects. 1286 size_t array_size_; // Size of array. 1287 size_t pos_; // Current position. 1288 const uint8_t* ptr_; // Pointer into encoded data array. 1289 ValueType type_; // Type of current encoded value. 1290 jvalue jval_; // Value of current encoded value. 1291 DISALLOW_IMPLICIT_CONSTRUCTORS(EncodedStaticFieldValueIterator); 1292}; 1293std::ostream& operator<<(std::ostream& os, const EncodedStaticFieldValueIterator::ValueType& code); 1294 1295class CatchHandlerIterator { 1296 public: 1297 CatchHandlerIterator(const DexFile::CodeItem& code_item, uint32_t address); 1298 1299 CatchHandlerIterator(const DexFile::CodeItem& code_item, 1300 const DexFile::TryItem& try_item); 1301 1302 explicit CatchHandlerIterator(const uint8_t* handler_data) { 1303 Init(handler_data); 1304 } 1305 1306 uint16_t GetHandlerTypeIndex() const { 1307 return handler_.type_idx_; 1308 } 1309 uint32_t GetHandlerAddress() const { 1310 return handler_.address_; 1311 } 1312 void Next(); 1313 bool HasNext() const { 1314 return remaining_count_ != -1 || catch_all_; 1315 } 1316 // End of this set of catch blocks, convenience method to locate next set of catch blocks 1317 const uint8_t* EndDataPointer() const { 1318 CHECK(!HasNext()); 1319 return current_data_; 1320 } 1321 1322 private: 1323 void Init(const DexFile::CodeItem& code_item, int32_t offset); 1324 void Init(const uint8_t* handler_data); 1325 1326 struct CatchHandlerItem { 1327 uint16_t type_idx_; // type index of the caught exception type 1328 uint32_t address_; // handler address 1329 } handler_; 1330 const uint8_t* current_data_; // the current handler in dex file. 1331 int32_t remaining_count_; // number of handlers not read. 1332 bool catch_all_; // is there a handler that will catch all exceptions in case 1333 // that all typed handler does not match. 1334}; 1335 1336} // namespace art 1337 1338#endif // ART_RUNTIME_DEX_FILE_H_ 1339