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