Lines Matching refs:self
80 def __init__(self, fields):
81 self.fields = fields
82 self.is_flexible = False
85 self.is_flexible = True
87 if not self.is_flexible:
88 self.ctype = Descriptor._GetCtype(fields)
89 self.size = ctypes.sizeof(self.ctype)
91 def Read(self, memory, offset):
92 if self.is_flexible:
93 fields_copy = self.fields[:]
107 complete_ctype = self.ctype
116 def __str__(self):
117 return "{" + ", ".join("%s: %s" % (field, self.__getattribute__(field))
595 def __init__(self, start, size, name):
596 self.start = start
597 self.end = self.start + size
598 self.name = name
600 def __cmp__(self, other):
602 return self.start - other.start
603 return self.start - other
605 def Covers(self, addr):
606 return (self.start <= addr) and (addr < self.end)
614 def __init__(self, options, minidump_name):
615 self._reset()
616 self.minidump_name = minidump_name
618 self.minidump_file = open(minidump_name, "a+")
619 self.minidump = mmap.mmap(self.minidump_file.fileno(), 0)
621 self.minidump_file = open(minidump_name, "r")
622 self.minidump = mmap.mmap(self.minidump_file.fileno(), 0, mmap.MAP_PRIVATE)
623 self.header = MINIDUMP_HEADER.Read(self.minidump, 0)
624 if self.header.signature != MinidumpReader._HEADER_MAGIC:
626 DebugPrint(self.header)
627 offset = self.header.stream_directories_rva
629 for _ in range(self.header.stream_count):
630 directories.append(MINIDUMP_DIRECTORY.Read(self.minidump, offset))
633 self.symdir = options.symdir
634 self._ReadArchitecture(directories)
635 self._ReadDirectories(directories)
636 self._FindObjdump(options)
638 def _reset(self):
639 self.header = None
640 self.arch = None
641 self.exception = None
642 self.exception_context = None
643 self.memory_list = None
644 self.memory_list64 = None
645 self.module_list = None
646 self.thread_map = {}
648 self.modules_with_symbols = []
649 self.symbols = []
652 def _ReadArchitecture(self, directories):
657 self.minidump, d.location.rva)
658 self.arch = system_info.processor_architecture
659 if self.arch == MD_CPU_ARCHITECTURE_ARM64_BREAKPAD_LEGACY:
660 self.arch = MD_CPU_ARCHITECTURE_ARM64
661 assert self.arch in [MD_CPU_ARCHITECTURE_AMD64,
665 assert not self.arch is None
667 def _ReadDirectories(self, directories):
671 self.exception = MINIDUMP_EXCEPTION_STREAM.Read(
672 self.minidump, d.location.rva)
673 DebugPrint(self.exception)
674 self.exception_context = self.ContextDescriptor().Read(
675 self.minidump, self.exception.thread_context.rva)
676 DebugPrint(self.exception_context)
678 thread_list = MINIDUMP_THREAD_LIST.Read(self.minidump, d.location.rva)
681 self.minidump, d.location.rva)
686 self.thread_map[thread.id] = thread
688 assert self.module_list is None
689 self.module_list = MINIDUMP_MODULE_LIST.Read(
690 self.minidump, d.location.rva)
691 if ctypes.sizeof(self.module_list) + 4 == d.location.data_size:
692 self.module_list = MINIDUMP_MODULE_LIST_Mac.Read(
693 self.minidump, d.location.rva)
694 assert ctypes.sizeof(self.module_list) == d.location.data_size
695 DebugPrint(self.module_list)
698 assert self.memory_list is None
699 self.memory_list = MINIDUMP_MEMORY_LIST.Read(
700 self.minidump, d.location.rva)
701 if ctypes.sizeof(self.memory_list) + 4 == d.location.data_size:
702 self.memory_list = MINIDUMP_MEMORY_LIST_Mac.Read(
703 self.minidump, d.location.rva)
704 assert ctypes.sizeof(self.memory_list) == d.location.data_size
705 DebugPrint(self.memory_list)
707 assert self.memory_list64 is None
708 self.memory_list64 = MINIDUMP_MEMORY_LIST64.Read(
709 self.minidump, d.location.rva)
710 assert ctypes.sizeof(self.memory_list64) == d.location.data_size
711 DebugPrint(self.memory_list64)
713 def _FindObjdump(self, options):
717 objdump_bin = self._FindThirdPartyObjdump()
726 def _FindThirdPartyObjdump(self):
735 if self.arch == MD_CPU_ARCHITECTURE_ARM:
737 elif self.arch == MD_CPU_ARCHITECTURE_ARM64:
751 def ContextDescriptor(self):
752 if self.arch == MD_CPU_ARCHITECTURE_X86:
754 elif self.arch == MD_CPU_ARCHITECTURE_AMD64:
756 elif self.arch == MD_CPU_ARCHITECTURE_ARM:
758 elif self.arch == MD_CPU_ARCHITECTURE_ARM64:
763 def IsValidAlignedAddress(self, address):
764 return self.IsAlignedAddress(address) and self.IsValidAddress(address)
766 def IsValidAddress(self, address):
767 return self.FindLocation(address) is not None
769 def IsAlignedAddress(self, address):
770 return (address % self.MachinePointerSize()) == 0
772 def IsExceptionStackAddress(self, address):
773 if not self.IsAlignedAddress(address): return False
774 return self.IsAnyExceptionStackAddress(address)
776 def IsAnyExceptionStackAddress(self, address):
777 return self.StackTop() <= address <= self.StackBottom()
779 def IsValidExceptionStackAddress(self, address):
780 if not self.IsValidAddress(address): return False
781 return self.IsExceptionStackAddress(address)
783 def IsModuleAddress(self, address):
784 return self.GetModuleForAddress(address) != None
786 def GetModuleForAddress(self, address):
787 for module in self.module_list.modules:
793 def ReadU8(self, address):
794 location = self.FindLocation(address)
795 return ctypes.c_uint8.from_buffer(self.minidump, location).value
797 def ReadU32(self, address):
798 location = self.FindLocation(address)
799 return ctypes.c_uint32.from_buffer(self.minidump, location).value
801 def ReadU64(self, address):
802 location = self.FindLocation(address)
803 return ctypes.c_uint64.from_buffer(self.minidump, location).value
805 def Is64(self):
806 return (self.arch == MD_CPU_ARCHITECTURE_ARM64 or
807 self.arch == MD_CPU_ARCHITECTURE_AMD64)
809 def IsPointerCompressed(self):
811 return self.Is64()
813 def Is32BitTagged(self):
814 return not self.Is64() or self.IsPointerCompressed()
816 def ReadTagged(self, address):
817 if self.Is32BitTagged():
818 return self.ReadU32(address)
819 return self.ReadU64(address)
821 def ReadUIntPtr(self, address):
822 if self.Is64():
823 return self.ReadU64(address)
824 return self.ReadU32(address)
826 def ReadSized(self, address, size):
828 return self.ReadU64(address)
830 return self.ReadU32(address)
832 def ReadBytes(self, address, size):
833 location = self.FindLocation(address)
834 return self.minidump[location:location + size]
836 def _ReadWord(self, location):
837 if self.Is64():
838 return ctypes.c_uint64.from_buffer(self.minidump, location).value
839 return ctypes.c_uint32.from_buffer(self.minidump, location).value
841 def ReadAsciiPtr(self, address):
844 for c in self.ReadBytes(address, self.MachinePointerSize())
848 def ReadAsciiString(self, address):
850 while self.IsValidAddress(address):
851 code = self.ReadU8(address)
859 def IsProbableASCIIRegion(self, location, length):
864 byte = ctypes.c_uint8.from_buffer(self.minidump, loc).value
881 def IsProbableExecutableRegion(self, location, length):
883 sixty_four = self.Is64()
886 byte = ctypes.c_uint8.from_buffer(self.minidump, loc).value
908 def FindRegion(self, addr):
914 self.ForEachMemoryRegion(is_in)
919 def ForEachMemoryRegion(self, cb):
920 if self.memory_list64 is not None:
921 for r in self.memory_list64.ranges:
922 location = self.memory_list64.base_rva + offset
923 cb(self, r.start, r.size, location)
926 if self.memory_list is not None:
927 for r in self.memory_list.ranges:
928 cb(self, r.start, r.memory.data_size, r.memory.rva)
930 def FindWord(self, word, alignment=0):
933 for i in range(size - self.MachinePointerSize()):
939 self.ForEachMemoryRegion(search_inside_region)
941 def FindWordList(self, word):
945 for i in range(size - self.MachinePointerSize()):
949 if self.IsAlignedAddress(slot):
953 self.ForEachMemoryRegion(search_inside_region)
956 def FindLocation(self, address):
958 if self.memory_list64 is not None:
959 for r in self.memory_list64.ranges:
961 return self.memory_list64.base_rva + offset + address - r.start
963 if self.memory_list is not None:
964 for r in self.memory_list.ranges:
969 def GetDisasmLines(self, address, size):
974 location = self.FindLocation(address)
978 if self.arch == MD_CPU_ARCHITECTURE_X86:
980 elif self.arch == MD_CPU_ARCHITECTURE_ARM:
983 elif self.arch == MD_CPU_ARCHITECTURE_ARM64:
986 elif self.arch == MD_CPU_ARCHITECTURE_AMD64:
988 results = [ disasm.GetDisasmLines(self.minidump_name,
998 def Dispose(self):
999 self._reset()
1000 self.minidump.close()
1001 self.minidump_file.close()
1003 def ExceptionIP(self):
1004 if self.arch == MD_CPU_ARCHITECTURE_AMD64:
1005 return self.exception_context.rip
1006 elif self.arch == MD_CPU_ARCHITECTURE_ARM:
1007 return self.exception_context.pc
1008 elif self.arch == MD_CPU_ARCHITECTURE_ARM64:
1009 return self.exception_context.pc
1010 elif self.arch == MD_CPU_ARCHITECTURE_X86:
1011 return self.exception_context.eip
1013 def ExceptionSP(self):
1014 if self.arch == MD_CPU_ARCHITECTURE_AMD64:
1015 return self.exception_context.rsp
1016 elif self.arch == MD_CPU_ARCHITECTURE_ARM:
1017 return self.exception_context.sp
1018 elif self.arch == MD_CPU_ARCHITECTURE_ARM64:
1019 return self.exception_context.sp
1020 elif self.arch == MD_CPU_ARCHITECTURE_X86:
1021 return self.exception_context.esp
1023 def ExceptionFP(self):
1024 if self.arch == MD_CPU_ARCHITECTURE_AMD64:
1025 return self.exception_context.rbp
1026 elif self.arch == MD_CPU_ARCHITECTURE_ARM:
1028 elif self.arch == MD_CPU_ARCHITECTURE_ARM64:
1029 return self.exception_context.fp
1030 elif self.arch == MD_CPU_ARCHITECTURE_X86:
1031 return self.exception_context.ebp
1033 def ExceptionThread(self):
1034 return self.thread_map[self.exception.thread_id]
1036 def StackTop(self):
1037 return self.ExceptionSP()
1039 def StackBottom(self):
1040 exception_thread = self.ExceptionThread()
1044 def FormatIntPtr(self, value):
1045 if self.Is64():
1049 def FormatTagged(self, value):
1050 if self.Is64() and not self.IsPointerCompressed():
1054 def MachinePointerSize(self):
1055 if self.Is64():
1059 def TaggedPointerSize(self):
1060 if self.IsPointerCompressed():
1062 return self.MachinePointerSize()
1064 def Register(self, name):
1065 return self.exception_context.__getattribute__(name)
1067 def ReadMinidumpString(self, rva):
1068 string = bytearray(MINIDUMP_STRING.Read(self.minidump, rva).buffer)
1076 def _LoadSymbolsFrom(self, symfile, baseaddr):
1087 bisect.insort_left(self.symbols,
1091 def TryLoadSymbolsFor(self, modulename, module):
1093 symfile = os.path.join(self.symdir,
1096 self._LoadSymbolsFrom(symfile, module.base_of_image)
1097 self.modules_with_symbols.append(module)
1102 def _IsInModuleWithSymbols(self, addr):
1103 for module in self.modules_with_symbols:
1112 def FindSymbol(self, addr):
1113 if not self._IsInModuleWithSymbols(addr):
1116 i = bisect.bisect_left(self.symbols, addr)
1118 if (0 < i) and self.symbols[i - 1].Covers(addr):
1119 symbol = self.symbols[i - 1]
1120 elif (i < len(self.symbols)) and self.symbols[i].Covers(addr):
1121 symbol = self.symbols[i]
1131 def __init__(self):
1132 self.indent = 0
1134 def Indent(self):
1135 self.indent += 2
1137 def Dedent(self):
1138 self.indent -= 2
1140 def Print(self, string):
1141 print("%s%s" % (self._IndentString(), string))
1143 def PrintLines(self, lines):
1144 indent = self._IndentString()
1147 def _IndentString(self):
1148 return self.indent * " "
1189 def __init__(self, heap, map, address):
1190 self.heap = heap
1191 self.map = map
1192 self.address = address
1194 def Is(self, cls):
1195 return isinstance(self, cls)
1197 def Print(self, p):
1198 p.Print(str(self))
1200 def __str__(self):
1202 if self.map is not None:
1203 instance_type = INSTANCE_TYPES[self.map.instance_type]
1204 return "%s(%s, %s)" % (self.__class__.__name__,
1205 self.heap.reader.FormatIntPtr(self.address),
1208 def ObjectField(self, offset):
1209 field_value = self.heap.reader.ReadTagged(self.address + offset)
1210 return self.heap.FindObjectOrSmi(field_value)
1212 def SmiField(self, offset):
1213 field_value = self.heap.reader.ReadTagged(self.address + offset)
1214 if self.heap.IsSmi(field_value):
1215 return self.heap.SmiUntag(field_value)
1220 def Decode(self, offset, size, value):
1224 def InstanceSizesOffset(self):
1225 return self.heap.TaggedPointerSize()
1227 def InstanceSizeOffset(self):
1228 return self.InstanceSizesOffset()
1230 def InObjectProperties(self):
1231 return self.InstanceSizeOffset() + 1
1233 def UnusedByte(self):
1234 return self.InObjectProperties() + 1
1236 def VisitorId(self):
1237 return self.UnusedByte() + 1
1240 def InstanceAttributesOffset(self):
1241 return self.InstanceSizesOffset() + self.heap.IntSize()
1243 def InstanceTypeOffset(self):
1244 return self.InstanceAttributesOffset()
1246 def BitFieldOffset(self):
1247 return self.InstanceTypeOffset() + 1
1249 def BitField2Offset(self):
1250 return self.BitFieldOffset() + 1
1252 def UnusedPropertyFieldsOffset(self):
1253 return self.BitField2Offset() + 1
1256 def BitField3Offset(self):
1257 return self.InstanceAttributesOffset() + self.heap.IntSize()
1259 def PrototypeOffset(self):
1260 return self.BitField3Offset() + self.heap.TaggedPointerSize()
1262 def ConstructorOrBackPointerOffset(self):
1263 return self.PrototypeOffset() + self.heap.TaggedPointerSize()
1265 def TransitionsOrPrototypeInfoOffset(self):
1266 return self.ConstructorOrBackPointerOffset() + self.heap.TaggedPointerSize()
1268 def DescriptorsOffset(self):
1269 return (self.TransitionsOrPrototypeInfoOffset() +
1270 self.heap.TaggedPointerSize())
1272 def CodeCacheOffset(self):
1273 return self.DescriptorsOffset() + self.heap.TaggedPointerSize()
1275 def DependentCodeOffset(self):
1276 return self.CodeCacheOffset() + self.heap.TaggedPointerSize()
1278 def ReadByte(self, offset):
1279 return self.heap.reader.ReadU8(self.address + offset)
1281 def ReadSlot(self, offset):
1282 return self.heap.reader.ReadTagged(self.address + offset)
1284 def Print(self, p):
1285 p.Print("Map(%08x)" % (self.address))
1287 self.ReadByte(self.InstanceSizeOffset()),
1288 self.ReadByte(self.InObjectProperties()),
1289 self.ReadByte(self.UnusedByte()),
1290 self.VisitorId()))
1292 instance_type = INSTANCE_TYPES[self.ReadByte(self.InstanceTypeOffset())]
1293 bitfield = self.ReadByte(self.BitFieldOffset())
1294 bitfield2 = self.ReadByte(self.BitField2Offset())
1295 unused = self.ReadByte(self.UnusedPropertyFieldsOffset())
1299 p.Print(" - kind: %s" % (self.Decode(3, 5, bitfield2)))
1301 bitfield3 = self.ReadSlot(self.BitField3Offset())
1305 self.Decode(0, 10, bitfield3),
1306 self.Decode(10, 10, bitfield3),
1307 self.Decode(21, 1, bitfield3)))
1308 p.Print(" - DictionaryMap: %s" % (self.Decode(20, 1, bitfield3)))
1309 p.Print(" - Deprecated: %s" % (self.Decode(23, 1, bitfield3)))
1310 p.Print(" - IsUnstable: %s" % (self.Decode(24, 1, bitfield3)))
1311 p.Print(" - NewTargetIsBase: %s" % (self.Decode(27, 1, bitfield3)))
1313 descriptors = self.ObjectField(self.DescriptorsOffset())
1319 transitions = self.ObjectField(self.TransitionsOrPrototypeInfoOffset())
1325 p.Print(" - Prototype: %s" % self.ObjectField(self.PrototypeOffset()))
1327 def __init__(self, heap, map, address):
1328 HeapObject.__init__(self, heap, map, address)
1329 self.instance_type = \
1330 heap.reader.ReadU8(self.address + self.InstanceTypeOffset())
1334 def LengthOffset(self):
1336 return self.heap.TaggedPointerSize() * 2
1338 def __init__(self, heap, map, address):
1339 HeapObject.__init__(self, heap, map, address)
1340 self.length = self.SmiField(self.LengthOffset())
1342 def GetChars(self):
1345 def Print(self, p):
1346 p.Print(str(self))
1348 def __str__(self):
1349 return "\"%s\"" % self.GetChars()
1353 def CharsOffset(self):
1354 return self.heap.TaggedPointerSize() * 3
1356 def __init__(self, heap, map, address):
1357 String.__init__(self, heap, map, address)
1358 self.chars = heap.reader.ReadBytes(self.address + self.CharsOffset(),
1359 self.length)
1361 def GetChars(self):
1362 return self.chars
1372 def __init__(self, heap, map, address):
1373 String.__init__(self, heap, map, address)
1375 self.resource = \
1376 reader.ReadU32(self.address + ExternalString.RESOURCE_OFFSET)
1377 self.chars = "?external string?"
1378 if not reader.IsValidAddress(self.resource): return
1379 string_impl_address = self.resource + \
1388 raw_chars = reader.ReadBytes(chars_ptr, 2 * self.length)
1389 self.chars = codecs.getdecoder("utf16")(raw_chars)[0]
1391 def GetChars(self):
1392 return self.chars
1396 def LeftOffset(self):
1397 return self.heap.TaggedPointerSize() * 3
1399 def RightOffset(self):
1400 return self.heap.TaggedPointerSize() * 4
1402 def __init__(self, heap, map, address):
1403 String.__init__(self, heap, map, address)
1404 self.left = self.ObjectField(self.LeftOffset())
1405 self.right = self.ObjectField(self.RightOffset())
1407 def GetChars(self):
1409 return self.left.GetChars() + self.right.GetChars()
1426 def ToStringOffset(self):
1427 return self.heap.TaggedPointerSize()
1429 def ToNumberOffset(self):
1430 return self.ToStringOffset() + self.heap.TaggedPointerSize()
1432 def KindOffset(self):
1433 return self.ToNumberOffset() + self.heap.TaggedPointerSize()
1435 def __init__(self, heap, map, address):
1436 HeapObject.__init__(self, heap, map, address)
1437 self.to_string = self.ObjectField(self.ToStringOffset())
1438 self.kind = self.SmiField(self.KindOffset())
1440 def Print(self, p):
1441 p.Print(str(self))
1443 def __str__(self):
1444 if self.to_string:
1445 return "Oddball(%08x, <%s>)" % (self.address, str(self.to_string))
1448 if 0 <= self.kind < len(Oddball.KINDS):
1449 kind = Oddball.KINDS[self.kind]
1450 return "Oddball(%08x, kind=%s)" % (self.address, kind)
1454 def LengthOffset(self):
1455 return self.heap.TaggedPointerSize()
1457 def ElementsOffset(self):
1458 return self.heap.TaggedPointerSize() * 2
1460 def MemberOffset(self, i):
1461 return self.ElementsOffset() + self.heap.TaggedPointerSize() * i
1463 def Get(self, i):
1464 return self.ObjectField(self.MemberOffset(i))
1466 def __init__(self, heap, map, address):
1467 HeapObject.__init__(self, heap, map, address)
1468 self.length = self.SmiField(self.LengthOffset())
1470 def Print(self, p):
1471 p.Print("FixedArray(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1473 p.Print("length: %d" % self.length)
1474 base_offset = self.ElementsOffset()
1475 for i in range(self.length):
1478 p.Print("[%08d] = %s" % (i, self.ObjectField(offset)))
1487 def __str__(self):
1488 return "FixedArray(%08x, length=%d)" % (self.address, self.length)
1492 def __init__(self, array):
1493 self.array = array
1495 def Length(self):
1496 return self.array.Get(0)
1498 def Decode(self, offset, size, value):
1508 def Type(self, value):
1509 return DescriptorArray.TYPES[self.Decode(0, 3, value)]
1511 def Attributes(self, value):
1512 attributes = self.Decode(3, 3, value)
1519 def Deleted(self, value):
1520 return self.Decode(6, 1, value) == 1
1522 def FieldIndex(self, value):
1523 return self.Decode(20, 11, value)
1525 def Pointer(self, value):
1526 return self.Decode(6, 11, value)
1528 def Details(self, di, value):
1531 self.Type(value),
1532 self.Attributes(value),
1533 self.FieldIndex(value),
1534 self.Pointer(value)
1538 def Print(self, p):
1539 length = self.Length()
1540 array = self.array
1550 self.Details(di, array.Get(i + 1)))
1553 end = self.array.length // 3
1559 def __init__(self, array):
1560 self.array = array
1562 def IsSimpleTransition(self):
1563 return self.array.length <= 2
1565 def Length(self):
1567 if self.IsSimpleTransition():
1568 return self.array.length - 1
1569 return (self.array.length - 3) // 2
1571 def Print(self, p):
1572 length = self.Length()
1573 array = self.array
1577 if self.IsSimpleTransition():
1597 def CodeEntryOffset(self):
1598 return 3 * self.heap.TaggedPointerSize()
1600 def SharedOffset(self):
1601 return 5 * self.heap.TaggedPointerSize()
1603 def __init__(self, heap, map, address):
1604 HeapObject.__init__(self, heap, map, address)
1606 heap.reader.ReadU32(self.address + self.CodeEntryOffset())
1607 self.code = heap.FindObject(code_entry - Code.HeaderSize(heap) + 1)
1608 self.shared = self.ObjectField(self.SharedOffset())
1610 def Print(self, p):
1611 source = "\n".join(" %s" % line for line in self._GetSource().split("\n"))
1612 p.Print("JSFunction(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1614 p.Print("inferred name: %s" % self.shared.inferred_name)
1615 if self.shared.script.Is(Script) and self.shared.script.name.Is(String):
1616 p.Print("script name: %s" % self.shared.script.name)
1618 p.PrintLines(self._GetSource().split("\n"))
1620 self.code.Print(p)
1621 if self.code != self.shared.code:
1623 self.shared.code.Print(p)
1627 def __str__(self):
1629 if self.shared is not None and self.shared.Is(SharedFunctionInfo):
1630 inferred_name = self.shared.inferred_name
1632 (self.heap.reader.FormatIntPtr(self.address), inferred_name)
1634 def _GetSource(self):
1636 start = self.shared.start_position
1637 end = self.shared.end_position
1638 if not self.shared.script.Is(Script): return source
1639 script_source = self.shared.script.source
1647 def CodeOffset(self):
1648 return 2 * self.heap.TaggedPointerSize()
1650 def ScriptOffset(self):
1651 return 7 * self.heap.TaggedPointerSize()
1653 def InferredNameOffset(self):
1654 return 9 * self.heap.TaggedPointerSize()
1656 def EndPositionOffset(self):
1657 return 12 * self.heap.TaggedPointerSize() + 4 * self.heap.IntSize()
1659 def StartPositionAndTypeOffset(self):
1660 return 12 * self.heap.TaggedPointerSize() + 5 * self.heap.IntSize()
1662 def __init__(self, heap, map, address):
1663 HeapObject.__init__(self, heap, map, address)
1665 self.code = self.ObjectField(self.CodeOffset())
1666 self.script = self.ObjectField(self.ScriptOffset())
1667 self.inferred_name = self.ObjectField(self.InferredNameOffset())
1670 heap.reader.ReadU32(self.StartPositionAndTypeOffset())
1671 self.start_position = start_position_and_type >> 2
1673 heap.reader.ReadU32(self.EndPositionOffset())
1674 self.end_position = pseudo_smi_end_position >> 2
1677 self.SmiField(self.StartPositionAndTypeOffset())
1679 self.start_position = start_position_and_type >> 2
1681 self.start_position = None
1682 self.end_position = \
1683 self.SmiField(self.EndPositionOffset())
1689 def SourceOffset(self):
1690 return self.heap.TaggedPointerSize()
1692 def NameOffset(self):
1693 return self.SourceOffset() + self.heap.TaggedPointerSize()
1695 def __init__(self, heap, map, address):
1696 HeapObject.__init__(self, heap, map, address)
1697 self.source = self.ObjectField(self.SourceOffset())
1698 self.name = self.ObjectField(self.NameOffset())
1702 def DefaultCacheOffset(self):
1703 return self.heap.TaggedPointerSize()
1705 def NormalTypeCacheOffset(self):
1706 return self.DefaultCacheOffset() + self.heap.TaggedPointerSize()
1708 def __init__(self, heap, map, address):
1709 HeapObject.__init__(self, heap, map, address)
1710 self.default_cache = self.ObjectField(self.DefaultCacheOffset())
1711 self.normal_type_cache = self.ObjectField(self.NormalTypeCacheOffset())
1713 def Print(self, p):
1714 p.Print("CodeCache(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1716 p.Print("default cache: %s" % self.default_cache)
1717 p.Print("normal type cache: %s" % self.normal_type_cache)
1725 def InstructionSizeOffset(self):
1726 return self.heap.TaggedPointerSize()
1734 def __init__(self, heap, map, address):
1735 HeapObject.__init__(self, heap, map, address)
1736 self.entry = self.address + Code.HeaderSize(heap)
1737 self.instruction_size = \
1738 heap.reader.ReadU32(self.address + self.InstructionSizeOffset())
1740 def Print(self, p):
1741 lines = self.heap.reader.GetDisasmLines(self.entry, self.instruction_size)
1742 p.Print("Code(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1744 p.Print("instruction_size: %d" % self.instruction_size)
1745 p.PrintLines(self._FormatLine(line) for line in lines)
1749 def _FormatLine(self, line):
1750 return FormatDisasmLine(self.entry, self.heap, line)
1785 def __init__(self, reader, stack_map):
1786 self.reader = reader
1787 self.stack_map = stack_map
1788 self.objects = {}
1790 def FindObjectOrSmi(self, tagged_address):
1791 if self.IsSmi(tagged_address): return self.SmiUntag(tagged_address)
1792 return self.FindObject(tagged_address)
1794 def FindObject(self, tagged_address):
1795 if tagged_address in self.objects:
1796 return self.objects[tagged_address]
1797 if not self.IsTaggedObjectAddress(tagged_address): return None
1799 if not self.reader.IsValidAddress(address): return None
1800 map_tagged_address = self.reader.ReadTagged(address)
1803 meta_map = Map(self, None, address)
1809 map = self.FindMap(map_tagged_address)
1814 object = cls(self, map, address)
1815 self.objects[tagged_address] = object
1818 def FindMap(self, tagged_address):
1819 address = self.FindMapAddress(tagged_address)
1821 object = Map(self, None, address)
1824 def FindMapAddress(self, tagged_address):
1825 if not self.IsTaggedMapAddress(tagged_address): return None
1827 if not self.reader.IsValidAddress(address): return None
1830 def IntSize(self):
1833 def MachinePointerSize(self):
1834 return self.reader.MachinePointerSize()
1836 def TaggedPointerSize(self):
1837 return self.reader.TaggedPointerSize()
1839 def IsPointerCompressed(self):
1840 return self.reader.IsPointerCompressed()
1842 def ObjectAlignmentMask(self):
1843 return self.TaggedPointerSize() - 1
1845 def IsTaggedObjectAddress(self, address):
1846 return (address & self.ObjectAlignmentMask()) == 1
1848 def IsValidTaggedObjectAddress(self, address):
1849 if not self.IsTaggedObjectAddress(address): return False
1850 return self.reader.IsValidAddress(address)
1852 def IsTaggedMapAddress(self, address):
1853 return (address & self.MapAlignmentMask()) == 1
1855 def MapAlignmentMask(self):
1856 if self.reader.arch == MD_CPU_ARCHITECTURE_AMD64:
1858 elif self.reader.arch == MD_CPU_ARCHITECTURE_ARM:
1860 elif self.reader.arch == MD_CPU_ARCHITECTURE_ARM64:
1862 elif self.reader.arch == MD_CPU_ARCHITECTURE_X86:
1865 def PageAlignmentMask(self):
1868 def IsTaggedAddress(self, address):
1869 return (address & self.ObjectAlignmentMask()) == 1
1871 def IsSmi(self, tagged_address):
1872 if self.reader.Is64() and not self.reader.IsPointerCompressed():
1874 return not self.IsTaggedAddress(tagged_address)
1876 def SmiUntag(self, tagged_address):
1877 if self.reader.Is64() and not self.reader.IsPointerCompressed():
1881 def AddressTypeMarker(self, address):
1882 if not self.reader.IsValidAddress(address): return " "
1883 if self.reader.IsExceptionStackAddress(address): return "S"
1884 if self.reader.IsModuleAddress(address): return "C"
1885 if self.IsTaggedAddress(address):
1887 if self.reader.IsAnyExceptionStackAddress(address): return "s"
1891 def FormatIntPtr(self, address):
1892 marker = self.AddressTypeMarker(address)
1893 address = self.reader.FormatIntPtr(address)
1897 def RelativeOffset(self, slot, address):
1898 if not self.reader.IsValidAlignedAddress(slot): return None
1899 if self.IsTaggedObjectAddress(address):
1901 if not self.reader.IsValidAlignedAddress(address): return None
1902 offset = (address - slot) / self.MachinePointerSize()
1906 if self.reader.IsExceptionStackAddress(address):
1910 target_address = self.reader.ReadUIntPtr(address)
1911 return "[%+02d]=%s %s" % (offset, self.reader.FormatIntPtr(target_address),
1912 self.AddressTypeMarker(target_address))
1914 def FindObjectPointers(self, start=0, end=0):
1917 for slot in range(start, start + size, self.reader.TaggedPointerSize()):
1918 if not self.reader.IsValidAddress(slot): break
1920 tagged_address = self.reader.ReadTagged(slot)
1921 if not self.IsValidTaggedObjectAddress(tagged_address): continue
1922 map_address = self.reader.ReadTagged(tagged_address - 1)
1923 if not self.IsTaggedMapAddress(map_address): continue
1927 self.reader.ForEachMemoryRegion(find_object_in_region)
1929 find_object_in_region(self.reader, start, end-start, None)
1934 def __init__(self, heap, known_name):
1935 HeapObject.__init__(self, heap, None, None)
1936 self.known_name = known_name
1938 def __str__(self):
1939 return "<%s>" % self.known_name
1943 def __init__(self, heap, known_name, instance_type):
1944 HeapObject.__init__(self, heap, None, None)
1945 self.instance_type = instance_type
1946 self.known_name = known_name
1948 def __str__(self):
1949 return "<%s>" % self.known_name
1958 def __init__(self, minidump_name, reader):
1959 self.comment_file = minidump_name + ".comments"
1960 self.address_comments = {}
1961 self.page_address = {}
1962 if os.path.exists(self.comment_file):
1963 with open(self.comment_file, "r") as f:
1970 self.address_comments[int(m.group(1), 0)] = m.group(2)
1973 self.page_address[m.group(1)] = int(m.group(2), 0)
1974 self.reader = reader
1975 self.styles = {}
1976 self.color_addresses()
1979 def get_page_address(self, page_kind):
1980 return self.page_address.get(page_kind, 0)
1982 def save_page_address(self, page_kind, address):
1983 with open(self.comment_file, "a") as f:
1987 def color_addresses(self):
1989 exception_thread = self.reader.thread_map[self.reader.exception.thread_id]
1990 stack_top = self.reader.ExceptionSP()
1993 frame_pointer = self.reader.ExceptionFP()
1994 self.styles[frame_pointer] = "frame"
1996 self.reader.MachinePointerSize()):
1998 self.styles[slot] = "sa"
2000 self.reader.MachinePointerSize()):
2001 maybe_address = self.reader.ReadUIntPtr(slot)
2003 self.styles[maybe_address] = "sv"
2005 self.styles[slot] = "frame"
2007 self.styles[self.reader.ExceptionIP()] = "pc"
2009 def get_style_class(self, address):
2010 return self.styles.get(address, None)
2012 def get_style_class_string(self, address):
2013 style = self.get_style_class(address)
2019 def set_comment(self, address, comment):
2020 self.address_comments[address] = comment
2021 with open(self.comment_file, "a") as f:
2025 def get_comment(self, address):
2026 return self.address_comments.get(address, "")
2031 def __init__(self, reader, heap):
2032 self.reader = reader
2033 self.heap = heap
2034 self.known_first_map_page = 0
2035 self.known_first_old_page = 0
2036 self.context = None
2038 def __getattr__(self, name):
2041 return getattr(self.heap, name)
2043 def GetPageOffset(self, tagged_address):
2044 return tagged_address & self.heap.PageAlignmentMask()
2046 def IsInKnownMapSpace(self, tagged_address):
2047 page_address = tagged_address & ~self.heap.PageAlignmentMask()
2048 return page_address == self.known_first_map_page
2050 def IsInKnownOldSpace(self, tagged_address):
2051 page_address = tagged_address & ~self.heap.PageAlignmentMask()
2052 return page_address == self.known_first_old_page
2054 def ContainingKnownOldSpaceName(self, tagged_address):
2055 page_address = tagged_address & ~self.heap.PageAlignmentMask()
2056 if page_address == self.known_first_old_page: return "OLD_SPACE"
2059 def FrameMarkerName(self, value):
2067 def IsFrameMarker(self, slot, address):
2071 if not self.reader.IsExceptionStackAddress(slot): return False
2072 next_slot = slot + self.reader.MachinePointerSize()
2073 if not self.reader.IsValidAddress(next_slot): return False
2074 next_address = self.reader.ReadUIntPtr(next_slot)
2075 return self.reader.IsExceptionStackAddress(next_address)
2077 def FormatSmi(self, address):
2078 value = self.heap.SmiUntag(address)
2080 if not self.reader.Is64() or value == 0: return None
2083 def SenseObject(self, address, slot=None):
2084 if self.IsFrameMarker(slot, address):
2085 return self.FrameMarkerName(address)
2086 if self.heap.IsSmi(address):
2087 return self.FormatSmi(address)
2088 if not self.heap.IsTaggedAddress(address): return None
2090 if self.IsInKnownOldSpace(tagged_address):
2091 offset = self.GetPageOffset(tagged_address)
2092 lookup_key = (self.ContainingKnownOldSpaceName(tagged_address), offset)
2095 return KnownObject(self, known_obj_name)
2096 if self.IsInKnownMapSpace(tagged_address):
2097 known_map = self.SenseMap(tagged_address)
2100 found_obj = self.heap.FindObject(tagged_address)
2103 if self.reader.IsValidAddress(address):
2104 map_tagged_address = self.reader.ReadTagged(address)
2105 map = self.SenseMap(map_tagged_address)
2110 return cls(self, map, address)
2113 def SenseMap(self, tagged_address):
2114 if self.IsInKnownMapSpace(tagged_address):
2115 offset = self.GetPageOffset(tagged_address)
2120 return KnownMap(self, known_map_name, known_map_type)
2121 found_map = self.heap.FindMap(tagged_address)
2125 def FindObjectOrSmi(self, tagged_address):
2127 found_obj = self.SenseObject(tagged_address)
2129 if self.IsSmi(tagged_address):
2130 return self.FormatSmi(tagged_address)
2132 return "Unknown(%s)" % self.reader.FormatIntPtr(tagged_address)
2134 def FindObject(self, tagged_address):
2138 def FindMap(self, tagged_address):
2142 def PrintKnowledge(self):
2145 self.reader.FormatIntPtr(self.known_first_map_page),
2146 self.reader.FormatIntPtr(self.known_first_old_page)))
2148 def FindFirstAsciiString(self, start, end=None, min_length=32):
2152 if not self.reader.IsValidAddress(slot): break
2153 message = self.reader.ReadAsciiString(slot)
2158 def PrintStackTraceMessage(self, start=None, print_message=True):
2164 ptr_size = self.reader.MachinePointerSize()
2165 if start is None: start = self.reader.ExceptionSP()
2166 if not self.reader.IsValidAddress(start): return start
2170 if not self.reader.IsValidAddress(slot + ptr_size): break
2171 magic1 = self.reader.ReadUIntPtr(slot)
2172 magic2 = self.reader.ReadUIntPtr(slot + ptr_size)
2175 return self.TryExtractOldStyleStackTrace(slot, start, end,
2178 return self.TryExtractStackTrace(slot, start, end, print_message)
2180 return self.TryExtractErrorMessage(slot, start, end, print_message)
2182 return self.TryExtractOldStyleStackTrace(0, start, end,
2185 def TryExtractStackTrace(self, slot, start, end, print_message):
2186 ptr_size = self.reader.MachinePointerSize()
2187 assert self.reader.ReadUIntPtr(slot) & 0xFFFFFFFF == STACK_TRACE_MARKER
2192 end_slot = self.FindPtr(end_marker, end_search, end_search + ptr_size * 512)
2194 print("Stack Message (start=%s):" % self.heap.FormatIntPtr(slot))
2198 value = self.reader.ReadUIntPtr(slot)
2199 print(" %s: %s" % (name.rjust(14), self.heap.FormatIntPtr(value)))
2201 print(" message start: %s" % self.heap.FormatIntPtr(slot))
2203 print(" stack_start: %s" % self.heap.FormatIntPtr(stack_start))
2204 (message_start, message) = self.FindFirstAsciiString(slot)
2205 self.FormatStackTrace(message, print_message)
2208 def FindPtr(self, expected_value, start, end):
2209 ptr_size = self.reader.MachinePointerSize()
2211 if not self.reader.IsValidAddress(slot): return None
2212 value = self.reader.ReadUIntPtr(slot)
2216 def TryExtractErrorMessage(self, slot, start, end, print_message):
2217 ptr_size = self.reader.MachinePointerSize()
2221 end_slot = self.FindPtr(end_marker, end_search, end_search + ptr_size * 512)
2223 print("Error Message (start=%s):" % self.heap.FormatIntPtr(slot))
2225 (message_start, message) = self.FindFirstAsciiString(slot)
2226 self.FormatStackTrace(message, print_message)
2230 def TryExtractOldStyleStackTrace(self, message_slot, start, end,
2232 ptr_size = self.reader.MachinePointerSize()
2240 message_start, message = self.FindFirstAsciiString(start, end, 128)
2243 message_start = self.reader.ReadUIntPtr(message_slot + ptr_size * 4)
2244 message = self.reader.ReadAsciiString(message_start)
2250 print(" message start: %s" % self.heap.FormatIntPtr(message_start))
2251 print(" stack_start: %s" % self.heap.FormatIntPtr(stack_start ))
2253 ptr1 = self.reader.ReadUIntPtr(slot + ptr_size * 2)
2254 ptr2 = self.reader.ReadUIntPtr(slot + ptr_size * 3)
2256 print(" magic1: %s" % self.heap.FormatIntPtr(magic1))
2257 print(" magic2: %s" % self.heap.FormatIntPtr(magic2))
2258 print(" ptr1: %s" % self.heap.FormatIntPtr(ptr1))
2259 print(" ptr2: %s" % self.heap.FormatIntPtr(ptr2))
2260 print(" message start: %s" % self.heap.FormatIntPtr(message_start))
2261 print(" stack_start: %s" % self.heap.FormatIntPtr(stack_start ))
2263 self.FormatStackTrace(message, print_message)
2266 def FormatStackTrace(self, message, print_message):
2271 ptr_size = self.reader.MachinePointerSize()
2277 address = self.heap.FormatIntPtr(int(address_org, 16))
2287 def TryInferFramePointer(self, slot, address):
2290 if not self.reader.IsExceptionStackAddress(address): return 0
2291 next_address = self.reader.ReadUIntPtr(address)
2296 def TryInferContext(self, address):
2297 if self.context: return
2298 ptr_size = self.reader.MachinePointerSize()
2301 while self.reader.IsExceptionStackAddress(address):
2302 prev_addr = self.reader.ReadUIntPtr(address-ptr_size)
2303 if self.heap.IsTaggedObjectAddress(prev_addr):
2308 address = self.reader.ReadUIntPtr(address)
2316 self.context = address
2318 def InterpretMemory(self, start, end):
2321 if not self.reader.Is64():
2322 frame_pointer = self.reader.ExceptionFP()
2325 frame_pointer = self.reader.ReadUIntPtr(frame_pointer)
2326 if not self.reader.IsExceptionStackAddress(frame_pointer) or \
2331 is_stack = self.reader.IsExceptionStackAddress(start)
2333 ptr_size = self.reader.TaggedPointerSize()
2336 if not self.reader.IsValidAddress(slot):
2339 maybe_address = self.reader.ReadUIntPtr(slot)
2349 heap_object = self.SenseObject(maybe_address, slot)
2355 length = self.reader.ReadTagged(slot + ptr_size)
2356 if self.heap.IsSmi(length):
2357 length = self.heap.SmiUntag(length)
2360 relative_offset = self.heap.RelativeOffset(slot, maybe_address)
2363 if maybe_address == self.context:
2368 if self.reader.IsExceptionStackAddress(maybe_address):
2370 self.reader.ReadUIntPtr(maybe_address) & 0xFFFFFFFF
2374 frame_pointer = self.TryInferFramePointer(slot, maybe_address)
2376 self.TryInferContext(slot)
2377 maybe_symbol = self.reader.FindSymbol(maybe_address)
2387 if not self.reader.IsExceptionStackAddress(maybe_address):
2393 address_type_marker = self.heap.AddressTypeMarker(maybe_address)
2394 string_value = self.reader.ReadAsciiPtr(slot)
2395 print("%s: %s %s %s %s" % (self.reader.FormatIntPtr(slot),
2396 self.reader.FormatIntPtr(maybe_address),
2402 heap_object = self.heap.FindObject(maybe_address)
2626 def formatter(self, query_components):
2628 return self.server.get_dump_formatter(name)
2630 def send_success_html_headers(self):
2631 self.send_response(200)
2632 self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
2633 self.send_header("Pragma", "no-cache")
2634 self.send_header("Expires", "0")
2635 self.send_header('Content-type','text/html')
2636 self.end_headers()
2639 def write(self, string):
2640 self.wfile.write(string.encode('utf-8'))
2642 def do_GET(self):
2644 parsedurl = urllib.parse.urlparse(self.path)
2648 self.send_success_html_headers()
2649 self.server.output_dumps(out_buffer)
2650 self.write(out_buffer.getvalue())
2652 self.send_success_html_headers()
2653 self.formatter(query_components).output_summary(out_buffer)
2654 self.write(out_buffer.getvalue())
2656 self.send_success_html_headers()
2657 self.formatter(query_components).output_info(out_buffer)
2658 self.write(out_buffer.getvalue())
2660 self.send_success_html_headers()
2661 self.formatter(query_components).output_modules(out_buffer)
2662 self.write(out_buffer.getvalue())
2666 self.send_error(404, "Invalid params")
2668 self.send_success_html_headers()
2669 self.formatter(query_components).output_search_res(
2671 self.write(out_buffer.getvalue())
2676 self.send_error(404, "Invalid params")
2678 self.send_success_html_headers()
2679 self.formatter(query_components).output_disasm(
2681 self.write(out_buffer.getvalue())
2686 self.send_success_html_headers()
2687 self.formatter(query_components).output_data(
2689 self.write(out_buffer.getvalue())
2691 self.send_error(404,'Invalid params')
2698 if self.server.set_dump_desc(name, description):
2699 self.send_success_html_headers()
2700 self.write("OK")
2702 self.send_error(404,'Invalid params')
2709 self.formatter(query_components).set_comment(address, comment)
2710 self.send_success_html_headers()
2711 self.write("OK")
2713 self.send_error(404,'Invalid params')
2720 self.formatter(query_components).set_page_address(kind, address)
2721 self.send_success_html_headers()
2722 self.write("OK")
2724 self.send_error(404,'Invalid params')
2726 self.send_error(404,'File Not Found: %s' % self.path)
2729 self.send_error(404,'File Not Found: %s' % self.path)
2732 self.send_error(404, 'Web parameter error: %s' % e.message)
2742 def __init__(self, switches, minidump_name, http_server):
2743 self.dumpfilename = os.path.split(minidump_name)[1]
2744 self.encfilename = urllib.parse.urlencode({'dump': self.dumpfilename})
2745 self.reader = MinidumpReader(switches, minidump_name)
2746 self.server = http_server
2749 exception_thread = self.reader.thread_map[self.reader.exception.thread_id]
2750 stack_top = self.reader.ExceptionSP()
2753 stack_map = {self.reader.ExceptionIP(): -1}
2755 self.reader.MachinePointerSize()):
2756 maybe_address = self.reader.ReadUIntPtr(slot)
2759 self.heap = V8Heap(self.reader, stack_map)
2761 self.padawan = InspectionPadawan(self.reader, self.heap)
2762 self.comments = InspectionInfo(minidump_name, self.reader)
2763 self.padawan.known_first_old_page = (
2764 self.comments.get_page_address("oldpage"))
2765 self.padawan.known_first_map_page = (
2766 self.comments.get_page_address("mappage"))
2768 def set_comment(self, straddress, comment):
2771 self.comments.set_comment(address, comment)
2775 def set_page_address(self, kind, straddress):
2779 self.padawan.known_first_old_page = address
2781 self.padawan.known_first_map_page = address
2782 self.comments.save_page_address(kind, address)
2786 def td_from_address(self, f, address):
2787 f.write("<td %s>" % self.comments.get_style_class_string(address))
2789 def format_address(self, maybeaddress, straddress = None):
2794 straddress = "0x" + self.reader.FormatIntPtr(maybeaddress)
2796 if not self.reader.IsValidAddress(maybeaddress):
2799 (style_class, self.encfilename, straddress, straddress))
2801 def format_onheap_address(self, size, maybeaddress, uncompressed):
2805 straddress = "0x" + self.reader.FormatTagged(maybeaddress)
2806 struncompressed = "0x" + self.reader.FormatIntPtr(uncompressed)
2808 if not self.reader.IsValidAddress(maybeaddress):
2811 (style_class, self.encfilename, struncompressed, straddress))
2813 def output_header(self, f):
2815 "query_dump": self.encfilename,
2816 "dump_name": html.escape(self.dumpfilename)
2819 def output_footer(self, f):
2824 def output_summary(self, f):
2825 self.output_header(f)
2827 self.output_context(f, InspectionWebFormatter.CONTEXT_SHORT)
2828 self.output_disasm_pc(f)
2831 exception_thread = self.reader.thread_map[self.reader.exception.thread_id]
2832 stack_top = self.reader.ExceptionSP()
2835 stack_top + self.MAX_CONTEXT_STACK)
2836 self.output_words(f, stack_top - 16, stack_bottom, stack_top, "Stack",
2837 self.heap.MachinePointerSize())
2840 self.output_footer(f)
2843 def output_info(self, f):
2844 self.output_header(f)
2847 self.server.output_dump_desc_field(f, self.dumpfilename)
2850 f.write("<span class=\"code\">%s</span><br>" % (self.dumpfilename))
2851 dt = datetime.datetime.fromtimestamp(self.reader.header.time_date_stampt)
2853 self.output_context(f, InspectionWebFormatter.CONTEXT_FULL)
2854 self.output_address_ranges(f)
2855 self.output_footer(f)
2858 def output_address_ranges(self, f):
2862 self.reader.ForEachMemoryRegion(print_region)
2874 f.write("<td>%s</td>" % self.format_address(start))
2875 f.write("<td> %s</td>" % self.format_address(start + size))
2882 def output_module_details(self, f, module):
2883 f.write("<b>%s</b>" % GetModuleName(self.reader, module))
2889 f.write("base: %s" % self.reader.FormatIntPtr(module.base_of_image))
2891 f.write(" end: %s" % self.reader.FormatIntPtr(module.base_of_image +
2902 def output_modules(self, f):
2903 self.output_header(f)
2905 for module in self.reader.module_list.modules:
2906 self.output_module_details(f, module)
2908 self.output_footer(f)
2911 def output_context(self, f, details):
2912 exception_thread = self.reader.thread_map[self.reader.exception.thread_id]
2917 self.reader.exception.exception.code)
2919 if self.reader.exception.exception.parameter_count > 0:
2921 for i in range(0, self.reader.exception.exception.parameter_count):
2922 f.write("%08x" % self.reader.exception.exception.information[i])
2925 for r in CONTEXT_FOR_ARCH[self.reader.arch]:
2927 (r, self.format_address(self.reader.Register(r))))
2929 if self.reader.arch in [MD_CPU_ARCHITECTURE_ARM, MD_CPU_ARCHITECTURE_ARM64]:
2930 f.write("<b>cpsr</b>: %s" % bin(self.reader.exception_context.cpsr)[2:])
2933 bin(self.reader.exception_context.eflags)[2:])
2937 def align_down(self, a, size):
2941 def align_up(self, a, size):
2945 def format_object(self, address):
2946 heap_object = self.padawan.SenseObject(address)
2949 def output_data(self, f, straddress, datakind):
2951 self.output_header(f)
2953 if not self.reader.IsValidAddress(address):
2956 region = self.reader.FindRegion(address)
2958 self.output_words(f, region[0], region[0] + region[1], address, "Dump",
2959 self.heap.MachinePointerSize())
2961 self.output_words(f, region[0], region[0] + region[1], address,
2962 "Tagged Dump", self.heap.TaggedPointerSize())
2964 self.output_ascii(f, region[0], region[0] + region[1], address)
2965 self.output_footer(f)
2971 def output_words(self, f, start_address, end_address, highlight_address, desc,
2973 region = self.reader.FindRegion(highlight_address)
2978 start_address = self.align_down(start_address, size)
2979 low = self.align_down(region[0], size)
2980 high = self.align_up(region[0] + region[1], size)
2983 end_address = self.align_up(end_address, size)
2992 (self.encfilename, highlight_address))
3012 straddress += "%02x" % self.reader.ReadU8(i)
3016 maybe_address = self.reader.ReadSized(slot, size)
3017 if size == self.reader.MachinePointerSize():
3023 if size == self.reader.TaggedPointerSize():
3024 straddress = self.format_onheap_address(size, maybe_address,
3027 heap_object = self.format_object(maybe_address)
3029 straddress = self.format_address(maybe_address)
3042 self.output_comment_box(f, "da-", slot)
3044 self.td_from_address(f, slot)
3045 f.write(address_fmt % self.format_address(slot))
3046 self.td_from_address(f, maybe_uncompressed_address)
3050 self.output_comment_box(f, "sv-" + self.reader.FormatIntPtr(slot),
3059 def output_ascii(self, f, start_address, end_address, highlight_address):
3060 region = self.reader.FindRegion(highlight_address)
3073 (self.encfilename, highlight_address))
3083 start = self.align_down(start_address, line_width)
3096 code = self.reader.ReadU8(address)
3108 def output_disasm(self, f, straddress, strexact):
3110 self.output_header(f)
3112 if not self.reader.IsValidAddress(address):
3115 region = self.reader.FindRegion(address)
3116 self.output_disasm_range(
3118 self.output_footer(f)
3124 self, f, start_address, end_address, highlight_address, exact):
3125 region = self.reader.FindRegion(highlight_address)
3131 lines = self.reader.GetDisasmLines(start_address, count)
3141 lines = self.reader.GetDisasmLines(highlight_address, count)
3149 (self.encfilename, exactness, highlight_address))
3161 self.format_disasm_line(
3167 def annotate_disasm_addresses(self, line):
3171 formatted_address = self.format_address(maybe_address, m.group(0))
3173 object_info = self.padawan.SenseObject(maybe_address)
3183 self, f, start, line, next_address, highlight_address):
3196 stack_slot = self.heap.stack_map.get(line_address)
3213 if self.heap.reader.arch == MD_CPU_ARCHITECTURE_X86:
3223 code = self.annotate_disasm_addresses(code[op_offset:])
3225 self.output_comment_box(f, "codel-", line_address)
3229 self.td_from_address(f, line_address)
3230 f.write(self.format_address(line_address))
3236 def output_comment_box(self, f, prefix, address):
3237 comment = self.comments.get_comment(address)
3244 self.reader.FormatIntPtr(address),
3249 def output_find_results(self, f, results):
3251 toomany = len(results) > self.MAX_FOUND_RESULTS
3254 (len(results), self.MAX_FOUND_RESULTS))
3257 results = results[:min(len(results), self.MAX_FOUND_RESULTS)]
3260 (self.comments.get_style_class_string(address),
3261 self.format_address(address)))
3266 def output_page_info(self, f, page_kind, page_address, my_page_address):
3278 def output_search_res(self, f, straddress):
3280 self.output_header(f)
3286 self.output_comment_box(f, "search-", address)
3289 page_address = address & ~self.heap.PageAlignmentMask()
3292 self.output_page_info(f, "old", self.padawan.known_first_old_page, \
3294 self.output_page_info(f, "map", self.padawan.known_first_map_page, \
3297 if not self.reader.IsValidAddress(address):
3302 self.output_words(f, address - 8, address + 32, address, "Dump",
3303 self.heap.MachinePointerSize())
3305 if self.heap.IsPointerCompressed():
3306 self.output_words(f, address - 8, address + 32, address,
3307 "Tagged Dump", self.heap.TaggedPointerSize())
3311 self.output_ascii(f, address, address + 256, address)
3315 self.output_disasm_range(f, address - 16, address + 16, address, True)
3317 aligned_res, unaligned_res = self.reader.FindWordList(address)
3322 self.output_find_results(f, aligned_res)
3327 self.output_find_results(f, unaligned_res)
3332 self.output_footer(f)
3338 def output_disasm_pc(self, f):
3339 address = self.reader.ExceptionIP()
3340 if not self.reader.IsValidAddress(address):
3342 self.output_disasm_range(f, address - 16, address + 16, address, True)
3406 def __init__(self, port_number, switches, minidump_name):
3409 self.dumppath = splitpath[0]
3410 self.dumpfilename = splitpath[1]
3411 self.default_formatter = InspectionWebFormatter(
3412 switches, minidump_name, self)
3413 self.formatters = { self.dumpfilename : self.default_formatter }
3414 self.switches = switches
3416 def output_dump_desc_field(self, f, name):
3418 descfile = open(os.path.join(self.dumppath, name + ".desc"), "r")
3427 def set_dump_desc(self, name, description):
3430 fname = os.path.join(self.dumppath, name)
3439 def get_dump_formatter(self, name):
3441 return self.default_formatter
3445 formatter = self.formatters.get(name, None)
3449 self.switches, os.path.join(self.dumppath, name), self)
3450 self.formatters[name] = formatter
3455 def output_dumps(self, f):
3465 for fname in os.listdir(self.dumppath):
3467 mtime = os.stat(os.path.join(self.dumppath, fname)).st_mtime
3482 self.output_dump_desc_field(f, fname)
3490 def __init__(self, reader, heap):
3491 cmd.Cmd.__init__(self)
3492 self.reader = reader
3493 self.heap = heap
3494 self.padawan = InspectionPadawan(reader, heap)
3495 self.prompt = "(grok) "
3497 self.dd_start = 0
3498 self.dd_num = 0x10
3499 self.u_start = 0
3500 self.u_num = 0
3502 def EvalExpression(self, expr):
3510 for register,value in self.reader.ContextDescriptor().fields]
3514 expr = expr.replace("$"+register, str(self.reader.Register(register)))
3521 def ParseAddressExpr(self, expr):
3524 result = self.EvalExpression(expr)
3534 def do_help(self, cmd=None):
3549 return super(InspectionShell, self).do_help(cmd)
3551 def do_p(self, cmd):
3553 return self.do_print(cmd)
3555 def do_print(self, cmd):
3560 print(self.EvalExpression(cmd))
3564 def do_da(self, address):
3566 return self.do_display_ascii(address)
3568 def do_display_ascii(self, address):
3572 address = self.ParseAddressExpr(address)
3573 string = self.reader.ReadAsciiString(address)
3575 print("Not an ASCII string at %s" % self.reader.FormatIntPtr(address))
3579 def do_dsa(self, address):
3581 return self.do_display_stack_ascii(address)
3583 def do_display_stack_ascii(self, address):
3587 if self.reader.exception is None:
3593 address = self.ParseAddressExpr(address)
3594 self.padawan.PrintStackTraceMessage(address)
3596 def do_dd(self, args):
3601 If the num is not specified, a default value of 16 words is usif not self.Is
3608 self.dd_start = self.ParseAddressExpr(args[0])
3609 self.dd_num = int(args[1], 16) if len(args) > 1 else 0x10
3611 self.dd_start += self.dd_num * self.reader.MachinePointerSize()
3612 if not self.reader.IsAlignedAddress(self.dd_start):
3614 end = self.dd_start + self.reader.MachinePointerSize() * self.dd_num
3615 self.padawan.InterpretMemory(self.dd_start, end)
3617 def do_do(self, address):
3619 return self.do_display_object(address)
3621 def do_display_object(self, address):
3628 address = self.ParseAddressExpr(address)
3629 if self.reader.IsAlignedAddress(address):
3631 elif not self.heap.IsTaggedObjectAddress(address):
3634 heap_object = self.padawan.SenseObject(address)
3640 def do_dso(self, args):
3642 return self.do_display_stack_objects(args)
3644 def do_display_stack_objects(self, args):
3653 start = self.reader.StackTop()
3654 end = self.reader.StackBottom()
3657 start = self.ParseAddressExpr(args[0])
3658 end = self.ParseAddressExpr(args[1]) if len(args) > 1 else end
3659 objects = self.heap.FindObjectPointers(start, end)
3661 heap_object = self.padawan.SenseObject(address)
3665 print("%s %s" % (self.padawan.FormatIntPtr(address), info))
3667 def do_do_desc(self, address):
3671 start = self.ParseAddressExpr(address)
3673 DescriptorArray(FixedArray(self.heap, None, start)).Print(Printer())
3675 def do_do_map(self, address):
3679 start = self.ParseAddressExpr(address)
3681 Map(self.heap, None, start).Print(Printer())
3683 def do_do_trans(self, address):
3687 start = self.ParseAddressExpr(address)
3689 TransitionArray(FixedArray(self.heap, None, start)).Print(Printer())
3691 def do_dp(self, address):
3693 return self.do_display_page(address)
3695 def do_display_page(self, address):
3702 address = self.ParseAddressExpr(address)
3703 page_address = address & ~self.heap.PageAlignmentMask()
3704 if self.reader.IsValidAddress(page_address):
3710 def do_k(self, arguments):
3718 self.padawan.PrintKnowledge()
3720 def do_ko(self, address):
3722 return self.do_known_oldspace(address)
3724 def do_known_oldspace(self, address):
3730 address = self.ParseAddressExpr(address)
3731 page_address = address & ~self.heap.PageAlignmentMask()
3732 self.padawan.known_first_old_page = page_address
3734 def do_km(self, address):
3736 return self.do_known_map(address)
3738 def do_known_map(self, address):
3744 address = self.ParseAddressExpr(address)
3745 page_address = address & ~self.heap.PageAlignmentMask()
3746 self.padawan.known_first_map_page = page_address
3748 def do_list(self, smth):
3757 self.reader.ForEachMemoryRegion(print_region)
3759 def do_lm(self, arg):
3761 return self.do_list_modules(arg)
3763 def do_list_modules(self, arg):
3770 for module in self.reader.module_list.modules:
3772 name = GetModuleName(self.reader, module).lower()
3774 PrintModuleDetails(self.reader, module)
3776 PrintModuleDetails(self.reader, module)
3779 def do_s(self, word):
3781 return self.do_search(word)
3783 def do_search(self, word):
3792 word = self.ParseAddressExpr(word)
3797 "Searching for word %d/0x%s:" % (word, self.reader.FormatIntPtr(word)))
3798 self.reader.FindWord(word)
3800 def do_sh(self, none):
3809 def do_u(self, args):
3811 return self.do_disassemble(args)
3813 def do_disassemble(self, args):
3822 self.u_start = self.ParseAddressExpr(args[0])
3823 self.u_size = self.ParseAddressExpr(args[1]) if len(args) > 1 else 0x20
3829 if not self.reader.IsValidAddress(self.u_start):
3831 self.reader.FormatIntPtr(self.u_start)))
3833 lines = self.reader.GetDisasmLines(self.u_start, self.u_size)
3836 self.reader.FormatIntPtr(self.u_start)))
3844 print(FormatDisasmLine(self.u_start, self.heap, line))
3846 self.u_start += lines[-1][0]
3849 def do_EOF(self, none):