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