Mercurial > paraspace

comparison paraspace/dexfile.py @ 13:c05fac334ab1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
compute size for objects
author Thinker K.F. Li <thinker@codemud.net>
date Wed, 25 May 2011 21:47:15 +0800
parents 8101024c942b
children f5728c6868b2
comparison
equal deleted inserted replaced
12:8101024c942b 13:c05fac334ab1
1 import itertools
2
1 class _DEX_header(object): 3 class _DEX_header(object):
2 magic = None # 0x00, 8 bytes 4 magic = None # 0x00, 8 bytes
3 checksum = None # 0x08, 4 bytes 5 checksum = None # 0x08, 4 bytes
4 signature = None # 0x0c, 20 bytes 6 signature = None # 0x0c, 20 bytes
5 fileSize = None # 0x20, 4 bytes 7 fileSize = None # 0x20, 4 bytes
28 'linkSize linkOff mapOff stringIdsSize stringIdsOff typeIdsSize ' \ 30 'linkSize linkOff mapOff stringIdsSize stringIdsOff typeIdsSize ' \
29 'typeIdsOff protoIdsSize protoIdsOff fieldIdsSize fieldIdsOff ' \ 31 'typeIdsOff protoIdsSize protoIdsOff fieldIdsSize fieldIdsOff ' \
30 'methodIdsSize methodIdsOff classDefsSize classDefsOff ' \ 32 'methodIdsSize methodIdsOff classDefsSize classDefsOff ' \
31 'dataSize dataOff'.split() 33 'dataSize dataOff'.split()
32 34
35 data_size = 0x70
36
33 def parse(self, data): 37 def parse(self, data):
34 self.magic = data[:8] 38 self.magic = data[:8]
35 self.checksum = data[8: 0x0c] 39 self.checksum = data[8: 0x0c]
36 self.signature = data[0x0c: 0x20] 40 self.signature = data[0x0c: 0x20]
37 41
109 113
110 nbytes = sh / 7 114 nbytes = sh / 7
111 return v, nbytes 115 return v, nbytes
112 116
113 117
118 def _to_uleb128(v):
119 assert v >= 0
120
121 data = ''
122 while True:
123 if v > 0x7f:
124 data = data + chr((v & 0x7f) | 0x80)
125 else:
126 data = data + chr(v & 0x7f)
127 break
128 v = v >> 7
129 pass
130
131 return data
132
133
134 def _uleb128_sz(v):
135 return len(_to_uleb128(v))
136
137
114 def _leb128(data): 138 def _leb128(data):
115 v, sh = _uleb128(data) 139 v, sh = _uleb128(data)
116 if v & (1 << (sh * 7 - 1)): 140 if v & (1 << (sh * 7 - 1)):
117 v = -((1 << (sh * 7)) - v) 141 v = -((1 << (sh * 7)) - v)
118 pass 142 pass
119 return v, sh 143 return v, sh
144
145
146 def _to_leb128(v):
147 data = ''
148 while True:
149 if v > 0x3f or v < ~0x3f:
150 data = data + chr((v & 0x7f) | 0x80)
151 else:
152 data = data + chr(v & 0x7f)
153 break
154 v = v >> 7
155 pass
156 return data
157
158
159 def _leb128_sz(v):
160 return len(_to_leb128(v))
161
162
163 def _compute_sz(o):
164 if hasattr(o, 'compute_size'):
165 o.compute_size()
166 pass
167 return o.data_size
168
169
170 def _sum_data_size(obj_list):
171 obj_sizes = itertools.imap(_compute_sz, obj_list)
172 total = sum(obj_sizes)
173 return total
120 174
121 175
122 class _DEX_MapItem(object): 176 class _DEX_MapItem(object):
123 type = None # 2 bytes 177 type = None # 2 bytes
124 unused = None # 2 bytes 178 unused = None # 2 bytes
264 self.virtualMethodsSize, sh = _uleb128(data[off:off + 10]) 318 self.virtualMethodsSize, sh = _uleb128(data[off:off + 10])
265 sz = sz + sh 319 sz = sz + sh
266 320
267 self.data_size = sz 321 self.data_size = sz
268 pass 322 pass
323
324 def compute_size(self):
325 self.data_size = \
326 _uleb128_sz(self.staticFieldsSize) + \
327 _uleb128_sz(self.instanceFieldsSize) + \
328 _uleb128_sz(self.directMethodsSize) + \
329 _uleb128_sz(self.virtualMethodsSize)
330 pass
269 pass 331 pass
270 332
271 333
272 class _DEX_Field(object): 334 class _DEX_Field(object):
273 fieldIdx = None 335 fieldIdx = None
282 self.accessFlags, sh = _uleb128(data[off:off + 10]) 344 self.accessFlags, sh = _uleb128(data[off:off + 10])
283 sz = sz + sh 345 sz = sz + sh
284 346
285 self.data_size = sz 347 self.data_size = sz
286 pass 348 pass
349
350 def compute_size(self):
351 self.data_size = \
352 _uleb128_sz(self.fieldIdx) + \
353 _uleb128_sz(self.accessFlags)
354 pass
287 pass 355 pass
288 356
289 357
290 class _DEX_Method(object): 358 class _DEX_Method(object):
291 methodIdx = None 359 methodIdx = None
305 373
306 self.codeOff, sh = _uleb128(data[off:off + 10]) 374 self.codeOff, sh = _uleb128(data[off:off + 10])
307 sz = sz + sh 375 sz = sz + sh
308 376
309 self.data_size = sz 377 self.data_size = sz
378 pass
379
380 def compute_size(self):
381 self.data_size = \
382 _uleb128_sz(self.methodIdx) + \
383 _uleb128_sz(self.accessFlags) + \
384 _uleb128_sz(self.codeOff)
310 pass 385 pass
311 pass 386 pass
312 387
313 class _DEX_ClassData(object): 388 class _DEX_ClassData(object):
314 header = None # DexClassDataHeader 389 header = None # DexClassDataHeader
318 virtualMethods = None # DexMethod* 393 virtualMethods = None # DexMethod*
319 394
320 data_size = None 395 data_size = None
321 396
322 def parse(self, data, off): 397 def parse(self, data, off):
398 moff = man_off(off)
399
323 header = _DEX_ClassDataHeader() 400 header = _DEX_ClassDataHeader()
324 header.parse(data, off) 401 header.parse(data, moff())
325 self.header = header 402 self.header = header
326 403 moff(header.data_size)
327 cur_off = [off + header.data_size]
328 404
329 def parse_field(): 405 def parse_field():
330 field = _DEX_Field() 406 field = _DEX_Field()
331 off = cur_off[0] 407 field.parse(data, moff())
332 field.parse(data, off) 408 moff(field.data_size)
333 cur_off[0] = cur_off[0] + field.data_size
334 409
335 # 410 #
336 # field index depends previous one to reduce size 411 # field index depends previous one to reduce size
337 # 412 #
338 field.fieldIdx = field.fieldIdx + idx[0] 413 field.fieldIdx = field.fieldIdx + idx[0]
340 415
341 return field 416 return field
342 417
343 def parse_method(): 418 def parse_method():
344 method = _DEX_Method() 419 method = _DEX_Method()
345 off = cur_off[0] 420 method.parse(data, moff())
346 method.parse(data, off) 421 moff(method.data_size)
347 cur_off[0] = cur_off[0] + method.data_size
348 422
349 # 423 #
350 # method index depends previous one to reduce size 424 # method index depends previous one to reduce size
351 # 425 #
352 method.methodIdx = method.methodIdx + idx[0] 426 method.methodIdx = method.methodIdx + idx[0]
365 for i in range(header.directMethodsSize)] 439 for i in range(header.directMethodsSize)]
366 idx = [0] 440 idx = [0]
367 self.virtualMethods = [parse_method() 441 self.virtualMethods = [parse_method()
368 for i in range(header.virtualMethodsSize)] 442 for i in range(header.virtualMethodsSize)]
369 443
370 self.data_size = cur_off[0] - off 444 self.data_size = moff() - off
445 pass
446
447 def compute_size(self):
448 sz = self.header.data_size
449 sz = sz + _sum_data_size(itertools.chain(self.staticFields,
450 self.instanceFields,
451 self.directMethods,
452 self.virtualMethods))
453
454 self.data_size = sz
371 pass 455 pass
372 pass 456 pass
373 457
374 458
375 class _DEX_TypeItem(object): 459 class _DEX_TypeItem(object):
403 for i in range(size)] 487 for i in range(size)]
404 488
405 self.typeItems = typeItems 489 self.typeItems = typeItems
406 self.data_size = moff() - off 490 self.data_size = moff() - off
407 pass 491 pass
492
493 def compute_size(self):
494 size = 4 + _sum_data_size(self.typeItems)
495
496 self.data_size = size
497 pass
408 pass 498 pass
409 499
410 500
411 class _DEX_TypeLists(object): 501 class _DEX_TypeLists(object):
412 typeLists = None 502 typeLists = None
413 503
414 data_size = None 504 data_size = None
415 505
416 def parse(self, num, data, off): 506 def parse(self, num, data, off):
507 moff = man_off(off)
508
417 def parse(): 509 def parse():
418 off = (cur_off[0] + 3) & ~0x3 # type list must aligned for 4 bytes 510 moff.off = (moff(0) + 3) & ~0x3 # aligned for 4 bytes
419 typeList = _DEX_TypeList() 511 typeList = _DEX_TypeList()
420 typeList.parse(data, off) 512 typeList.parse(data, moff())
421 cur_off[0] = off + typeList.data_size 513 moff(typeList.data_size)
422 514
423 return typeList 515 return typeList
424 516
425 cur_off = [off]
426 typeLists = [parse() for i in range(num)] 517 typeLists = [parse() for i in range(num)]
427 518
428 self.typeLists = typeLists 519 self.typeLists = typeLists
429 self.data_size = cur_off[0] - off 520 self.data_size = moff(0) - off
521 pass
522
523 def compute_size(self):
524 def compute_align(prev, cur):
525 v = ((prev + 3) & ~0x3) + cur
526 return v
527
528 sizes = itertools.imap(_compute_sz, self.typeLists)
529 size = reduce(compute_align, sizes)
530
531 self.data_size = size
430 pass 532 pass
431 pass 533 pass
432 534
433 535
434 class _DEX_Try(object): 536 class _DEX_Try(object):
454 address = None 556 address = None
455 557
456 data_size = None 558 data_size = None
457 559
458 def parse(self, data, off): 560 def parse(self, data, off):
459 cur_off = off 561 moff = man_off(off)
460 self.typeIdx, sh = _uleb128(data[cur_off:cur_off + 5]) 562 self.typeIdx, sh = _uleb128(data[moff():moff() + 5])
461 cur_off = cur_off + sh 563 moff(sh)
462 self.address, sh = _uleb128(data[cur_off:cur_off + 5]) 564 self.address, sh = _uleb128(data[moff():moff() + 5])
463 cur_off = cur_off + sh 565 moff(sh)
464 566
465 self.data_size = cur_off - off 567 self.data_size = moff() - off
466 pass 568 pass
467 569
468 def parse1(self, data, off): 570 def parse1(self, data, off):
469 self.address, sh = _uleb128(data[off:off + 5]) 571 self.address, sh = _uleb128(data[off:off + 5])
470 572
471 self.data_size = sh 573 self.data_size = sh
574 pass
575
576 def compute_size(self):
577 if self.typeIdx is not None:
578 size = _uleb128_sz(self.typeIdx)
579 else:
580 size = 0
581 pass
582 size = size + _uleb128_sz(self.address)
583
584 self.data_size = size
472 pass 585 pass
473 pass 586 pass
474 587
475 588
476 class _DEX_Catch(object): 589 class _DEX_Catch(object):
509 moff(handler.data_size) 622 moff(handler.data_size)
510 self.handlers.append(handler) 623 self.handlers.append(handler)
511 pass 624 pass
512 625
513 self.data_size = moff() - off 626 self.data_size = moff() - off
627 pass
628
629 def compute_size(self):
630 count = len(self.handlers)
631 if self.catchesAll:
632 count = -(count - 1)
633 pass
634 count_sz = _leb128_sz(count)
635
636 handlers_size = _sum_data_size(self.handlers)
637
638 size = count_sz + handlers_size
514 pass 639 pass
515 pass 640 pass
516 641
517 642
518 class _DEX_Code(object): 643 class _DEX_Code(object):
566 pass 691 pass
567 692
568 moff.off = (moff() + 3) & ~0x3 # round code item to 4 bytes 693 moff.off = (moff() + 3) & ~0x3 # round code item to 4 bytes
569 self.data_size = moff() - off 694 self.data_size = moff() - off
570 pass 695 pass
696
697 def compute_size(self):
698 size = 16 + self.insnsSize * 2
699
700 if self.triesSize > 0:
701 size = (size + 0x3) & ~0x3
702
703 try_items_size = _sum_data_size(self.try_items)
704
705 catch_handler_items = self.catch_handler_items
706 catch_handler_items_cnt = len(catch_handler_items)
707 catch_handler_items_cnt_sz = _uleb128_sz(catch_handler_items_cnt)
708 catch_handler_items_sz = _sum_data_size(catch_handler_items)
709 catch_handler_items_size = \
710 catch_handler_items_cnt_sz + \
711 catch_handler_items_sz
712
713 size = size + try_items_size + catch_handler_items_size
714 pass
715
716 self.data_size = (size + 3) & ~0x3
717 pass
571 pass 718 pass
572 719
573 720
574 ## \brief File offset to Annotation item. 721 ## \brief File offset to Annotation item.
575 # 722 #
606 self.annotations = [parse_annotation_ref() 753 self.annotations = [parse_annotation_ref()
607 for i in range(size)] 754 for i in range(size)]
608 755
609 self.data_size = moff() - off 756 self.data_size = moff() - off
610 pass 757 pass
758
759 def compute_size(self):
760 annotations_size = _sum_data_size(self.annotations)
761 size = 4 + annotations_size
762
763 self.data_size = size
764 pass
611 pass 765 pass
612 766
613 767
614 class _DEX_FieldAnnotationsItem(object): 768 class _DEX_FieldAnnotationsItem(object):
615 fieldIdx = None # 4 bytes 769 fieldIdx = None # 4 bytes
696 for i in range(methodsSize)] 850 for i in range(methodsSize)]
697 self.parameterAnnotationsItems = [parse_parameterAnnotationsItem() 851 self.parameterAnnotationsItems = [parse_parameterAnnotationsItem()
698 for i in range(parametersSize)] 852 for i in range(parametersSize)]
699 853
700 self.data_size = moff() - off 854 self.data_size = moff() - off
855 pass
856
857 def compute_size(self):
858 field_anno_sz = _sum_data_size(self.fieldAnnotationsItems)
859 method_anno_sz = _sum_data_size(self.methodAnnotationsItems)
860 parameter_anno_sz = _sum_data_size(self.parameterAnnotationsItems)
861
862 all_items_size = field_anno_sz + method_anno_sz + parameter_anno_sz
863 size = 16 + all_items_size
864
865 self.data_size = size
701 pass 866 pass
702 pass 867 pass
703 868
704 869
705 ## 870 ##
829 raise ValueError, \ 994 raise ValueError, \
830 'Bad annotation element value byte 0x02x' % (valueType) 995 'Bad annotation element value byte 0x02x' % (valueType)
831 996
832 self.data_size = moff() - off 997 self.data_size = moff() - off
833 pass 998 pass
999
1000 def compute_size(self):
1001 if self.nameIdx is not None:
1002 nameIdx_size = _uleb128_sz(self.nameIdx)
1003 else:
1004 nameIdx_size = 0
1005 pass
1006
1007 valueType = self.valueType
1008 width = valueType >> self.kDexAnnotationValueArgShift
1009
1010 vtype = valueType & self.kDexAnnotationValueTypeMask
1011
1012 if vtype in (self.kDexAnnotationByte,
1013 self.kDexAnnotationShort,
1014 self.kDexAnnotationChar,
1015 self.kDexAnnotationInt,
1016 self.kDexAnnotationLong,
1017 self.kDexAnnotationFloat,
1018 self.kDexAnnotationDouble,
1019 self.kDexAnnotationString,
1020 self.kDexAnnotationType,
1021 self.kDexAnnotationMethod,
1022 self.kDexAnnotationField,
1023 self.kDexAnnotationEnum):
1024 value_size = width + 2
1025 pass
1026 elif vtype in (self.kDexAnnotationBoolean,
1027 self.kDexAnnotationNull):
1028 value_size = 1
1029 pass
1030 elif vtype == self.kDexAnnotationArray:
1031 array_cnt = len(self.value)
1032 array_cnt_size = _uleb128_sz(array_cnt)
1033 array_size = _sum_data_size(self.value)
1034 value_size = 1 + array_cnt_size + array_size
1035 pass
1036 elif vtype == self.kDexAnnotationAnnotation:
1037 value_size = 1 + _compute_sz(self.value)
1038 pass
1039 else:
1040 raise ValueError, \
1041 'Bad annotation element value byte 0x02x' % (valueType)
1042
1043 self.data_size = nameIdx_size + value_size
1044 pass
834 pass 1045 pass
835 1046
836 1047
837 ## \brief Annotation item 1048 ## \brief Annotation item
838 # 1049 #
874 self.members = [parse_AnnotationMemmber() 1085 self.members = [parse_AnnotationMemmber()
875 for i in range(size)] 1086 for i in range(size)]
876 1087
877 self.data_size = moff() - off 1088 self.data_size = moff() - off
878 pass 1089 pass
1090
1091 def compute_size(self):
1092 if self.visibility is not None:
1093 visibility_size = 1
1094 else:
1095 visibility_size = 0
1096 pass
1097
1098 typeIdx_size = _uleb128_sz(self.typeIdx)
1099
1100 members_cnt_size = _uleb128_sz(len(self.members))
1101 members_size = members_cnt_size + _sum_data_size(self.members)
1102
1103 size = visibility_size + typeIdx_size + members_size
1104
1105 self.data_size = size
1106 pass
879 pass 1107 pass
880 1108
881 1109
882 class _DEX_EncodedArrayItem(object): 1110 class _DEX_EncodedArrayItem(object):
883 elements = None 1111 elements = None
898 1126
899 self.elements = [parse_element() 1127 self.elements = [parse_element()
900 for i in range(size)] 1128 for i in range(size)]
901 1129
902 self.data_size = moff() - off 1130 self.data_size = moff() - off
1131 pass
1132
1133 def compute_size(self):
1134 elements_cnt_size = _uleb128_sz(len(self.elements))
1135 size = elements_cnt_size + _sum_data_size(self.elements)
1136
1137 self.data_size = size
903 pass 1138 pass
904 pass 1139 pass
905 1140
906 1141
907 class _DEX_DebugInfoItem(object): 1142 class _DEX_DebugInfoItem(object):
958 adv, sh = _uleb128(data[moff():moff() + 5]) 1193 adv, sh = _uleb128(data[moff():moff() + 5])
959 moff(sh) 1194 moff(sh)
960 opcodes.append((opcode, adv)) 1195 opcodes.append((opcode, adv))
961 pass 1196 pass
962 elif opcode == self.DBG_ADVANCE_LINE: 1197 elif opcode == self.DBG_ADVANCE_LINE:
963 adv, sh = _uleb128(data[moff():moff() + 5]) 1198 adv, sh = _leb128(data[moff():moff() + 5])
964 moff(sh) 1199 moff(sh)
965 opcodes.append((opcode, adv)) 1200 opcodes.append((opcode, adv))
966 pass 1201 pass
967 elif opcode in (self.DBG_START_LOCAL, 1202 elif opcode in (self.DBG_START_LOCAL,
968 self.DBG_START_LOCAL_EXTENDED): 1203 self.DBG_START_LOCAL_EXTENDED):
1001 pass 1236 pass
1002 self.opcodes = opcodes 1237 self.opcodes = opcodes
1003 1238
1004 self.data_size = moff() - off 1239 self.data_size = moff() - off
1005 pass 1240 pass
1241
1242 def compute_size(self):
1243 start_line_size = _uleb128_sz(self.start_line)
1244
1245 parameters_cnt_size = _uleb128_sz(len(self.parameters))
1246 parameter_sizes = itertools.imap(_uleb128_sz, self.parameters)
1247 parameters_size = parameters_cnt_size + sum(parameter_sizes)
1248
1249 def compute_opcode_size(code):
1250 opcode = code[0]
1251
1252 if opcode == self.DBG_END_SEQUENCE:
1253 size = 1
1254 elif opcode == self.DBG_ADVANCE_PC:
1255 size = 1 + _uleb128_sz(code[1])
1256 elif opcode == self.DBG_ADVANCE_LINE:
1257 size = 1 + _leb128_sz(code[1])
1258 elif opcode in (self.DBG_START_LOCAL,
1259 self.DBG_START_LOCAL_EXTENDED):
1260 size = 1 + _uleb128_sz(code[1]) + _uleb128_sz(code[2]) + \
1261 _uleb128_sz(code[3])
1262 if len(code) == 5:
1263 size = size + _uleb128_sz(code[4])
1264 pass
1265 pass
1266 elif opcode == self.DBG_END_LOCAL:
1267 size = 1 + _uleb128_sz(code[1])
1268 elif opcode == self.DBG_RESTART_LOCAL:
1269 size = 1 + _uleb128_sz(code[1])
1270 elif opcode in (self.DBG_SET_PROLOGUE_END,
1271 self.DBG_SET_EPILOGUE_BEGIN,
1272 self.DBG_SET_FILE):
1273 size = 1
1274 else:
1275 size = 1
1276 pass
1277
1278 return size
1279
1280 opcode_sizes = itertools.imap(compute_opcode_size, self.opcodes)
1281 opcode_sizes = [i for i in opcode_sizes]
1282 opcodes_size = sum(opcode_sizes)
1283
1284 size = start_line_size + parameters_size + opcodes_size
1285
1286 self.data_size = size
1287 pass
1006 pass 1288 pass
1007 1289
1008 1290
1009 class DEXFile(object): 1291 class DEXFile(object):
1010 _data = None 1292 _data = None
1416 print '\t\t%s@0x%x' % (name, code_off) 1698 print '\t\t%s@0x%x' % (name, code_off)
1417 pass 1699 pass
1418 pass 1700 pass
1419 1701
1420 print 1702 print
1421 print 'TypeLists size is %d bytes' % (dex._typeLists.data_size) 1703 print 'TypeLists size is %d/%d bytes' % (dex._typeLists.data_size,
1704 _compute_sz(dex._typeLists))
1422 1705
1423 bytes = sum([code.data_size for code in dex._codeItems]) 1706 bytes = sum([code.data_size for code in dex._codeItems])
1707 rbytes = sum([_compute_sz(code) for code in dex._codeItems])
1424 print 1708 print
1425 print 'CodeItems size is %d bytes' % (bytes) 1709 print 'CodeItems size is %d/%d bytes' % (bytes, rbytes)
1426 1710
1427 bytes = sum([annoset.data_size for annoset in dex._annotationSetItems]) 1711 bytes = sum([annoset.data_size for annoset in dex._annotationSetItems])
1712 rbytes = sum([_compute_sz(annoset) for annoset in dex._annotationSetItems])
1428 print 1713 print
1429 print 'AnnotationSetItems size is %d bytes' % (bytes) 1714 print 'AnnotationSetItems size is %d/%d bytes' % (bytes, rbytes)
1430 1715
1431 bytes = sum([annodir.data_size 1716 bytes = sum([annodir.data_size
1432 for annodir in dex._annotationsDirectoryItems]) 1717 for annodir in dex._annotationsDirectoryItems])
1718 rbytes = sum([_compute_sz(annodir)
1719 for annodir in dex._annotationsDirectoryItems])
1433 print 1720 print
1434 print 'AnnotationsDirtoryItems size is %d bytes' % (bytes) 1721 print 'AnnotationsDirtoryItems size is %d/%d bytes' % (bytes, rbytes)
1435 1722
1436 bytes = sum([annoitem.data_size 1723 bytes = sum([annoitem.data_size
1437 for annoitem in dex._annotationItems]) 1724 for annoitem in dex._annotationItems])
1725 rbytes = sum([_compute_sz(annoitem)
1726 for annoitem in dex._annotationItems])
1438 print 1727 print
1439 print 'AnnotationItems size is %d bytes' % (bytes) 1728 print 'AnnotationItems size is %d/%d bytes' % (bytes, rbytes)
1440 1729
1441 bytes = sum([encodeditem.data_size 1730 bytes = sum([encodeditem.data_size
1442 for encodeditem in dex._encodedArrayItems]) 1731 for encodeditem in dex._encodedArrayItems])
1732 rbytes = sum([_compute_sz(encodeditem)
1733 for encodeditem in dex._encodedArrayItems])
1443 print 1734 print
1444 print 'EncodedArrayItems size is %d bytes' % (bytes) 1735 print 'EncodedArrayItems size is %d/%d bytes' % (bytes, rbytes)
1445 1736
1446 bytes = sum([debuginfoitem.data_size 1737 bytes = sum([debuginfoitem.data_size
1447 for debuginfoitem in dex._debugInfoItems]) 1738 for debuginfoitem in dex._debugInfoItems])
1739 rbytes = sum([_compute_sz(debuginfoitem)
1740 for debuginfoitem in dex._debugInfoItems])
1448 print 1741 print
1449 print 'DebugInfoItems size is %d bytes' % (bytes) 1742 print 'DebugInfoItems size is %d/%d bytes' % (bytes, rbytes)
1450 1743
1451 print 1744 print
1452 print 'Data maps' 1745 print 'Data maps'
1453 maps = dex._maps 1746 maps = dex._maps
1454 for map in maps: 1747 for map in maps: