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