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