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