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