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