blob: 76947e5cee5ef8218cdaf08866a99fc145b43527 [file] [log] [blame]
Elliott Hughes2faa5f12012-01-30 14:42:07 -08001/*
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 */
Carl Shapiro1fb86202011-06-27 17:43:13 -070016
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_DEX_FILE_H_
18#define ART_RUNTIME_DEX_FILE_H_
Carl Shapiro1fb86202011-06-27 17:43:13 -070019
Elliott Hughes0c424cb2011-08-26 10:16:25 -070020#include <string>
Brian Carlstrom74eb46a2011-08-02 20:10:14 -070021#include <vector>
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070022
Elliott Hughes07ed66b2012-12-12 18:34:25 -080023#include "base/logging.h"
Sebastien Hertz2d6ba512013-05-17 11:31:37 +020024#include "base/mutex.h"
Elliott Hughese222ee02012-12-13 14:41:43 -080025#include "base/stringpiece.h"
Brian Carlstrom578bbdc2011-07-21 14:07:47 -070026#include "globals.h"
Ian Rogers08f753d2012-08-24 14:35:25 -070027#include "invoke_type.h"
Jesse Wilson6bf19152011-09-29 13:12:33 -040028#include "jni.h"
Brian Carlstrom33f741e2011-10-03 11:24:05 -070029#include "mem_map.h"
Ian Rogers08f753d2012-08-24 14:35:25 -070030#include "modifiers.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070031#include "safe_map.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070032#include "UniquePtr.h"
Carl Shapiro1fb86202011-06-27 17:43:13 -070033
34namespace art {
35
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080036namespace mirror {
37class AbstractMethod;
38class ClassLoader;
39class DexCache;
40class Field;
41} // namespace mirror
42class ClassLinker;
Brian Carlstroma6cc8932012-01-04 14:44:07 -080043class ZipArchive;
44
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070045// TODO: move all of the macro functionality into the DexCache class.
Brian Carlstromf615a612011-07-23 12:50:34 -070046class DexFile {
Carl Shapiro1fb86202011-06-27 17:43:13 -070047 public:
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070048 static const byte kDexMagic[];
49 static const byte kDexMagicVersion[];
50 static const size_t kSha1DigestSize = 20;
jeffhao10037c82012-01-23 15:06:23 -080051 static const uint32_t kDexEndianConstant = 0x12345678;
Carl Shapiro80d4dde2011-06-28 16:24:07 -070052
Brian Carlstromb7bbba42011-10-13 14:58:47 -070053 // name of the DexFile entry within a zip archive
54 static const char* kClassesDex;
55
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070056 // The value of an invalid index.
57 static const uint32_t kDexNoIndex = 0xFFFFFFFF;
58
Ian Rogers0571d352011-11-03 19:51:38 -070059 // The value of an invalid index.
60 static const uint16_t kDexNoIndex16 = 0xFFFF;
Carl Shapiro1fb86202011-06-27 17:43:13 -070061
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070062 // Raw header_item.
63 struct Header {
64 uint8_t magic_[8];
Brian Carlstrom7934ac22013-07-26 10:54:15 -070065 uint32_t checksum_; // See also location_checksum_
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070066 uint8_t signature_[kSha1DigestSize];
jeffhaof6174e82012-01-31 16:14:17 -080067 uint32_t file_size_; // size of entire file
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070068 uint32_t header_size_; // offset to start of next section
69 uint32_t endian_tag_;
Ian Rogers0571d352011-11-03 19:51:38 -070070 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
Elliott Hughesa21039c2012-06-21 12:09:25 -070087
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -070088 private:
89 DISALLOW_COPY_AND_ASSIGN(Header);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070090 };
Carl Shapiro1fb86202011-06-27 17:43:13 -070091
jeffhao10037c82012-01-23 15:06:23 -080092 // 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_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700119
jeffhao10037c82012-01-23 15:06:23 -0800120 private:
121 DISALLOW_COPY_AND_ASSIGN(MapItem);
122 };
123
124 struct MapList {
125 uint32_t size_;
126 MapItem list_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700127
jeffhao10037c82012-01-23 15:06:23 -0800128 private:
129 DISALLOW_COPY_AND_ASSIGN(MapList);
130 };
131
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700132 // Raw string_id_item.
133 struct StringId {
134 uint32_t string_data_off_; // offset in bytes from the base address
Elliott Hughesa21039c2012-06-21 12:09:25 -0700135
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700136 private:
137 DISALLOW_COPY_AND_ASSIGN(StringId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700138 };
139
140 // Raw type_id_item.
141 struct TypeId {
142 uint32_t descriptor_idx_; // index into string_ids
Elliott Hughesa21039c2012-06-21 12:09:25 -0700143
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700144 private:
145 DISALLOW_COPY_AND_ASSIGN(TypeId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700146 };
147
148 // Raw field_id_item.
149 struct FieldId {
Ian Rogers0571d352011-11-03 19:51:38 -0700150 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
Elliott Hughesa21039c2012-06-21 12:09:25 -0700153
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700154 private:
155 DISALLOW_COPY_AND_ASSIGN(FieldId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700156 };
157
158 // Raw method_id_item.
159 struct MethodId {
Ian Rogers0571d352011-11-03 19:51:38 -0700160 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
Elliott Hughesa21039c2012-06-21 12:09:25 -0700163
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700164 private:
165 DISALLOW_COPY_AND_ASSIGN(MethodId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700166 };
167
168 // Raw proto_id_item.
169 struct ProtoId {
Ian Rogers0571d352011-11-03 19:51:38 -0700170 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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700173 uint32_t parameters_off_; // file offset to type_list for parameter types
Elliott Hughesa21039c2012-06-21 12:09:25 -0700174
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700175 private:
176 DISALLOW_COPY_AND_ASSIGN(ProtoId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700177 };
178
179 // Raw class_def_item.
180 struct ClassDef {
Ian Rogers0571d352011-11-03 19:51:38 -0700181 uint16_t class_idx_; // index into type_ids_ array for this class
182 uint16_t pad1_; // padding = 0
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700183 uint32_t access_flags_;
Ian Rogers0571d352011-11-03 19:51:38 -0700184 uint16_t superclass_idx_; // index into type_ids_ array for superclass
185 uint16_t pad2_; // padding = 0
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700186 uint32_t interfaces_off_; // file offset to TypeList
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700187 uint32_t source_file_idx_; // index into string_ids_ for source file name
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700188 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
Elliott Hughesa21039c2012-06-21 12:09:25 -0700191
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700192 private:
193 DISALLOW_COPY_AND_ASSIGN(ClassDef);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700194 };
195
196 // Raw type_item.
197 struct TypeItem {
198 uint16_t type_idx_; // index into type_ids section
Elliott Hughesa21039c2012-06-21 12:09:25 -0700199
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700200 private:
201 DISALLOW_COPY_AND_ASSIGN(TypeItem);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700202 };
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
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700219 DISALLOW_COPY_AND_ASSIGN(TypeList);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700220 };
221
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700222 // 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
Ian Rogersd81871c2011-10-03 13:57:23 -0700229 uint32_t insns_size_in_code_units_; // size of the insns array, in 2 byte code units
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700230 uint16_t insns_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700231
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700232 private:
233 DISALLOW_COPY_AND_ASSIGN(CodeItem);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700234 };
235
Carl Shapiro2eaa9682011-08-04 19:26:11 -0700236 // Raw try_item.
237 struct TryItem {
238 uint32_t start_addr_;
239 uint16_t insn_count_;
240 uint16_t handler_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700241
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700242 private:
243 DISALLOW_COPY_AND_ASSIGN(TryItem);
Carl Shapiro2eaa9682011-08-04 19:26:11 -0700244 };
245
jeffhao10037c82012-01-23 15:06:23 -0800246 // 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_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700278
jeffhao10037c82012-01-23 15:06:23 -0800279 private:
280 DISALLOW_COPY_AND_ASSIGN(AnnotationsDirectoryItem);
281 };
282
283 struct FieldAnnotationsItem {
284 uint32_t field_idx_;
285 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700286
jeffhao10037c82012-01-23 15:06:23 -0800287 private:
288 DISALLOW_COPY_AND_ASSIGN(FieldAnnotationsItem);
289 };
290
291 struct MethodAnnotationsItem {
292 uint32_t method_idx_;
293 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700294
jeffhao10037c82012-01-23 15:06:23 -0800295 private:
296 DISALLOW_COPY_AND_ASSIGN(MethodAnnotationsItem);
297 };
298
299 struct ParameterAnnotationsItem {
300 uint32_t method_idx_;
301 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700302
jeffhao10037c82012-01-23 15:06:23 -0800303 private:
304 DISALLOW_COPY_AND_ASSIGN(ParameterAnnotationsItem);
305 };
306
307 struct AnnotationSetRefItem {
308 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700309
jeffhao10037c82012-01-23 15:06:23 -0800310 private:
311 DISALLOW_COPY_AND_ASSIGN(AnnotationSetRefItem);
312 };
313
314 struct AnnotationSetRefList {
315 uint32_t size_;
316 AnnotationSetRefItem list_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700317
jeffhao10037c82012-01-23 15:06:23 -0800318 private:
319 DISALLOW_COPY_AND_ASSIGN(AnnotationSetRefList);
320 };
321
322 struct AnnotationSetItem {
323 uint32_t size_;
324 uint32_t entries_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700325
jeffhao10037c82012-01-23 15:06:23 -0800326 private:
327 DISALLOW_COPY_AND_ASSIGN(AnnotationSetItem);
328 };
329
330 struct AnnotationItem {
331 uint8_t visibility_;
332 uint8_t annotation_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700333
jeffhao10037c82012-01-23 15:06:23 -0800334 private:
335 DISALLOW_COPY_AND_ASSIGN(AnnotationItem);
336 };
337
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700338 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,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700343 const ClassPath& class_path);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700344
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800345 // 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.
Ian Rogers33e95662013-05-20 20:29:14 -0700349 static bool GetChecksum(const std::string& filename, uint32_t& checksum)
350 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Brian Carlstrom78128a62011-09-15 17:21:19 -0700351
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700352 // Opens .dex file, guessing the container format based on file extension
Brian Carlstrom16192862011-09-12 17:50:06 -0700353 static const DexFile* Open(const std::string& filename,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800354 const std::string& location);
jeffhao262bf462011-10-20 18:36:32 -0700355
Brian Carlstrom89521892011-12-07 22:05:07 -0800356 // Opens .dex file, backed by existing memory
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800357 static const DexFile* Open(const uint8_t* base, size_t size,
Brian Carlstrom28db0122012-10-18 16:20:41 -0700358 const std::string& location,
359 uint32_t location_checksum) {
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800360 return OpenMemory(base, size, location, location_checksum, NULL);
Brian Carlstrom89521892011-12-07 22:05:07 -0800361 }
362
Brian Carlstroma6cc8932012-01-04 14:44:07 -0800363 // 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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700366 // Closes a .dex file.
Brian Carlstromf615a612011-07-23 12:50:34 -0700367 virtual ~DexFile();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700368
Brian Carlstroma663ea52011-08-19 23:33:41 -0700369 const std::string& GetLocation() const {
370 return location_;
371 }
372
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800373 // 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
Jesse Wilson6bf19152011-09-29 13:12:33 -0400379 // 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
Brian Carlstroma663ea52011-08-19 23:33:41 -0700383 const Header& GetHeader() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700384 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700385 return *header_;
Carl Shapiro1fb86202011-06-27 17:43:13 -0700386 }
387
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200388 Mutex& GetModificationLock() {
389 return modification_lock;
390 }
391
Ian Rogers0571d352011-11-03 19:51:38 -0700392 // Decode the dex magic version
Ian Rogersd81871c2011-10-03 13:57:23 -0700393 uint32_t GetVersion() const;
394
Brian Carlstrom6e3b1d92012-01-11 01:36:32 -0800395 // 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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700401 // Returns the number of string identifiers in the .dex file.
402 size_t NumStringIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700403 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700404 return header_->string_ids_size_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700405 }
406
Ian Rogers0571d352011-11-03 19:51:38 -0700407 // Returns the StringId at the specified index.
408 const StringId& GetStringId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700409 DCHECK_LT(idx, NumStringIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700410 return string_ids_[idx];
411 }
412
413 uint32_t GetIndexForStringId(const StringId& string_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800414 CHECK_GE(&string_id, string_ids_) << GetLocation();
415 CHECK_LT(&string_id, string_ids_ + header_->string_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700416 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.
Elliott Hughes45651fd2012-02-21 15:48:20 -0800422 const char* GetStringDataAndLength(const StringId& string_id, uint32_t* length) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700423
424 const char* GetStringData(const StringId& string_id) const {
Elliott Hughes45651fd2012-02-21 15:48:20 -0800425 uint32_t length;
Ian Rogers0571d352011-11-03 19:51:38 -0700426 return GetStringDataAndLength(string_id, &length);
427 }
428
429 // return the UTF-8 encoded string with the specified string_id index
Elliott Hughes45651fd2012-02-21 15:48:20 -0800430 const char* StringDataAndLengthByIdx(uint32_t idx, uint32_t* unicode_length) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700431 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 {
Elliott Hughes45651fd2012-02-21 15:48:20 -0800440 uint32_t unicode_length;
Ian Rogers0571d352011-11-03 19:51:38 -0700441 return StringDataAndLengthByIdx(idx, &unicode_length);
442 }
443
Ian Rogers637c65b2013-05-31 11:46:00 -0700444 // 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;
Ian Rogers0571d352011-11-03 19:51:38 -0700449
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700450 // Returns the number of type identifiers in the .dex file.
451 size_t NumTypeIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700452 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700453 return header_->type_ids_size_;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -0700454 }
455
Ian Rogers0571d352011-11-03 19:51:38 -0700456 // Returns the TypeId at the specified index.
457 const TypeId& GetTypeId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700458 DCHECK_LT(idx, NumTypeIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700459 return type_ids_[idx];
Carl Shapiro5fafe2b2011-07-09 15:34:41 -0700460 }
461
Ian Rogers0571d352011-11-03 19:51:38 -0700462 uint16_t GetIndexForTypeId(const TypeId& type_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800463 CHECK_GE(&type_id, type_ids_) << GetLocation();
464 CHECK_LT(&type_id, type_ids_ + header_->type_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700465 size_t result = &type_id - type_ids_;
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800466 DCHECK_LT(result, 65536U) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700467 return static_cast<uint16_t>(result);
468 }
469
470 // Get the descriptor string associated with a given type index.
Elliott Hughes45651fd2012-02-21 15:48:20 -0800471 const char* StringByTypeIdx(uint32_t idx, uint32_t* unicode_length) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700472 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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700489 // Returns the number of field identifiers in the .dex file.
490 size_t NumFieldIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700491 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700492 return header_->field_ids_size_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700493 }
494
Ian Rogers0571d352011-11-03 19:51:38 -0700495 // Returns the FieldId at the specified index.
496 const FieldId& GetFieldId(uint32_t idx) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800497 CHECK_LT(idx, NumFieldIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700498 return field_ids_[idx];
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700499 }
500
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800501 uint32_t GetIndexForFieldId(const FieldId& field_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800502 CHECK_GE(&field_id, field_ids_) << GetLocation();
503 CHECK_LT(&field_id, field_ids_ + header_->field_ids_size_) << GetLocation();
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800504 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
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700512 // Returns the declaring class descriptor string of a field id.
513 const char* GetFieldDeclaringClassDescriptor(const FieldId& field_id) const {
Brian Carlstromb9edb842011-08-28 16:31:06 -0700514 const DexFile::TypeId& type_id = GetTypeId(field_id.class_idx_);
515 return GetTypeDescriptor(type_id);
516 }
517
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700518 // 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
Brian Carlstromb9edb842011-08-28 16:31:06 -0700524 // Returns the name of a field id.
525 const char* GetFieldName(const FieldId& field_id) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700526 return StringDataByIdx(field_id.name_idx_);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700527 }
528
Ian Rogers0571d352011-11-03 19:51:38 -0700529 // Returns the number of method identifiers in the .dex file.
530 size_t NumMethodIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700531 DCHECK(header_ != NULL) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700532 return header_->method_ids_size_;
533 }
534
535 // Returns the MethodId at the specified index.
536 const MethodId& GetMethodId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700537 DCHECK_LT(idx, NumMethodIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700538 return method_ids_[idx];
539 }
540
541 uint32_t GetIndexForMethodId(const MethodId& method_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800542 CHECK_GE(&method_id, method_ids_) << GetLocation();
543 CHECK_LT(&method_id, method_ids_ + header_->method_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700544 return &method_id - method_ids_;
545 }
546
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800547 // 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,
Ian Rogers0571d352011-11-03 19:51:38 -0700550 const DexFile::ProtoId& signature) const;
551
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700552 // Returns the declaring class descriptor string of a method id.
553 const char* GetMethodDeclaringClassDescriptor(const MethodId& method_id) const {
Brian Carlstrom7540ff42011-09-04 16:38:46 -0700554 const DexFile::TypeId& type_id = GetTypeId(method_id.class_idx_);
555 return GetTypeDescriptor(type_id);
556 }
557
jeffhao98eacac2011-09-14 16:11:53 -0700558 // Returns the prototype of a method id.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700559 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 {
Ian Rogers0571d352011-11-03 19:51:38 -0700565 return CreateMethodSignature(method_id.proto_idx_, NULL);
jeffhao98eacac2011-09-14 16:11:53 -0700566 }
567
Brian Carlstrom7540ff42011-09-04 16:38:46 -0700568 // Returns the name of a method id.
569 const char* GetMethodName(const MethodId& method_id) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700570 return StringDataByIdx(method_id.name_idx_);
Brian Carlstrom7540ff42011-09-04 16:38:46 -0700571 }
572
Ian Rogers0571d352011-11-03 19:51:38 -0700573 // 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_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700576 }
Elliott Hughes45651fd2012-02-21 15:48:20 -0800577 const char* GetMethodShorty(const MethodId& method_id, uint32_t* length) const {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800578 return StringDataAndLengthByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_, length);
579 }
Ian Rogers0571d352011-11-03 19:51:38 -0700580 // Returns the number of class definitions in the .dex file.
581 size_t NumClassDefs() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700582 DCHECK(header_ != NULL) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700583 return header_->class_defs_size_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700584 }
585
586 // Returns the ClassDef at the specified index.
587 const ClassDef& GetClassDef(uint32_t idx) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800588 CHECK_LT(idx, NumClassDefs()) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700589 return class_defs_[idx];
590 }
591
Ian Rogers0571d352011-11-03 19:51:38 -0700592 uint32_t GetIndexForClassDef(const ClassDef& class_def) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800593 CHECK_GE(&class_def, class_defs_) << GetLocation();
594 CHECK_LT(&class_def, class_defs_ + header_->class_defs_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700595 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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700609 const TypeList* GetInterfacesList(const ClassDef& class_def) const {
610 if (class_def.interfaces_off_ == 0) {
611 return NULL;
612 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800613 const byte* addr = begin_ + class_def.interfaces_off_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700614 return reinterpret_cast<const TypeList*>(addr);
615 }
616 }
617
Ian Rogers0571d352011-11-03 19:51:38 -0700618 // 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 {
Ian Rogers30fab402012-01-23 15:43:46 -0800623 return begin_ + class_def.class_data_off_;
Ian Rogers0571d352011-11-03 19:51:38 -0700624 }
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700625 }
626
Ian Rogers0571d352011-11-03 19:51:38 -0700627 //
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800628 const CodeItem* GetCodeItem(const uint32_t code_off) const {
629 if (code_off == 0) {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700630 return NULL; // native or abstract method
631 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800632 const byte* addr = begin_ + code_off;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700633 return reinterpret_cast<const CodeItem*>(addr);
634 }
635 }
636
Ian Rogers0571d352011-11-03 19:51:38 -0700637 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 {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700643 DCHECK(header_ != NULL) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700644 return header_->proto_ids_size_;
645 }
646
647 // Returns the ProtoId at the specified index.
648 const ProtoId& GetProtoId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700649 DCHECK_LT(idx, NumProtoIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700650 return proto_ids_[idx];
651 }
652
653 uint16_t GetIndexForProtoId(const ProtoId& proto_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800654 CHECK_GE(&proto_id, proto_ids_) << GetLocation();
655 CHECK_LT(&proto_id, proto_ids_ + header_->proto_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700656 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,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800661 const std::vector<uint16_t>& signature_type_idxs_) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700662
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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700670 // 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);
Ian Rogers0571d352011-11-03 19:51:38 -0700673 return StringDataByIdx(proto_id.shorty_idx_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700674 }
675
676 const TypeList* GetProtoParameters(const ProtoId& proto_id) const {
677 if (proto_id.parameters_off_ == 0) {
678 return NULL;
679 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800680 const byte* addr = begin_ + proto_id.parameters_off_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700681 return reinterpret_cast<const TypeList*>(addr);
682 }
683 }
684
Ian Rogers0571d352011-11-03 19:51:38 -0700685 const byte* GetEncodedStaticFieldValuesArray(const ClassDef& class_def) const {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700686 if (class_def.static_values_off_ == 0) {
687 return 0;
688 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800689 return begin_ + class_def.static_values_off_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700690 }
691 }
692
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800693 static const TryItem* GetTryItems(const CodeItem& code_item, uint32_t offset);
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700694
695 // Get the base of the encoded data for the given DexCode.
Ian Rogers0571d352011-11-03 19:51:38 -0700696 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_));
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700699 return handler_data + offset;
700 }
701
Ian Rogersdbbc99d2013-04-18 16:51:54 -0700702 // 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);
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700707
Shih-wei Liao195487c2011-08-20 13:29:04 -0700708 // Get the pointer to the start of the debugging data
Ian Rogers0571d352011-11-03 19:51:38 -0700709 const byte* GetDebugInfoStream(const CodeItem* code_item) const {
Shih-wei Liao195487c2011-08-20 13:29:04 -0700710 if (code_item->debug_info_off_ == 0) {
711 return NULL;
712 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800713 return begin_ + code_item->debug_info_off_;
Shih-wei Liao195487c2011-08-20 13:29:04 -0700714 }
715 }
716
717 // Callback for "new position table entry".
718 // Returning true causes the decoder to stop early.
Elliott Hughes2435a572012-02-17 16:07:41 -0800719 typedef bool (*DexDebugNewPositionCb)(void* context, uint32_t address, uint32_t line_num);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700720
721 // Callback for "new locals table entry". "signature" is an empty string
722 // if no signature is available for an entry.
Elliott Hughes2435a572012-02-17 16:07:41 -0800723 typedef void (*DexDebugNewLocalCb)(void* context, uint16_t reg,
Elliott Hughes24edeb52012-06-18 15:29:46 -0700724 uint32_t start_address,
725 uint32_t end_address,
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700726 const char* name,
727 const char* descriptor,
728 const char* signature);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700729
Elliott Hughes2435a572012-02-17 16:07:41 -0800730 static bool LineNumForPcCb(void* context, uint32_t address, uint32_t line_num);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700731
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 {
Ian Rogersca190662012-06-26 15:45:57 -0700750 LocalInfo()
751 : name_(NULL), descriptor_(NULL), signature_(NULL), start_address_(0), is_live_(false) {}
Shih-wei Liao195487c2011-08-20 13:29:04 -0700752
Ian Rogers0571d352011-11-03 19:51:38 -0700753 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.
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700758
759 private:
760 DISALLOW_COPY_AND_ASSIGN(LocalInfo);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700761 };
762
763 struct LineNumFromPcContext {
Ian Rogersca190662012-06-26 15:45:57 -0700764 LineNumFromPcContext(uint32_t address, uint32_t line_num)
765 : address_(address), line_num_(line_num) {}
Shih-wei Liao195487c2011-08-20 13:29:04 -0700766 uint32_t address_;
767 uint32_t line_num_;
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700768 private:
769 DISALLOW_COPY_AND_ASSIGN(LineNumFromPcContext);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700770 };
771
Elliott Hughes2435a572012-02-17 16:07:41 -0800772 void InvokeLocalCbIfLive(void* context, int reg, uint32_t end_address,
Brian Carlstrom78128a62011-09-15 17:21:19 -0700773 LocalInfo* local_in_reg, DexDebugNewLocalCb local_cb) const {
Shih-wei Liao195487c2011-08-20 13:29:04 -0700774 if (local_cb != NULL && local_in_reg[reg].is_live_) {
Elliott Hughes2435a572012-02-17 16:07:41 -0800775 local_cb(context, reg, local_in_reg[reg].start_address_, end_address,
Elliott Hughesdbb40792011-11-18 17:05:22 -0800776 local_in_reg[reg].name_, local_in_reg[reg].descriptor_,
777 local_in_reg[reg].signature_ != NULL ? local_in_reg[reg].signature_ : "");
Shih-wei Liao195487c2011-08-20 13:29:04 -0700778 }
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.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800789 int32_t GetLineNumFromPC(const mirror::AbstractMethod* method, uint32_t rel_pc) const
Ian Rogersb726dcb2012-09-05 08:57:23 -0700790 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700791
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800792 void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
Elliott Hughes2435a572012-02-17 16:07:41 -0800793 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb,
794 void* context) const;
Shih-wei Liao195487c2011-08-20 13:29:04 -0700795
Ian Rogers0571d352011-11-03 19:51:38 -0700796 const char* GetSourceFile(const ClassDef& class_def) const {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700797 if (class_def.source_file_idx_ == 0xffffffff) {
798 return NULL;
799 } else {
Ian Rogers0571d352011-11-03 19:51:38 -0700800 return StringDataByIdx(class_def.source_file_idx_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700801 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700802 }
803
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800804 int GetPermissions() const;
Ian Rogers1c849e52012-06-28 14:00:33 -0700805
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200806 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
Carl Shapiro1fb86202011-06-27 17:43:13 -0700812 private:
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700813 // Opens a .dex file
814 static const DexFile* OpenFile(const std::string& filename,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800815 const std::string& location,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800816 bool verify);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700817
818 // Opens a dex file from within a .jar, .zip, or .apk file
819 static const DexFile* OpenZip(const std::string& filename,
Brian Carlstroma004aa92012-02-08 18:05:09 -0800820 const std::string& location);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700821
Brian Carlstrom89521892011-12-07 22:05:07 -0800822 // Opens a .dex file at the given address backed by a MemMap
823 static const DexFile* OpenMemory(const std::string& location,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800824 uint32_t location_checksum,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800825 MemMap* mem_map);
Brian Carlstrom89521892011-12-07 22:05:07 -0800826
827 // Opens a .dex file at the given address, optionally backed by a MemMap
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700828 static const DexFile* OpenMemory(const byte* dex_file,
jeffhaof6174e82012-01-31 16:14:17 -0800829 size_t size,
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700830 const std::string& location,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800831 uint32_t location_checksum,
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700832 MemMap* mem_map);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700833
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800834 DexFile(const byte* base, size_t size,
Brian Carlstrom28db0122012-10-18 16:20:41 -0700835 const std::string& location,
836 uint32_t location_checksum,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800837 MemMap* mem_map)
Ian Rogers30fab402012-01-23 15:43:46 -0800838 : begin_(base),
jeffhaof6174e82012-01-31 16:14:17 -0800839 size_(size),
Brian Carlstroma663ea52011-08-19 23:33:41 -0700840 location_(location),
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800841 location_checksum_(location_checksum),
Brian Carlstrom33f741e2011-10-03 11:24:05 -0700842 mem_map_(mem_map),
Jesse Wilson6bf19152011-09-29 13:12:33 -0400843 dex_object_(NULL),
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200844 modification_lock("DEX modification lock"),
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700845 header_(0),
846 string_ids_(0),
847 type_ids_(0),
848 field_ids_(0),
849 method_ids_(0),
850 proto_ids_(0),
Brian Carlstroma663ea52011-08-19 23:33:41 -0700851 class_defs_(0) {
Ian Rogers30fab402012-01-23 15:43:46 -0800852 CHECK(begin_ != NULL) << GetLocation();
jeffhaof6174e82012-01-31 16:14:17 -0800853 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_;
Brian Carlstroma663ea52011-08-19 23:33:41 -0700862 }
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700863
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
Brian Carlstrom6e3b1d92012-01-11 01:36:32 -0800873 // Returns true if the header magic and version numbers are of the expected values.
jeffhao10037c82012-01-23 15:06:23 -0800874 bool CheckMagicAndVersion() const;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700875
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800876 void DecodeDebugInfo0(const CodeItem* code_item, bool is_static, uint32_t method_idx,
Elliott Hughes2435a572012-02-17 16:07:41 -0800877 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb,
878 void* context, const byte* stream, LocalInfo* local_in_reg) const;
Elliott Hughes03181a82011-11-17 17:22:21 -0800879
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800880 // The index of descriptors to class definition indexes (as opposed to type id indexes)
Elliott Hughesa0e18062012-04-13 15:59:59 -0700881 typedef SafeMap<const StringPiece, uint32_t> Index;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700882 Index index_;
883
884 // The base address of the memory mapping.
Ian Rogers62d6c772013-02-27 08:32:07 -0800885 const byte* const begin_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700886
887 // The size of the underlying memory allocation in bytes.
Ian Rogers62d6c772013-02-27 08:32:07 -0800888 const size_t size_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700889
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700890 // Typically the dex file name when available, alternatively some identifying string.
Brian Carlstroma663ea52011-08-19 23:33:41 -0700891 //
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
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800896 const uint32_t location_checksum_;
897
Brian Carlstrom33f741e2011-10-03 11:24:05 -0700898 // Manages the underlying memory allocation.
899 UniquePtr<MemMap> mem_map_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700900
Jesse Wilson6bf19152011-09-29 13:12:33 -0400901 // A cached com.android.dex.Dex instance, possibly NULL. Use GetDexObject.
Ian Rogers62d6c772013-02-27 08:32:07 -0800902 // TODO: this is mutable as it shouldn't be here. We should move it to the dex cache or similar.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700903 mutable jobject dex_object_;
Jesse Wilson6bf19152011-09-29 13:12:33 -0400904
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200905 // 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
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700910 // 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_;
Carl Shapiro1fb86202011-06-27 17:43:13 -0700930};
931
Ian Rogers0571d352011-11-03 19:51:38 -0700932// 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_; }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800944 uint16_t GetTypeIdx() {
Ian Rogers0571d352011-11-03 19:51:38 -0700945 return type_list_->GetTypeItem(pos_).type_idx_;
946 }
947 const char* GetDescriptor() {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800948 return dex_file_.StringByTypeIdx(GetTypeIdx());
Ian Rogers0571d352011-11-03 19:51:38 -0700949 }
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 }
Ian Rogers637c65b2013-05-31 11:46:00 -0700997 inline void Next() {
Ian Rogers0571d352011-11-03 19:51:38 -0700998 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 }
Ian Rogers08f753d2012-08-24 14:35:25 -07001040 InvokeType GetMethodInvokeType(const DexFile::ClassDef& class_def) const {
1041 if (HasNextDirectMethod()) {
Brian Carlstromdf629502013-07-17 22:39:56 -07001042 if ((GetMemberAccessFlags() & kAccStatic) != 0) {
Ian Rogers08f753d2012-08-24 14:35:25 -07001043 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 }
Ian Rogers0571d352011-11-03 19:51:38 -07001058 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 }
jeffhao10037c82012-01-23 15:06:23 -08001064 const byte* EndDataPointer() const {
1065 CHECK(!HasNext());
1066 return ptr_pos_;
1067 }
Elliott Hughesa21039c2012-06-21 12:09:25 -07001068
Ian Rogers0571d352011-11-03 19:51:38 -07001069 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) {}
Elliott Hughesa21039c2012-06-21 12:09:25 -07001100
Ian Rogers0571d352011-11-03 19:51:38 -07001101 private:
1102 DISALLOW_COPY_AND_ASSIGN(ClassDataField);
Elliott Hughesee0fa762012-03-26 17:12:41 -07001103 };
1104 ClassDataField field_;
Ian Rogers0571d352011-11-03 19:51:38 -07001105
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) {}
Elliott Hughesa21039c2012-06-21 12:09:25 -07001115
Ian Rogers0571d352011-11-03 19:51:38 -07001116 private:
1117 DISALLOW_COPY_AND_ASSIGN(ClassDataMethod);
Elliott Hughesee0fa762012-03-26 17:12:41 -07001118 };
1119 ClassDataMethod method_;
Ian Rogers0571d352011-11-03 19:51:38 -07001120
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
Ian Rogers0571d352011-11-03 19:51:38 -07001131class EncodedStaticFieldValueIterator {
1132 public:
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001133 EncodedStaticFieldValueIterator(const DexFile& dex_file, mirror::DexCache* dex_cache,
1134 mirror::ClassLoader* class_loader,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001135 ClassLinker* linker, const DexFile::ClassDef& class_def)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001136 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001137
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001138 void ReadValueToField(mirror::Field* field) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001139
1140 bool HasNext() { return pos_ < array_size_; }
1141
1142 void Next();
Elliott Hughesa21039c2012-06-21 12:09:25 -07001143
Ian Rogers0571d352011-11-03 19:51:38 -07001144 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
Brian Carlstrom88f36542012-10-16 23:24:21 -07001163 private:
Ian Rogers0571d352011-11-03 19:51:38 -07001164 static const byte kEncodedValueTypeMask = 0x1f; // 0b11111
1165 static const byte kEncodedValueArgShift = 5;
1166
1167 const DexFile& dex_file_;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001168 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.
Ian Rogers0571d352011-11-03 19:51:38 -07001176 DISALLOW_IMPLICIT_CONSTRUCTORS(EncodedStaticFieldValueIterator);
1177};
Brian Carlstrom88f36542012-10-16 23:24:21 -07001178std::ostream& operator<<(std::ostream& os, const EncodedStaticFieldValueIterator::ValueType& code);
Ian Rogers0571d352011-11-03 19:51:38 -07001179
1180class CatchHandlerIterator {
1181 public:
1182 CatchHandlerIterator(const DexFile::CodeItem& code_item, uint32_t address);
Logan Chien736df022012-04-27 16:25:57 +08001183
1184 CatchHandlerIterator(const DexFile::CodeItem& code_item,
1185 const DexFile::TryItem& try_item);
1186
Ian Rogers0571d352011-11-03 19:51:38 -07001187 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 }
Elliott Hughesa21039c2012-06-21 12:09:25 -07001206
Ian Rogers0571d352011-11-03 19:51:38 -07001207 private:
Logan Chien736df022012-04-27 16:25:57 +08001208 void Init(const DexFile::CodeItem& code_item, int32_t offset);
Ian Rogers0571d352011-11-03 19:51:38 -07001209 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
Carl Shapiro1fb86202011-06-27 17:43:13 -07001221} // namespace art
1222
Brian Carlstromfc0e3212013-07-17 14:40:12 -07001223#endif // ART_RUNTIME_DEX_FILE_H_