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