blob: 51ab8d81a880d879d7d3bff75d65a47368ba4901 [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
Brian Carlstrome8104522013-10-15 21:56:36 -070036// TODO: remove dependencies on mirror classes, primarily by moving
37// EncodedStaticFieldValueIterator to its own file.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080038namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070039 class ArtField;
40 class ArtMethod;
41 class ClassLoader;
42 class DexCache;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043} // namespace mirror
44class ClassLinker;
Ian Rogersd91d6d62013-09-25 20:26:14 -070045class Signature;
Mathieu Chartier590fee92013-09-13 13:46:47 -070046template <typename T>
47class SirtRef;
Ian Rogersfc0e94b2013-09-23 23:51:32 -070048class StringPiece;
Brian Carlstroma6cc8932012-01-04 14:44:07 -080049class ZipArchive;
50
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070051// TODO: move all of the macro functionality into the DexCache class.
Brian Carlstromf615a612011-07-23 12:50:34 -070052class DexFile {
Carl Shapiro1fb86202011-06-27 17:43:13 -070053 public:
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070054 static const byte kDexMagic[];
55 static const byte kDexMagicVersion[];
56 static const size_t kSha1DigestSize = 20;
jeffhao10037c82012-01-23 15:06:23 -080057 static const uint32_t kDexEndianConstant = 0x12345678;
Carl Shapiro80d4dde2011-06-28 16:24:07 -070058
Brian Carlstromb7bbba42011-10-13 14:58:47 -070059 // name of the DexFile entry within a zip archive
60 static const char* kClassesDex;
61
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070062 // The value of an invalid index.
63 static const uint32_t kDexNoIndex = 0xFFFFFFFF;
64
Ian Rogers0571d352011-11-03 19:51:38 -070065 // The value of an invalid index.
66 static const uint16_t kDexNoIndex16 = 0xFFFF;
Carl Shapiro1fb86202011-06-27 17:43:13 -070067
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070068 // Raw header_item.
69 struct Header {
70 uint8_t magic_[8];
Brian Carlstrom7934ac22013-07-26 10:54:15 -070071 uint32_t checksum_; // See also location_checksum_
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070072 uint8_t signature_[kSha1DigestSize];
jeffhaof6174e82012-01-31 16:14:17 -080073 uint32_t file_size_; // size of entire file
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070074 uint32_t header_size_; // offset to start of next section
75 uint32_t endian_tag_;
Ian Rogers0571d352011-11-03 19:51:38 -070076 uint32_t link_size_; // unused
77 uint32_t link_off_; // unused
78 uint32_t map_off_; // unused
79 uint32_t string_ids_size_; // number of StringIds
80 uint32_t string_ids_off_; // file offset of StringIds array
81 uint32_t type_ids_size_; // number of TypeIds, we don't support more than 65535
82 uint32_t type_ids_off_; // file offset of TypeIds array
83 uint32_t proto_ids_size_; // number of ProtoIds, we don't support more than 65535
84 uint32_t proto_ids_off_; // file offset of ProtoIds array
85 uint32_t field_ids_size_; // number of FieldIds
86 uint32_t field_ids_off_; // file offset of FieldIds array
87 uint32_t method_ids_size_; // number of MethodIds
88 uint32_t method_ids_off_; // file offset of MethodIds array
89 uint32_t class_defs_size_; // number of ClassDefs
90 uint32_t class_defs_off_; // file offset of ClassDef array
91 uint32_t data_size_; // unused
92 uint32_t data_off_; // unused
Elliott Hughesa21039c2012-06-21 12:09:25 -070093
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -070094 private:
95 DISALLOW_COPY_AND_ASSIGN(Header);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -070096 };
Carl Shapiro1fb86202011-06-27 17:43:13 -070097
jeffhao10037c82012-01-23 15:06:23 -080098 // Map item type codes.
99 enum {
100 kDexTypeHeaderItem = 0x0000,
101 kDexTypeStringIdItem = 0x0001,
102 kDexTypeTypeIdItem = 0x0002,
103 kDexTypeProtoIdItem = 0x0003,
104 kDexTypeFieldIdItem = 0x0004,
105 kDexTypeMethodIdItem = 0x0005,
106 kDexTypeClassDefItem = 0x0006,
107 kDexTypeMapList = 0x1000,
108 kDexTypeTypeList = 0x1001,
109 kDexTypeAnnotationSetRefList = 0x1002,
110 kDexTypeAnnotationSetItem = 0x1003,
111 kDexTypeClassDataItem = 0x2000,
112 kDexTypeCodeItem = 0x2001,
113 kDexTypeStringDataItem = 0x2002,
114 kDexTypeDebugInfoItem = 0x2003,
115 kDexTypeAnnotationItem = 0x2004,
116 kDexTypeEncodedArrayItem = 0x2005,
117 kDexTypeAnnotationsDirectoryItem = 0x2006,
118 };
119
120 struct MapItem {
121 uint16_t type_;
122 uint16_t unused_;
123 uint32_t size_;
124 uint32_t offset_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700125
jeffhao10037c82012-01-23 15:06:23 -0800126 private:
127 DISALLOW_COPY_AND_ASSIGN(MapItem);
128 };
129
130 struct MapList {
131 uint32_t size_;
132 MapItem list_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700133
jeffhao10037c82012-01-23 15:06:23 -0800134 private:
135 DISALLOW_COPY_AND_ASSIGN(MapList);
136 };
137
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700138 // Raw string_id_item.
139 struct StringId {
140 uint32_t string_data_off_; // offset in bytes from the base address
Elliott Hughesa21039c2012-06-21 12:09:25 -0700141
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700142 private:
143 DISALLOW_COPY_AND_ASSIGN(StringId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700144 };
145
146 // Raw type_id_item.
147 struct TypeId {
148 uint32_t descriptor_idx_; // index into string_ids
Elliott Hughesa21039c2012-06-21 12:09:25 -0700149
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700150 private:
151 DISALLOW_COPY_AND_ASSIGN(TypeId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700152 };
153
154 // Raw field_id_item.
155 struct FieldId {
Ian Rogers0571d352011-11-03 19:51:38 -0700156 uint16_t class_idx_; // index into type_ids_ array for defining class
157 uint16_t type_idx_; // index into type_ids_ array for field type
158 uint32_t name_idx_; // index into string_ids_ array for field name
Elliott Hughesa21039c2012-06-21 12:09:25 -0700159
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700160 private:
161 DISALLOW_COPY_AND_ASSIGN(FieldId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700162 };
163
164 // Raw method_id_item.
165 struct MethodId {
Ian Rogers0571d352011-11-03 19:51:38 -0700166 uint16_t class_idx_; // index into type_ids_ array for defining class
167 uint16_t proto_idx_; // index into proto_ids_ array for method prototype
168 uint32_t name_idx_; // index into string_ids_ array for method name
Elliott Hughesa21039c2012-06-21 12:09:25 -0700169
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700170 private:
171 DISALLOW_COPY_AND_ASSIGN(MethodId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700172 };
173
174 // Raw proto_id_item.
175 struct ProtoId {
Ian Rogers0571d352011-11-03 19:51:38 -0700176 uint32_t shorty_idx_; // index into string_ids array for shorty descriptor
177 uint16_t return_type_idx_; // index into type_ids array for return type
178 uint16_t pad_; // padding = 0
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700179 uint32_t parameters_off_; // file offset to type_list for parameter types
Elliott Hughesa21039c2012-06-21 12:09:25 -0700180
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700181 private:
182 DISALLOW_COPY_AND_ASSIGN(ProtoId);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700183 };
184
185 // Raw class_def_item.
186 struct ClassDef {
Ian Rogers0571d352011-11-03 19:51:38 -0700187 uint16_t class_idx_; // index into type_ids_ array for this class
188 uint16_t pad1_; // padding = 0
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700189 uint32_t access_flags_;
Ian Rogers0571d352011-11-03 19:51:38 -0700190 uint16_t superclass_idx_; // index into type_ids_ array for superclass
191 uint16_t pad2_; // padding = 0
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700192 uint32_t interfaces_off_; // file offset to TypeList
Brian Carlstrom4a96b602011-07-26 16:40:23 -0700193 uint32_t source_file_idx_; // index into string_ids_ for source file name
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700194 uint32_t annotations_off_; // file offset to annotations_directory_item
195 uint32_t class_data_off_; // file offset to class_data_item
196 uint32_t static_values_off_; // file offset to EncodedArray
Elliott Hughesa21039c2012-06-21 12:09:25 -0700197
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700198 private:
199 DISALLOW_COPY_AND_ASSIGN(ClassDef);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700200 };
201
202 // Raw type_item.
203 struct TypeItem {
204 uint16_t type_idx_; // index into type_ids section
Elliott Hughesa21039c2012-06-21 12:09:25 -0700205
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700206 private:
207 DISALLOW_COPY_AND_ASSIGN(TypeItem);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700208 };
209
210 // Raw type_list.
211 class TypeList {
212 public:
213 uint32_t Size() const {
214 return size_;
215 }
216
217 const TypeItem& GetTypeItem(uint32_t idx) const {
Sebastien Hertzb24bd992013-08-02 15:19:09 +0200218 DCHECK_LT(idx, this->size_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700219 return this->list_[idx];
220 }
221
222 private:
223 uint32_t size_; // size of the list, in entries
224 TypeItem list_[1]; // elements of the list
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700225 DISALLOW_COPY_AND_ASSIGN(TypeList);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700226 };
227
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700228 // Raw code_item.
229 struct CodeItem {
230 uint16_t registers_size_;
231 uint16_t ins_size_;
232 uint16_t outs_size_;
233 uint16_t tries_size_;
234 uint32_t debug_info_off_; // file offset to debug info stream
Ian Rogersd81871c2011-10-03 13:57:23 -0700235 uint32_t insns_size_in_code_units_; // size of the insns array, in 2 byte code units
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700236 uint16_t insns_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700237
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700238 private:
239 DISALLOW_COPY_AND_ASSIGN(CodeItem);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700240 };
241
Carl Shapiro2eaa9682011-08-04 19:26:11 -0700242 // Raw try_item.
243 struct TryItem {
244 uint32_t start_addr_;
245 uint16_t insn_count_;
246 uint16_t handler_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700247
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700248 private:
249 DISALLOW_COPY_AND_ASSIGN(TryItem);
Carl Shapiro2eaa9682011-08-04 19:26:11 -0700250 };
251
jeffhao10037c82012-01-23 15:06:23 -0800252 // Annotation constants.
253 enum {
254 kDexVisibilityBuild = 0x00, /* annotation visibility */
255 kDexVisibilityRuntime = 0x01,
256 kDexVisibilitySystem = 0x02,
257
258 kDexAnnotationByte = 0x00,
259 kDexAnnotationShort = 0x02,
260 kDexAnnotationChar = 0x03,
261 kDexAnnotationInt = 0x04,
262 kDexAnnotationLong = 0x06,
263 kDexAnnotationFloat = 0x10,
264 kDexAnnotationDouble = 0x11,
265 kDexAnnotationString = 0x17,
266 kDexAnnotationType = 0x18,
267 kDexAnnotationField = 0x19,
268 kDexAnnotationMethod = 0x1a,
269 kDexAnnotationEnum = 0x1b,
270 kDexAnnotationArray = 0x1c,
271 kDexAnnotationAnnotation = 0x1d,
272 kDexAnnotationNull = 0x1e,
273 kDexAnnotationBoolean = 0x1f,
274
275 kDexAnnotationValueTypeMask = 0x1f, /* low 5 bits */
276 kDexAnnotationValueArgShift = 5,
277 };
278
279 struct AnnotationsDirectoryItem {
280 uint32_t class_annotations_off_;
281 uint32_t fields_size_;
282 uint32_t methods_size_;
283 uint32_t parameters_size_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700284
jeffhao10037c82012-01-23 15:06:23 -0800285 private:
286 DISALLOW_COPY_AND_ASSIGN(AnnotationsDirectoryItem);
287 };
288
289 struct FieldAnnotationsItem {
290 uint32_t field_idx_;
291 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700292
jeffhao10037c82012-01-23 15:06:23 -0800293 private:
294 DISALLOW_COPY_AND_ASSIGN(FieldAnnotationsItem);
295 };
296
297 struct MethodAnnotationsItem {
298 uint32_t method_idx_;
299 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700300
jeffhao10037c82012-01-23 15:06:23 -0800301 private:
302 DISALLOW_COPY_AND_ASSIGN(MethodAnnotationsItem);
303 };
304
305 struct ParameterAnnotationsItem {
306 uint32_t method_idx_;
307 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700308
jeffhao10037c82012-01-23 15:06:23 -0800309 private:
310 DISALLOW_COPY_AND_ASSIGN(ParameterAnnotationsItem);
311 };
312
313 struct AnnotationSetRefItem {
314 uint32_t annotations_off_;
Elliott Hughesa21039c2012-06-21 12:09:25 -0700315
jeffhao10037c82012-01-23 15:06:23 -0800316 private:
317 DISALLOW_COPY_AND_ASSIGN(AnnotationSetRefItem);
318 };
319
320 struct AnnotationSetRefList {
321 uint32_t size_;
322 AnnotationSetRefItem list_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700323
jeffhao10037c82012-01-23 15:06:23 -0800324 private:
325 DISALLOW_COPY_AND_ASSIGN(AnnotationSetRefList);
326 };
327
328 struct AnnotationSetItem {
329 uint32_t size_;
330 uint32_t entries_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700331
jeffhao10037c82012-01-23 15:06:23 -0800332 private:
333 DISALLOW_COPY_AND_ASSIGN(AnnotationSetItem);
334 };
335
336 struct AnnotationItem {
337 uint8_t visibility_;
338 uint8_t annotation_[1];
Elliott Hughesa21039c2012-06-21 12:09:25 -0700339
jeffhao10037c82012-01-23 15:06:23 -0800340 private:
341 DISALLOW_COPY_AND_ASSIGN(AnnotationItem);
342 };
343
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700344 typedef std::pair<const DexFile*, const DexFile::ClassDef*> ClassPathEntry;
345 typedef std::vector<const DexFile*> ClassPath;
346
347 // Search a collection of DexFiles for a descriptor
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700348 static ClassPathEntry FindInClassPath(const char* descriptor,
Brian Carlstrom9ea1cb12011-08-24 23:18:18 -0700349 const ClassPath& class_path);
Brian Carlstrom74eb46a2011-08-02 20:10:14 -0700350
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800351 // Returns the checksum of a file for comparison with GetLocationChecksum().
352 // For .dex files, this is the header checksum.
353 // For zip files, this is the classes.dex zip entry CRC32 checksum.
354 // Return true if the checksum could be found, false otherwise.
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700355 static bool GetChecksum(const char* filename, uint32_t* checksum, std::string* error_msg);
Brian Carlstrom78128a62011-09-15 17:21:19 -0700356
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700357 // Opens .dex file, guessing the container format based on file extension
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700358 static const DexFile* Open(const char* filename, const char* location, std::string* error_msg);
jeffhao262bf462011-10-20 18:36:32 -0700359
Brian Carlstrom89521892011-12-07 22:05:07 -0800360 // Opens .dex file, backed by existing memory
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800361 static const DexFile* Open(const uint8_t* base, size_t size,
Brian Carlstrom28db0122012-10-18 16:20:41 -0700362 const std::string& location,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700363 uint32_t location_checksum,
364 std::string* error_msg) {
365 return OpenMemory(base, size, location, location_checksum, NULL, error_msg);
Brian Carlstrom89521892011-12-07 22:05:07 -0800366 }
367
Brian Carlstroma6cc8932012-01-04 14:44:07 -0800368 // Opens .dex file from the classes.dex in a zip archive
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700369 static const DexFile* Open(const ZipArchive& zip_archive, const std::string& location,
370 std::string* error_msg);
Brian Carlstroma6cc8932012-01-04 14:44:07 -0800371
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700372 // Closes a .dex file.
Brian Carlstromf615a612011-07-23 12:50:34 -0700373 virtual ~DexFile();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700374
Brian Carlstroma663ea52011-08-19 23:33:41 -0700375 const std::string& GetLocation() const {
376 return location_;
377 }
378
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800379 // For DexFiles directly from .dex files, this is the checksum from the DexFile::Header.
380 // For DexFiles opened from a zip files, this will be the ZipEntry CRC32 of classes.dex.
381 uint32_t GetLocationChecksum() const {
382 return location_checksum_;
383 }
384
Brian Carlstroma663ea52011-08-19 23:33:41 -0700385 const Header& GetHeader() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700386 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700387 return *header_;
Carl Shapiro1fb86202011-06-27 17:43:13 -0700388 }
389
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200390 Mutex& GetModificationLock() {
391 return modification_lock;
392 }
393
Ian Rogers0571d352011-11-03 19:51:38 -0700394 // Decode the dex magic version
Ian Rogersd81871c2011-10-03 13:57:23 -0700395 uint32_t GetVersion() const;
396
Brian Carlstrom6e3b1d92012-01-11 01:36:32 -0800397 // Returns true if the byte string points to the magic value.
398 static bool IsMagicValid(const byte* magic);
399
400 // Returns true if the byte string after the magic is the correct value.
401 static bool IsVersionValid(const byte* magic);
402
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700403 // Returns the number of string identifiers in the .dex file.
404 size_t NumStringIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700405 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700406 return header_->string_ids_size_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700407 }
408
Ian Rogers0571d352011-11-03 19:51:38 -0700409 // Returns the StringId at the specified index.
410 const StringId& GetStringId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700411 DCHECK_LT(idx, NumStringIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700412 return string_ids_[idx];
413 }
414
415 uint32_t GetIndexForStringId(const StringId& string_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800416 CHECK_GE(&string_id, string_ids_) << GetLocation();
417 CHECK_LT(&string_id, string_ids_ + header_->string_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700418 return &string_id - string_ids_;
419 }
420
421 int32_t GetStringLength(const StringId& string_id) const;
422
Ian Rogersdfb325e2013-10-30 01:00:44 -0700423 // Returns a pointer to the UTF-8 string data referred to by the given string_id as well as the
424 // length of the string when decoded as a UTF-16 string. Note the UTF-16 length is not the same
425 // as the string length of the string data.
426 const char* GetStringDataAndUtf16Length(const StringId& string_id, uint32_t* utf16_length) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700427
428 const char* GetStringData(const StringId& string_id) const {
Ian Rogersdfb325e2013-10-30 01:00:44 -0700429 uint32_t ignored;
430 return GetStringDataAndUtf16Length(string_id, &ignored);
Ian Rogers0571d352011-11-03 19:51:38 -0700431 }
432
Ian Rogersdfb325e2013-10-30 01:00:44 -0700433 // Index version of GetStringDataAndUtf16Length.
434 const char* StringDataAndUtf16LengthByIdx(uint32_t idx, uint32_t* utf16_length) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700435 if (idx == kDexNoIndex) {
Ian Rogersdfb325e2013-10-30 01:00:44 -0700436 *utf16_length = 0;
Ian Rogers0571d352011-11-03 19:51:38 -0700437 return NULL;
438 }
439 const StringId& string_id = GetStringId(idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -0700440 return GetStringDataAndUtf16Length(string_id, utf16_length);
Ian Rogers0571d352011-11-03 19:51:38 -0700441 }
442
443 const char* StringDataByIdx(uint32_t idx) const {
Elliott Hughes45651fd2012-02-21 15:48:20 -0800444 uint32_t unicode_length;
Ian Rogersdfb325e2013-10-30 01:00:44 -0700445 return StringDataAndUtf16LengthByIdx(idx, &unicode_length);
Ian Rogers0571d352011-11-03 19:51:38 -0700446 }
447
Ian Rogers637c65b2013-05-31 11:46:00 -0700448 // Looks up a string id for a given modified utf8 string.
449 const StringId* FindStringId(const char* string) const;
450
451 // Looks up a string id for a given utf16 string.
452 const StringId* FindStringId(const uint16_t* string) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700453
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700454 // Returns the number of type identifiers in the .dex file.
455 size_t NumTypeIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700456 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700457 return header_->type_ids_size_;
Carl Shapiro5fafe2b2011-07-09 15:34:41 -0700458 }
459
Ian Rogers0571d352011-11-03 19:51:38 -0700460 // Returns the TypeId at the specified index.
461 const TypeId& GetTypeId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700462 DCHECK_LT(idx, NumTypeIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700463 return type_ids_[idx];
Carl Shapiro5fafe2b2011-07-09 15:34:41 -0700464 }
465
Ian Rogers0571d352011-11-03 19:51:38 -0700466 uint16_t GetIndexForTypeId(const TypeId& type_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800467 CHECK_GE(&type_id, type_ids_) << GetLocation();
468 CHECK_LT(&type_id, type_ids_ + header_->type_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700469 size_t result = &type_id - type_ids_;
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800470 DCHECK_LT(result, 65536U) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700471 return static_cast<uint16_t>(result);
472 }
473
474 // Get the descriptor string associated with a given type index.
Elliott Hughes45651fd2012-02-21 15:48:20 -0800475 const char* StringByTypeIdx(uint32_t idx, uint32_t* unicode_length) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700476 const TypeId& type_id = GetTypeId(idx);
Ian Rogersdfb325e2013-10-30 01:00:44 -0700477 return StringDataAndUtf16LengthByIdx(type_id.descriptor_idx_, unicode_length);
Ian Rogers0571d352011-11-03 19:51:38 -0700478 }
479
480 const char* StringByTypeIdx(uint32_t idx) const {
481 const TypeId& type_id = GetTypeId(idx);
482 return StringDataByIdx(type_id.descriptor_idx_);
483 }
484
485 // Returns the type descriptor string of a type id.
486 const char* GetTypeDescriptor(const TypeId& type_id) const {
487 return StringDataByIdx(type_id.descriptor_idx_);
488 }
489
490 // Looks up a type for the given string index
491 const TypeId* FindTypeId(uint32_t string_idx) const;
492
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700493 // Returns the number of field identifiers in the .dex file.
494 size_t NumFieldIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700495 DCHECK(header_ != NULL) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700496 return header_->field_ids_size_;
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700497 }
498
Ian Rogers0571d352011-11-03 19:51:38 -0700499 // Returns the FieldId at the specified index.
500 const FieldId& GetFieldId(uint32_t idx) const {
Sebastien Hertzb24bd992013-08-02 15:19:09 +0200501 DCHECK_LT(idx, NumFieldIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700502 return field_ids_[idx];
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700503 }
504
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800505 uint32_t GetIndexForFieldId(const FieldId& field_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800506 CHECK_GE(&field_id, field_ids_) << GetLocation();
507 CHECK_LT(&field_id, field_ids_ + header_->field_ids_size_) << GetLocation();
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800508 return &field_id - field_ids_;
509 }
510
511 // Looks up a field by its declaring class, name and type
512 const FieldId* FindFieldId(const DexFile::TypeId& declaring_klass,
513 const DexFile::StringId& name,
514 const DexFile::TypeId& type) const;
515
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700516 // Returns the declaring class descriptor string of a field id.
517 const char* GetFieldDeclaringClassDescriptor(const FieldId& field_id) const {
Brian Carlstromb9edb842011-08-28 16:31:06 -0700518 const DexFile::TypeId& type_id = GetTypeId(field_id.class_idx_);
519 return GetTypeDescriptor(type_id);
520 }
521
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700522 // Returns the class descriptor string of a field id.
523 const char* GetFieldTypeDescriptor(const FieldId& field_id) const {
524 const DexFile::TypeId& type_id = GetTypeId(field_id.type_idx_);
525 return GetTypeDescriptor(type_id);
526 }
527
Brian Carlstromb9edb842011-08-28 16:31:06 -0700528 // Returns the name of a field id.
529 const char* GetFieldName(const FieldId& field_id) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700530 return StringDataByIdx(field_id.name_idx_);
Brian Carlstromb9edb842011-08-28 16:31:06 -0700531 }
532
Ian Rogers0571d352011-11-03 19:51:38 -0700533 // Returns the number of method identifiers in the .dex file.
534 size_t NumMethodIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700535 DCHECK(header_ != NULL) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700536 return header_->method_ids_size_;
537 }
538
539 // Returns the MethodId at the specified index.
540 const MethodId& GetMethodId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700541 DCHECK_LT(idx, NumMethodIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700542 return method_ids_[idx];
543 }
544
545 uint32_t GetIndexForMethodId(const MethodId& method_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800546 CHECK_GE(&method_id, method_ids_) << GetLocation();
547 CHECK_LT(&method_id, method_ids_ + header_->method_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700548 return &method_id - method_ids_;
549 }
550
Ian Rogers9b1a4f42011-11-14 18:35:10 -0800551 // Looks up a method by its declaring class, name and proto_id
552 const MethodId* FindMethodId(const DexFile::TypeId& declaring_klass,
553 const DexFile::StringId& name,
Ian Rogers0571d352011-11-03 19:51:38 -0700554 const DexFile::ProtoId& signature) const;
555
Brian Carlstrom6b4ef022011-10-23 14:59:04 -0700556 // Returns the declaring class descriptor string of a method id.
557 const char* GetMethodDeclaringClassDescriptor(const MethodId& method_id) const {
Brian Carlstrom7540ff42011-09-04 16:38:46 -0700558 const DexFile::TypeId& type_id = GetTypeId(method_id.class_idx_);
559 return GetTypeDescriptor(type_id);
560 }
561
jeffhao98eacac2011-09-14 16:11:53 -0700562 // Returns the prototype of a method id.
Brian Carlstromaded5f72011-10-07 17:15:04 -0700563 const ProtoId& GetMethodPrototype(const MethodId& method_id) const {
564 return GetProtoId(method_id.proto_idx_);
565 }
566
Ian Rogersd91d6d62013-09-25 20:26:14 -0700567 // Returns a representation of the signature of a method id.
568 const Signature GetMethodSignature(const MethodId& method_id) const;
jeffhao98eacac2011-09-14 16:11:53 -0700569
Brian Carlstrom7540ff42011-09-04 16:38:46 -0700570 // Returns the name of a method id.
571 const char* GetMethodName(const MethodId& method_id) const {
Ian Rogers0571d352011-11-03 19:51:38 -0700572 return StringDataByIdx(method_id.name_idx_);
Brian Carlstrom7540ff42011-09-04 16:38:46 -0700573 }
574
Ian Rogers0571d352011-11-03 19:51:38 -0700575 // Returns the shorty of a method id.
576 const char* GetMethodShorty(const MethodId& method_id) const {
577 return StringDataByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700578 }
Elliott Hughes45651fd2012-02-21 15:48:20 -0800579 const char* GetMethodShorty(const MethodId& method_id, uint32_t* length) const {
Ian Rogerscf5077a2013-10-31 12:37:54 -0700580 // Using the UTF16 length is safe here as shorties are guaranteed to be ASCII characters.
Ian Rogersdfb325e2013-10-30 01:00:44 -0700581 return StringDataAndUtf16LengthByIdx(GetProtoId(method_id.proto_idx_).shorty_idx_, length);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800582 }
Ian Rogers0571d352011-11-03 19:51:38 -0700583 // Returns the number of class definitions in the .dex file.
584 size_t NumClassDefs() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700585 DCHECK(header_ != NULL) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700586 return header_->class_defs_size_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700587 }
588
589 // Returns the ClassDef at the specified index.
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700590 const ClassDef& GetClassDef(uint16_t idx) const {
Sebastien Hertzb24bd992013-08-02 15:19:09 +0200591 DCHECK_LT(idx, NumClassDefs()) << GetLocation();
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700592 return class_defs_[idx];
593 }
594
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700595 uint16_t GetIndexForClassDef(const ClassDef& class_def) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800596 CHECK_GE(&class_def, class_defs_) << GetLocation();
597 CHECK_LT(&class_def, class_defs_ + header_->class_defs_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700598 return &class_def - class_defs_;
599 }
600
601 // Returns the class descriptor string of a class definition.
602 const char* GetClassDescriptor(const ClassDef& class_def) const {
603 return StringByTypeIdx(class_def.class_idx_);
604 }
605
606 // Looks up a class definition by its class descriptor.
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700607 const ClassDef* FindClassDef(const char* descriptor) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700608
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700609 // Looks up a class definition by its type index.
610 const ClassDef* FindClassDef(uint16_t type_idx) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700611
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700612 const TypeList* GetInterfacesList(const ClassDef& class_def) const {
613 if (class_def.interfaces_off_ == 0) {
614 return NULL;
615 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800616 const byte* addr = begin_ + class_def.interfaces_off_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700617 return reinterpret_cast<const TypeList*>(addr);
618 }
619 }
620
Ian Rogers0571d352011-11-03 19:51:38 -0700621 // Returns a pointer to the raw memory mapped class_data_item
622 const byte* GetClassData(const ClassDef& class_def) const {
623 if (class_def.class_data_off_ == 0) {
624 return NULL;
625 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800626 return begin_ + class_def.class_data_off_;
Ian Rogers0571d352011-11-03 19:51:38 -0700627 }
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700628 }
629
Ian Rogers0571d352011-11-03 19:51:38 -0700630 //
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800631 const CodeItem* GetCodeItem(const uint32_t code_off) const {
632 if (code_off == 0) {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700633 return NULL; // native or abstract method
634 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800635 const byte* addr = begin_ + code_off;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700636 return reinterpret_cast<const CodeItem*>(addr);
637 }
638 }
639
Ian Rogers0571d352011-11-03 19:51:38 -0700640 const char* GetReturnTypeDescriptor(const ProtoId& proto_id) const {
641 return StringByTypeIdx(proto_id.return_type_idx_);
642 }
643
644 // Returns the number of prototype identifiers in the .dex file.
645 size_t NumProtoIds() const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700646 DCHECK(header_ != NULL) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700647 return header_->proto_ids_size_;
648 }
649
650 // Returns the ProtoId at the specified index.
651 const ProtoId& GetProtoId(uint32_t idx) const {
Ian Rogers4f6ad8a2013-03-18 15:27:28 -0700652 DCHECK_LT(idx, NumProtoIds()) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700653 return proto_ids_[idx];
654 }
655
656 uint16_t GetIndexForProtoId(const ProtoId& proto_id) const {
Brian Carlstrom61e513c2011-12-09 15:30:06 -0800657 CHECK_GE(&proto_id, proto_ids_) << GetLocation();
658 CHECK_LT(&proto_id, proto_ids_ + header_->proto_ids_size_) << GetLocation();
Ian Rogers0571d352011-11-03 19:51:38 -0700659 return &proto_id - proto_ids_;
660 }
661
662 // Looks up a proto id for a given return type and signature type list
Ian Rogersd91d6d62013-09-25 20:26:14 -0700663 const ProtoId* FindProtoId(uint16_t return_type_idx,
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800664 const std::vector<uint16_t>& signature_type_idxs_) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700665
666 // Given a signature place the type ids into the given vector, returns true on success
Ian Rogersd91d6d62013-09-25 20:26:14 -0700667 bool CreateTypeList(const StringPiece& signature, uint16_t* return_type_idx,
668 std::vector<uint16_t>* param_type_idxs) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700669
Ian Rogersd91d6d62013-09-25 20:26:14 -0700670 // Create a Signature from the given string signature or return Signature::NoSignature if not
671 // possible.
672 const Signature CreateSignature(const StringPiece& signature) const;
Ian Rogers0571d352011-11-03 19:51:38 -0700673
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700674 // Returns the short form method descriptor for the given prototype.
675 const char* GetShorty(uint32_t proto_idx) const {
676 const ProtoId& proto_id = GetProtoId(proto_idx);
Ian Rogers0571d352011-11-03 19:51:38 -0700677 return StringDataByIdx(proto_id.shorty_idx_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700678 }
679
680 const TypeList* GetProtoParameters(const ProtoId& proto_id) const {
681 if (proto_id.parameters_off_ == 0) {
682 return NULL;
683 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800684 const byte* addr = begin_ + proto_id.parameters_off_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700685 return reinterpret_cast<const TypeList*>(addr);
686 }
687 }
688
Ian Rogers0571d352011-11-03 19:51:38 -0700689 const byte* GetEncodedStaticFieldValuesArray(const ClassDef& class_def) const {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700690 if (class_def.static_values_off_ == 0) {
691 return 0;
692 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800693 return begin_ + class_def.static_values_off_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700694 }
695 }
696
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800697 static const TryItem* GetTryItems(const CodeItem& code_item, uint32_t offset);
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700698
699 // Get the base of the encoded data for the given DexCode.
Ian Rogers0571d352011-11-03 19:51:38 -0700700 static const byte* GetCatchHandlerData(const CodeItem& code_item, uint32_t offset) {
701 const byte* handler_data =
702 reinterpret_cast<const byte*>(GetTryItems(code_item, code_item.tries_size_));
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700703 return handler_data + offset;
704 }
705
Ian Rogersdbbc99d2013-04-18 16:51:54 -0700706 // Find which try region is associated with the given address (ie dex pc). Returns -1 if none.
707 static int32_t FindTryItem(const CodeItem &code_item, uint32_t address);
708
709 // Find the handler offset associated with the given address (ie dex pc). Returns -1 if none.
710 static int32_t FindCatchHandlerOffset(const CodeItem &code_item, uint32_t address);
Shih-wei Liao2fb97532011-08-11 16:17:23 -0700711
Shih-wei Liao195487c2011-08-20 13:29:04 -0700712 // Get the pointer to the start of the debugging data
Ian Rogers0571d352011-11-03 19:51:38 -0700713 const byte* GetDebugInfoStream(const CodeItem* code_item) const {
Shih-wei Liao195487c2011-08-20 13:29:04 -0700714 if (code_item->debug_info_off_ == 0) {
715 return NULL;
716 } else {
Ian Rogers30fab402012-01-23 15:43:46 -0800717 return begin_ + code_item->debug_info_off_;
Shih-wei Liao195487c2011-08-20 13:29:04 -0700718 }
719 }
720
721 // Callback for "new position table entry".
722 // Returning true causes the decoder to stop early.
Elliott Hughes2435a572012-02-17 16:07:41 -0800723 typedef bool (*DexDebugNewPositionCb)(void* context, uint32_t address, uint32_t line_num);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700724
725 // Callback for "new locals table entry". "signature" is an empty string
726 // if no signature is available for an entry.
Elliott Hughes2435a572012-02-17 16:07:41 -0800727 typedef void (*DexDebugNewLocalCb)(void* context, uint16_t reg,
Elliott Hughes24edeb52012-06-18 15:29:46 -0700728 uint32_t start_address,
729 uint32_t end_address,
Brian Carlstrom40381fb2011-10-19 14:13:40 -0700730 const char* name,
731 const char* descriptor,
732 const char* signature);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700733
Elliott Hughes2435a572012-02-17 16:07:41 -0800734 static bool LineNumForPcCb(void* context, uint32_t address, uint32_t line_num);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700735
736 // Debug info opcodes and constants
737 enum {
738 DBG_END_SEQUENCE = 0x00,
739 DBG_ADVANCE_PC = 0x01,
740 DBG_ADVANCE_LINE = 0x02,
741 DBG_START_LOCAL = 0x03,
742 DBG_START_LOCAL_EXTENDED = 0x04,
743 DBG_END_LOCAL = 0x05,
744 DBG_RESTART_LOCAL = 0x06,
745 DBG_SET_PROLOGUE_END = 0x07,
746 DBG_SET_EPILOGUE_BEGIN = 0x08,
747 DBG_SET_FILE = 0x09,
748 DBG_FIRST_SPECIAL = 0x0a,
749 DBG_LINE_BASE = -4,
750 DBG_LINE_RANGE = 15,
751 };
752
753 struct LocalInfo {
Ian Rogersca190662012-06-26 15:45:57 -0700754 LocalInfo()
755 : name_(NULL), descriptor_(NULL), signature_(NULL), start_address_(0), is_live_(false) {}
Shih-wei Liao195487c2011-08-20 13:29:04 -0700756
Ian Rogers0571d352011-11-03 19:51:38 -0700757 const char* name_; // E.g., list
758 const char* descriptor_; // E.g., Ljava/util/LinkedList;
759 const char* signature_; // E.g., java.util.LinkedList<java.lang.Integer>
760 uint16_t start_address_; // PC location where the local is first defined.
761 bool is_live_; // Is the local defined and live.
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700762
763 private:
764 DISALLOW_COPY_AND_ASSIGN(LocalInfo);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700765 };
766
767 struct LineNumFromPcContext {
Ian Rogersca190662012-06-26 15:45:57 -0700768 LineNumFromPcContext(uint32_t address, uint32_t line_num)
769 : address_(address), line_num_(line_num) {}
Shih-wei Liao195487c2011-08-20 13:29:04 -0700770 uint32_t address_;
771 uint32_t line_num_;
Brian Carlstromd2fbb2b2011-08-23 11:57:08 -0700772 private:
773 DISALLOW_COPY_AND_ASSIGN(LineNumFromPcContext);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700774 };
775
Elliott Hughes2435a572012-02-17 16:07:41 -0800776 void InvokeLocalCbIfLive(void* context, int reg, uint32_t end_address,
Brian Carlstrom78128a62011-09-15 17:21:19 -0700777 LocalInfo* local_in_reg, DexDebugNewLocalCb local_cb) const {
Shih-wei Liao195487c2011-08-20 13:29:04 -0700778 if (local_cb != NULL && local_in_reg[reg].is_live_) {
Elliott Hughes2435a572012-02-17 16:07:41 -0800779 local_cb(context, reg, local_in_reg[reg].start_address_, end_address,
Elliott Hughesdbb40792011-11-18 17:05:22 -0800780 local_in_reg[reg].name_, local_in_reg[reg].descriptor_,
781 local_in_reg[reg].signature_ != NULL ? local_in_reg[reg].signature_ : "");
Shih-wei Liao195487c2011-08-20 13:29:04 -0700782 }
783 }
784
785 // Determine the source file line number based on the program counter.
786 // "pc" is an offset, in 16-bit units, from the start of the method's code.
787 //
788 // Returns -1 if no match was found (possibly because the source files were
789 // compiled without "-g", so no line number information is present).
790 // Returns -2 for native methods (as expected in exception traces).
791 //
792 // This is used by runtime; therefore use art::Method not art::DexFile::Method.
Brian Carlstromea46f952013-07-30 01:26:50 -0700793 int32_t GetLineNumFromPC(const mirror::ArtMethod* method, uint32_t rel_pc) const
Ian Rogersb726dcb2012-09-05 08:57:23 -0700794 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Shih-wei Liao195487c2011-08-20 13:29:04 -0700795
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800796 void DecodeDebugInfo(const CodeItem* code_item, bool is_static, uint32_t method_idx,
Elliott Hughes2435a572012-02-17 16:07:41 -0800797 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb,
798 void* context) const;
Shih-wei Liao195487c2011-08-20 13:29:04 -0700799
Ian Rogers0571d352011-11-03 19:51:38 -0700800 const char* GetSourceFile(const ClassDef& class_def) const {
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700801 if (class_def.source_file_idx_ == 0xffffffff) {
802 return NULL;
803 } else {
Ian Rogers0571d352011-11-03 19:51:38 -0700804 return StringDataByIdx(class_def.source_file_idx_);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700805 }
Carl Shapiro0e5d75d2011-07-06 18:28:37 -0700806 }
807
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800808 int GetPermissions() const;
Ian Rogers1c849e52012-06-28 14:00:33 -0700809
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200810 bool IsReadOnly() const;
811
Brian Carlstrome0948e12013-08-29 09:36:15 -0700812 bool EnableWrite() const;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200813
Brian Carlstrome0948e12013-08-29 09:36:15 -0700814 bool DisableWrite() const;
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200815
Ian Rogers8b2c0b92013-09-19 02:56:49 -0700816 const byte* Begin() const {
817 return begin_;
818 }
819
820 size_t Size() const {
821 return size_;
822 }
823
Carl Shapiro1fb86202011-06-27 17:43:13 -0700824 private:
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700825 // Opens a .dex file
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700826 static const DexFile* OpenFile(int fd, const char* location, bool verify, std::string* error_msg);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700827
828 // Opens a dex file from within a .jar, .zip, or .apk file
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700829 static const DexFile* OpenZip(int fd, const std::string& location, std::string* error_msg);
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700830
Brian Carlstrom89521892011-12-07 22:05:07 -0800831 // Opens a .dex file at the given address backed by a MemMap
832 static const DexFile* OpenMemory(const std::string& location,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800833 uint32_t location_checksum,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700834 MemMap* mem_map,
835 std::string* error_msg);
Brian Carlstrom89521892011-12-07 22:05:07 -0800836
837 // Opens a .dex file at the given address, optionally backed by a MemMap
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700838 static const DexFile* OpenMemory(const byte* dex_file,
jeffhaof6174e82012-01-31 16:14:17 -0800839 size_t size,
Brian Carlstrom58ae9412011-10-04 00:56:06 -0700840 const std::string& location,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800841 uint32_t location_checksum,
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700842 MemMap* mem_map,
843 std::string* error_msg);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700844
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800845 DexFile(const byte* base, size_t size,
Brian Carlstrom28db0122012-10-18 16:20:41 -0700846 const std::string& location,
847 uint32_t location_checksum,
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800848 MemMap* mem_map)
Ian Rogers30fab402012-01-23 15:43:46 -0800849 : begin_(base),
jeffhaof6174e82012-01-31 16:14:17 -0800850 size_(size),
Brian Carlstroma663ea52011-08-19 23:33:41 -0700851 location_(location),
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800852 location_checksum_(location_checksum),
Brian Carlstrom33f741e2011-10-03 11:24:05 -0700853 mem_map_(mem_map),
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200854 modification_lock("DEX modification lock"),
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700855 header_(0),
856 string_ids_(0),
857 type_ids_(0),
858 field_ids_(0),
859 method_ids_(0),
860 proto_ids_(0),
Brian Carlstroma663ea52011-08-19 23:33:41 -0700861 class_defs_(0) {
Ian Rogers30fab402012-01-23 15:43:46 -0800862 CHECK(begin_ != NULL) << GetLocation();
jeffhaof6174e82012-01-31 16:14:17 -0800863 CHECK_GT(size_, 0U) << GetLocation();
864 }
865
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700866 // Top-level initializer that calls other Init methods.
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700867 bool Init(std::string* error_msg);
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700868
869 // Caches pointers into to the various file sections.
870 void InitMembers();
871
Brian Carlstrom6e3b1d92012-01-11 01:36:32 -0800872 // Returns true if the header magic and version numbers are of the expected values.
Ian Rogers8d31bbd2013-10-13 10:44:14 -0700873 bool CheckMagicAndVersion(std::string* error_msg) const;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700874
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800875 void DecodeDebugInfo0(const CodeItem* code_item, bool is_static, uint32_t method_idx,
Elliott Hughes2435a572012-02-17 16:07:41 -0800876 DexDebugNewPositionCb position_cb, DexDebugNewLocalCb local_cb,
877 void* context, const byte* stream, LocalInfo* local_in_reg) const;
Elliott Hughes03181a82011-11-17 17:22:21 -0800878
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700879 // The base address of the memory mapping.
Ian Rogers62d6c772013-02-27 08:32:07 -0800880 const byte* const begin_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700881
882 // The size of the underlying memory allocation in bytes.
Ian Rogers62d6c772013-02-27 08:32:07 -0800883 const size_t size_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700884
Elliott Hughes64bf5a32011-09-20 14:43:12 -0700885 // Typically the dex file name when available, alternatively some identifying string.
Brian Carlstroma663ea52011-08-19 23:33:41 -0700886 //
887 // The ClassLinker will use this to match DexFiles the boot class
888 // path to DexCache::GetLocation when loading from an image.
889 const std::string location_;
890
Brian Carlstrom5b332c82012-02-01 15:02:31 -0800891 const uint32_t location_checksum_;
892
Brian Carlstrom33f741e2011-10-03 11:24:05 -0700893 // Manages the underlying memory allocation.
894 UniquePtr<MemMap> mem_map_;
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700895
Sebastien Hertz2d6ba512013-05-17 11:31:37 +0200896 // The DEX-to-DEX compiler uses this lock to ensure thread safety when
897 // enabling write access to a read-only DEX file.
898 // TODO: move to Locks::dex_file_modification_lock.
899 Mutex modification_lock;
900
Brian Carlstrom7e49dca2011-07-22 18:07:34 -0700901 // Points to the header section.
902 const Header* header_;
903
904 // Points to the base of the string identifier list.
905 const StringId* string_ids_;
906
907 // Points to the base of the type identifier list.
908 const TypeId* type_ids_;
909
910 // Points to the base of the field identifier list.
911 const FieldId* field_ids_;
912
913 // Points to the base of the method identifier list.
914 const MethodId* method_ids_;
915
916 // Points to the base of the prototype identifier list.
917 const ProtoId* proto_ids_;
918
919 // Points to the base of the class definition list.
920 const ClassDef* class_defs_;
Carl Shapiro1fb86202011-06-27 17:43:13 -0700921};
922
Ian Rogers0571d352011-11-03 19:51:38 -0700923// Iterate over a dex file's ProtoId's paramters
924class DexFileParameterIterator {
925 public:
926 DexFileParameterIterator(const DexFile& dex_file, const DexFile::ProtoId& proto_id)
927 : dex_file_(dex_file), size_(0), pos_(0) {
928 type_list_ = dex_file_.GetProtoParameters(proto_id);
929 if (type_list_ != NULL) {
930 size_ = type_list_->Size();
931 }
932 }
933 bool HasNext() const { return pos_ < size_; }
934 void Next() { ++pos_; }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800935 uint16_t GetTypeIdx() {
Ian Rogers0571d352011-11-03 19:51:38 -0700936 return type_list_->GetTypeItem(pos_).type_idx_;
937 }
938 const char* GetDescriptor() {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800939 return dex_file_.StringByTypeIdx(GetTypeIdx());
Ian Rogers0571d352011-11-03 19:51:38 -0700940 }
941 private:
942 const DexFile& dex_file_;
943 const DexFile::TypeList* type_list_;
944 uint32_t size_;
945 uint32_t pos_;
946 DISALLOW_IMPLICIT_CONSTRUCTORS(DexFileParameterIterator);
947};
948
Ian Rogersd91d6d62013-09-25 20:26:14 -0700949// Abstract the signature of a method.
950class Signature {
951 public:
952 std::string ToString() const;
953
954 static Signature NoSignature() {
955 return Signature();
956 }
957
Ian Rogersdfb325e2013-10-30 01:00:44 -0700958 bool operator==(const Signature& rhs) const;
Ian Rogersd91d6d62013-09-25 20:26:14 -0700959 bool operator!=(const Signature& rhs) const {
960 return !(*this == rhs);
961 }
962
963 bool operator==(const StringPiece& rhs) const {
964 // TODO: Avoid temporary string allocation.
965 return ToString() == rhs;
966 }
967
968 private:
969 Signature(const DexFile* dex, const DexFile::ProtoId& proto) : dex_file_(dex), proto_id_(&proto) {
970 }
971
972 Signature() : dex_file_(nullptr), proto_id_(nullptr) {
973 }
974
975 friend class DexFile;
976
977 const DexFile* const dex_file_;
978 const DexFile::ProtoId* const proto_id_;
979};
980std::ostream& operator<<(std::ostream& os, const Signature& sig);
981
Ian Rogers0571d352011-11-03 19:51:38 -0700982// Iterate and decode class_data_item
983class ClassDataItemIterator {
984 public:
985 ClassDataItemIterator(const DexFile& dex_file, const byte* raw_class_data_item)
986 : dex_file_(dex_file), pos_(0), ptr_pos_(raw_class_data_item), last_idx_(0) {
987 ReadClassDataHeader();
988 if (EndOfInstanceFieldsPos() > 0) {
989 ReadClassDataField();
990 } else if (EndOfVirtualMethodsPos() > 0) {
991 ReadClassDataMethod();
992 }
993 }
994 uint32_t NumStaticFields() const {
995 return header_.static_fields_size_;
996 }
997 uint32_t NumInstanceFields() const {
998 return header_.instance_fields_size_;
999 }
1000 uint32_t NumDirectMethods() const {
1001 return header_.direct_methods_size_;
1002 }
1003 uint32_t NumVirtualMethods() const {
1004 return header_.virtual_methods_size_;
1005 }
1006 bool HasNextStaticField() const {
1007 return pos_ < EndOfStaticFieldsPos();
1008 }
1009 bool HasNextInstanceField() const {
1010 return pos_ >= EndOfStaticFieldsPos() && pos_ < EndOfInstanceFieldsPos();
1011 }
1012 bool HasNextDirectMethod() const {
1013 return pos_ >= EndOfInstanceFieldsPos() && pos_ < EndOfDirectMethodsPos();
1014 }
1015 bool HasNextVirtualMethod() const {
1016 return pos_ >= EndOfDirectMethodsPos() && pos_ < EndOfVirtualMethodsPos();
1017 }
1018 bool HasNext() const {
1019 return pos_ < EndOfVirtualMethodsPos();
1020 }
Ian Rogers637c65b2013-05-31 11:46:00 -07001021 inline void Next() {
Ian Rogers0571d352011-11-03 19:51:38 -07001022 pos_++;
1023 if (pos_ < EndOfStaticFieldsPos()) {
1024 last_idx_ = GetMemberIndex();
1025 ReadClassDataField();
1026 } else if (pos_ == EndOfStaticFieldsPos() && NumInstanceFields() > 0) {
1027 last_idx_ = 0; // transition to next array, reset last index
1028 ReadClassDataField();
1029 } else if (pos_ < EndOfInstanceFieldsPos()) {
1030 last_idx_ = GetMemberIndex();
1031 ReadClassDataField();
1032 } else if (pos_ == EndOfInstanceFieldsPos() && NumDirectMethods() > 0) {
1033 last_idx_ = 0; // transition to next array, reset last index
1034 ReadClassDataMethod();
1035 } else if (pos_ < EndOfDirectMethodsPos()) {
1036 last_idx_ = GetMemberIndex();
1037 ReadClassDataMethod();
1038 } else if (pos_ == EndOfDirectMethodsPos() && NumVirtualMethods() > 0) {
1039 last_idx_ = 0; // transition to next array, reset last index
1040 ReadClassDataMethod();
1041 } else if (pos_ < EndOfVirtualMethodsPos()) {
1042 last_idx_ = GetMemberIndex();
1043 ReadClassDataMethod();
1044 } else {
1045 DCHECK(!HasNext());
1046 }
1047 }
1048 uint32_t GetMemberIndex() const {
1049 if (pos_ < EndOfInstanceFieldsPos()) {
1050 return last_idx_ + field_.field_idx_delta_;
1051 } else {
Sebastien Hertzb24bd992013-08-02 15:19:09 +02001052 DCHECK_LT(pos_, EndOfVirtualMethodsPos());
Ian Rogers0571d352011-11-03 19:51:38 -07001053 return last_idx_ + method_.method_idx_delta_;
1054 }
1055 }
1056 uint32_t GetMemberAccessFlags() const {
1057 if (pos_ < EndOfInstanceFieldsPos()) {
1058 return field_.access_flags_;
1059 } else {
Sebastien Hertzb24bd992013-08-02 15:19:09 +02001060 DCHECK_LT(pos_, EndOfVirtualMethodsPos());
Ian Rogers0571d352011-11-03 19:51:38 -07001061 return method_.access_flags_;
1062 }
1063 }
Ian Rogers08f753d2012-08-24 14:35:25 -07001064 InvokeType GetMethodInvokeType(const DexFile::ClassDef& class_def) const {
1065 if (HasNextDirectMethod()) {
Brian Carlstromdf629502013-07-17 22:39:56 -07001066 if ((GetMemberAccessFlags() & kAccStatic) != 0) {
Ian Rogers08f753d2012-08-24 14:35:25 -07001067 return kStatic;
1068 } else {
1069 return kDirect;
1070 }
1071 } else {
Sebastien Hertzb24bd992013-08-02 15:19:09 +02001072 DCHECK_EQ(GetMemberAccessFlags() & kAccStatic, 0U);
Ian Rogers08f753d2012-08-24 14:35:25 -07001073 if ((class_def.access_flags_ & kAccInterface) != 0) {
1074 return kInterface;
1075 } else if ((GetMemberAccessFlags() & kAccConstructor) != 0) {
1076 return kSuper;
1077 } else {
1078 return kVirtual;
1079 }
1080 }
1081 }
Ian Rogers0571d352011-11-03 19:51:38 -07001082 const DexFile::CodeItem* GetMethodCodeItem() const {
1083 return dex_file_.GetCodeItem(method_.code_off_);
1084 }
1085 uint32_t GetMethodCodeItemOffset() const {
1086 return method_.code_off_;
1087 }
jeffhao10037c82012-01-23 15:06:23 -08001088 const byte* EndDataPointer() const {
1089 CHECK(!HasNext());
1090 return ptr_pos_;
1091 }
Elliott Hughesa21039c2012-06-21 12:09:25 -07001092
Ian Rogers0571d352011-11-03 19:51:38 -07001093 private:
1094 // A dex file's class_data_item is leb128 encoded, this structure holds a decoded form of the
1095 // header for a class_data_item
1096 struct ClassDataHeader {
1097 uint32_t static_fields_size_; // the number of static fields
1098 uint32_t instance_fields_size_; // the number of instance fields
1099 uint32_t direct_methods_size_; // the number of direct methods
1100 uint32_t virtual_methods_size_; // the number of virtual methods
1101 } header_;
1102
1103 // Read and decode header from a class_data_item stream into header
1104 void ReadClassDataHeader();
1105
1106 uint32_t EndOfStaticFieldsPos() const {
1107 return header_.static_fields_size_;
1108 }
1109 uint32_t EndOfInstanceFieldsPos() const {
1110 return EndOfStaticFieldsPos() + header_.instance_fields_size_;
1111 }
1112 uint32_t EndOfDirectMethodsPos() const {
1113 return EndOfInstanceFieldsPos() + header_.direct_methods_size_;
1114 }
1115 uint32_t EndOfVirtualMethodsPos() const {
1116 return EndOfDirectMethodsPos() + header_.virtual_methods_size_;
1117 }
1118
1119 // A decoded version of the field of a class_data_item
1120 struct ClassDataField {
1121 uint32_t field_idx_delta_; // delta of index into the field_ids array for FieldId
1122 uint32_t access_flags_; // access flags for the field
1123 ClassDataField() : field_idx_delta_(0), access_flags_(0) {}
Elliott Hughesa21039c2012-06-21 12:09:25 -07001124
Ian Rogers0571d352011-11-03 19:51:38 -07001125 private:
1126 DISALLOW_COPY_AND_ASSIGN(ClassDataField);
Elliott Hughesee0fa762012-03-26 17:12:41 -07001127 };
1128 ClassDataField field_;
Ian Rogers0571d352011-11-03 19:51:38 -07001129
1130 // Read and decode a field from a class_data_item stream into field
1131 void ReadClassDataField();
1132
1133 // A decoded version of the method of a class_data_item
1134 struct ClassDataMethod {
1135 uint32_t method_idx_delta_; // delta of index into the method_ids array for MethodId
1136 uint32_t access_flags_;
1137 uint32_t code_off_;
1138 ClassDataMethod() : method_idx_delta_(0), access_flags_(0), code_off_(0) {}
Elliott Hughesa21039c2012-06-21 12:09:25 -07001139
Ian Rogers0571d352011-11-03 19:51:38 -07001140 private:
1141 DISALLOW_COPY_AND_ASSIGN(ClassDataMethod);
Elliott Hughesee0fa762012-03-26 17:12:41 -07001142 };
1143 ClassDataMethod method_;
Ian Rogers0571d352011-11-03 19:51:38 -07001144
1145 // Read and decode a method from a class_data_item stream into method
1146 void ReadClassDataMethod();
1147
1148 const DexFile& dex_file_;
1149 size_t pos_; // integral number of items passed
1150 const byte* ptr_pos_; // pointer into stream of class_data_item
1151 uint32_t last_idx_; // last read field or method index to apply delta to
1152 DISALLOW_IMPLICIT_CONSTRUCTORS(ClassDataItemIterator);
1153};
1154
Ian Rogers0571d352011-11-03 19:51:38 -07001155class EncodedStaticFieldValueIterator {
1156 public:
Mathieu Chartier590fee92013-09-13 13:46:47 -07001157 EncodedStaticFieldValueIterator(const DexFile& dex_file, SirtRef<mirror::DexCache>* dex_cache,
1158 SirtRef<mirror::ClassLoader>* class_loader,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001159 ClassLinker* linker, const DexFile::ClassDef& class_def)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001160 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001161
Brian Carlstromea46f952013-07-30 01:26:50 -07001162 void ReadValueToField(mirror::ArtField* field) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0571d352011-11-03 19:51:38 -07001163
1164 bool HasNext() { return pos_ < array_size_; }
1165
1166 void Next();
Elliott Hughesa21039c2012-06-21 12:09:25 -07001167
Ian Rogers0571d352011-11-03 19:51:38 -07001168 enum ValueType {
1169 kByte = 0x00,
1170 kShort = 0x02,
1171 kChar = 0x03,
1172 kInt = 0x04,
1173 kLong = 0x06,
1174 kFloat = 0x10,
1175 kDouble = 0x11,
1176 kString = 0x17,
1177 kType = 0x18,
1178 kField = 0x19,
1179 kMethod = 0x1a,
1180 kEnum = 0x1b,
1181 kArray = 0x1c,
1182 kAnnotation = 0x1d,
1183 kNull = 0x1e,
1184 kBoolean = 0x1f
1185 };
1186
Brian Carlstrom88f36542012-10-16 23:24:21 -07001187 private:
Ian Rogers0571d352011-11-03 19:51:38 -07001188 static const byte kEncodedValueTypeMask = 0x1f; // 0b11111
1189 static const byte kEncodedValueArgShift = 5;
1190
1191 const DexFile& dex_file_;
Mathieu Chartier590fee92013-09-13 13:46:47 -07001192 SirtRef<mirror::DexCache>* const dex_cache_; // Dex cache to resolve literal objects.
1193 SirtRef<mirror::ClassLoader>* const class_loader_; // ClassLoader to resolve types.
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001194 ClassLinker* linker_; // Linker to resolve literal objects.
1195 size_t array_size_; // Size of array.
1196 size_t pos_; // Current position.
1197 const byte* ptr_; // Pointer into encoded data array.
1198 ValueType type_; // Type of current encoded value.
1199 jvalue jval_; // Value of current encoded value.
Ian Rogers0571d352011-11-03 19:51:38 -07001200 DISALLOW_IMPLICIT_CONSTRUCTORS(EncodedStaticFieldValueIterator);
1201};
Brian Carlstrom88f36542012-10-16 23:24:21 -07001202std::ostream& operator<<(std::ostream& os, const EncodedStaticFieldValueIterator::ValueType& code);
Ian Rogers0571d352011-11-03 19:51:38 -07001203
1204class CatchHandlerIterator {
1205 public:
1206 CatchHandlerIterator(const DexFile::CodeItem& code_item, uint32_t address);
Logan Chien736df022012-04-27 16:25:57 +08001207
1208 CatchHandlerIterator(const DexFile::CodeItem& code_item,
1209 const DexFile::TryItem& try_item);
1210
Ian Rogers0571d352011-11-03 19:51:38 -07001211 explicit CatchHandlerIterator(const byte* handler_data) {
1212 Init(handler_data);
1213 }
1214
1215 uint16_t GetHandlerTypeIndex() const {
1216 return handler_.type_idx_;
1217 }
1218 uint32_t GetHandlerAddress() const {
1219 return handler_.address_;
1220 }
1221 void Next();
1222 bool HasNext() const {
1223 return remaining_count_ != -1 || catch_all_;
1224 }
1225 // End of this set of catch blocks, convenience method to locate next set of catch blocks
1226 const byte* EndDataPointer() const {
1227 CHECK(!HasNext());
1228 return current_data_;
1229 }
Elliott Hughesa21039c2012-06-21 12:09:25 -07001230
Ian Rogers0571d352011-11-03 19:51:38 -07001231 private:
Logan Chien736df022012-04-27 16:25:57 +08001232 void Init(const DexFile::CodeItem& code_item, int32_t offset);
Ian Rogers0571d352011-11-03 19:51:38 -07001233 void Init(const byte* handler_data);
1234
1235 struct CatchHandlerItem {
1236 uint16_t type_idx_; // type index of the caught exception type
1237 uint32_t address_; // handler address
1238 } handler_;
1239 const byte *current_data_; // the current handler in dex file.
1240 int32_t remaining_count_; // number of handlers not read.
1241 bool catch_all_; // is there a handler that will catch all exceptions in case
1242 // that all typed handler does not match.
1243};
1244
Carl Shapiro1fb86202011-06-27 17:43:13 -07001245} // namespace art
1246
Brian Carlstromfc0e3212013-07-17 14:40:12 -07001247#endif // ART_RUNTIME_DEX_FILE_H_