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