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