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