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