Lines Matching refs:reader
122 def FullDump(reader, heap):
124 def dump_region(reader, start, size, location):
130 is_executable = reader.IsProbableExecutableRegion(location, size)
131 is_ascii = reader.IsProbableASCIIRegion(location, size)
134 lines = reader.GetDisasmLines(start, size)
148 byte = ctypes.c_uint8.from_buffer(reader.minidump, slot + i).value
158 print("%s %s |%s|" % (reader.FormatIntPtr(addr),
164 print("%s - %s" % (reader.FormatIntPtr(start),
165 reader.FormatIntPtr(start + size)))
167 for i in range(0, size, reader.MachinePointerSize()):
169 maybe_address = reader.ReadUIntPtr(slot)
171 print("%s: %s" % (reader.FormatIntPtr(slot),
172 reader.FormatIntPtr(maybe_address)))
177 reader.ForEachMemoryRegion(dump_region)
610 """Minidump (.dmp) reader."""
910 def is_in(reader, start, size, location):
931 def search_inside_region(reader, start, size, location):
935 if reader._ReadWord(loc) == word:
937 print("%s: %s" % (reader.FormatIntPtr(slot),
938 reader.FormatIntPtr(word)))
944 def search_inside_region(reader, start, size, location):
947 if reader._ReadWord(loc) == word:
1165 if heap.reader.arch == MD_CPU_ARCHITECTURE_X86:
1205 self.heap.reader.FormatIntPtr(self.address),
1209 field_value = self.heap.reader.ReadTagged(self.address + offset)
1213 field_value = self.heap.reader.ReadTagged(self.address + offset)
1279 return self.heap.reader.ReadU8(self.address + offset)
1282 return self.heap.reader.ReadTagged(self.address + offset)
1330 heap.reader.ReadU8(self.address + self.InstanceTypeOffset())
1358 self.chars = heap.reader.ReadBytes(self.address + self.CharsOffset(),
1374 reader = heap.reader
1376 reader.ReadU32(self.address + ExternalString.RESOURCE_OFFSET)
1378 if not reader.IsValidAddress(self.resource): return
1381 if not reader.IsValidAddress(string_impl_address): return
1382 string_impl = reader.ReadU32(string_impl_address)
1385 if not reader.IsValidAddress(chars_ptr_address): return
1386 chars_ptr = reader.ReadU32(chars_ptr_address)
1387 if not reader.IsValidAddress(chars_ptr): return
1388 raw_chars = reader.ReadBytes(chars_ptr, 2 * self.length)
1471 p.Print("FixedArray(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1606 heap.reader.ReadU32(self.address + self.CodeEntryOffset())
1612 p.Print("JSFunction(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1632 (self.heap.reader.FormatIntPtr(self.address), inferred_name)
1670 heap.reader.ReadU32(self.StartPositionAndTypeOffset())
1673 heap.reader.ReadU32(self.EndPositionOffset())
1714 p.Print("CodeCache(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1738 heap.reader.ReadU32(self.address + self.InstructionSizeOffset())
1741 lines = self.heap.reader.GetDisasmLines(self.entry, self.instruction_size)
1742 p.Print("Code(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1785 def __init__(self, reader, stack_map):
1786 self.reader = reader
1799 if not self.reader.IsValidAddress(address): return None
1800 map_tagged_address = self.reader.ReadTagged(address)
1827 if not self.reader.IsValidAddress(address): return None
1834 return self.reader.MachinePointerSize()
1837 return self.reader.TaggedPointerSize()
1840 return self.reader.IsPointerCompressed()
1850 return self.reader.IsValidAddress(address)
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:
1872 if self.reader.Is64() and not self.reader.IsPointerCompressed():
1877 if self.reader.Is64() and not self.reader.IsPointerCompressed():
1882 if not self.reader.IsValidAddress(address): return " "
1883 if self.reader.IsExceptionStackAddress(address): return "S"
1884 if self.reader.IsModuleAddress(address): return "C"
1887 if self.reader.IsAnyExceptionStackAddress(address): return "s"
1893 address = self.reader.FormatIntPtr(address)
1898 if not self.reader.IsValidAlignedAddress(slot): return None
1901 if not self.reader.IsValidAlignedAddress(address): return None
1906 if self.reader.IsExceptionStackAddress(address):
1910 target_address = self.reader.ReadUIntPtr(address)
1911 return "[%+02d]=%s %s" % (offset, self.reader.FormatIntPtr(target_address),
1916 def find_object_in_region(reader, start, size, location):
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)
1922 map_address = self.reader.ReadTagged(tagged_address - 1)
1927 self.reader.ForEachMemoryRegion(find_object_in_region)
1929 find_object_in_region(self.reader, start, end-start, None)
1958 def __init__(self, minidump_name, reader):
1974 self.reader = reader
1989 exception_thread = self.reader.thread_map[self.reader.exception.thread_id]
1990 stack_top = self.reader.ExceptionSP()
1993 frame_pointer = self.reader.ExceptionFP()
1996 self.reader.MachinePointerSize()):
2000 self.reader.MachinePointerSize()):
2001 maybe_address = self.reader.ReadUIntPtr(slot)
2007 self.styles[self.reader.ExceptionIP()] = "pc"
2031 def __init__(self, reader, heap):
2032 self.reader = reader
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)
2080 if not self.reader.Is64() or value == 0: return None
2103 if self.reader.IsValidAddress(address):
2104 map_tagged_address = self.reader.ReadTagged(address)
2132 return "Unknown(%s)" % self.reader.FormatIntPtr(tagged_address)
2145 self.reader.FormatIntPtr(self.known_first_map_page),
2146 self.reader.FormatIntPtr(self.known_first_old_page)))
2152 if not self.reader.IsValidAddress(slot): break
2153 message = self.reader.ReadAsciiString(slot)
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)
2186 ptr_size = self.reader.MachinePointerSize()
2187 assert self.reader.ReadUIntPtr(slot) & 0xFFFFFFFF == STACK_TRACE_MARKER
2198 value = self.reader.ReadUIntPtr(slot)
2209 ptr_size = self.reader.MachinePointerSize()
2211 if not self.reader.IsValidAddress(slot): return None
2212 value = self.reader.ReadUIntPtr(slot)
2217 ptr_size = self.reader.MachinePointerSize()
2232 ptr_size = self.reader.MachinePointerSize()
2243 message_start = self.reader.ReadUIntPtr(message_slot + ptr_size * 4)
2244 message = self.reader.ReadAsciiString(message_start)
2253 ptr1 = self.reader.ReadUIntPtr(slot + ptr_size * 2)
2254 ptr2 = self.reader.ReadUIntPtr(slot + ptr_size * 3)
2271 ptr_size = self.reader.MachinePointerSize()
2290 if not self.reader.IsExceptionStackAddress(address): return 0
2291 next_address = self.reader.ReadUIntPtr(address)
2298 ptr_size = self.reader.MachinePointerSize()
2301 while self.reader.IsExceptionStackAddress(address):
2302 prev_addr = self.reader.ReadUIntPtr(address-ptr_size)
2308 address = self.reader.ReadUIntPtr(address)
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)
2355 length = self.reader.ReadTagged(slot + ptr_size)
2368 if self.reader.IsExceptionStackAddress(maybe_address):
2370 self.reader.ReadUIntPtr(maybe_address) & 0xFFFFFFFF
2377 maybe_symbol = self.reader.FindSymbol(maybe_address)
2387 if not self.reader.IsExceptionStackAddress(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),
2745 self.reader = MinidumpReader(switches, minidump_name)
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)
2794 straddress = "0x" + self.reader.FormatIntPtr(maybeaddress)
2796 if not self.reader.IsValidAddress(maybeaddress):
2805 straddress = "0x" + self.reader.FormatTagged(maybeaddress)
2806 struncompressed = "0x" + self.reader.FormatIntPtr(uncompressed)
2808 if not self.reader.IsValidAddress(maybeaddress):
2831 exception_thread = self.reader.thread_map[self.reader.exception.thread_id]
2832 stack_top = self.reader.ExceptionSP()
2851 dt = datetime.datetime.fromtimestamp(self.reader.header.time_date_stampt)
2862 self.reader.ForEachMemoryRegion(print_region)
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 +
2905 for module in self.reader.module_list.modules:
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:])
2953 if not self.reader.IsValidAddress(address):
2956 region = self.reader.FindRegion(address)
2973 region = self.reader.FindRegion(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():
3050 self.output_comment_box(f, "sv-" + self.reader.FormatIntPtr(slot),
3060 region = self.reader.FindRegion(highlight_address)
3096 code = self.reader.ReadU8(address)
3112 if not self.reader.IsValidAddress(address):
3115 region = self.reader.FindRegion(address)
3125 region = self.reader.FindRegion(highlight_address)
3131 lines = self.reader.GetDisasmLines(start_address, count)
3141 lines = self.reader.GetDisasmLines(highlight_address, count)
3213 if self.heap.reader.arch == MD_CPU_ARCHITECTURE_X86:
3244 self.reader.FormatIntPtr(address),
3297 if not self.reader.IsValidAddress(address):
3317 aligned_res, unaligned_res = self.reader.FindWordList(address)
3339 address = self.reader.ExceptionIP()
3340 if not self.reader.IsValidAddress(address):
3490 def __init__(self, reader, heap):
3492 self.reader = reader
3494 self.padawan = InspectionPadawan(reader, heap)
3510 for register,value in self.reader.ContextDescriptor().fields]
3514 expr = expr.replace("$"+register, str(self.reader.Register(register)))
3573 string = self.reader.ReadAsciiString(address)
3575 print("Not an ASCII string at %s" % self.reader.FormatIntPtr(address))
3587 if self.reader.exception is None:
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
3629 if self.reader.IsAlignedAddress(address):
3653 start = self.reader.StackTop()
3654 end = self.reader.StackBottom()
3704 if self.reader.IsValidAddress(page_address):
3752 def print_region(reader, start, size, location):
3753 print(" %s - %s (%d bytes)" % (reader.FormatIntPtr(start),
3754 reader.FormatIntPtr(start + size),
3757 self.reader.ForEachMemoryRegion(print_region)
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)
3797 "Searching for word %d/0x%s:" % (word, self.reader.FormatIntPtr(word)))
3798 self.reader.FindWord(word)
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)))
3876 def GetModuleName(reader, module):
3877 name = reader.ReadMinidumpString(module.module_name_rva)
3883 def PrintModuleDetails(reader, module):
3884 print("%s" % GetModuleName(reader, module))
3889 print(" base: %s" % reader.FormatIntPtr(module.base_of_image))
3890 print(" end: %s" % reader.FormatIntPtr(module.base_of_image +
3899 reader = MinidumpReader(options, minidump_name)
3902 _AnalyzeMinidump(options, reader)
3903 reader.Dispose()
3906 def _AnalyzeMinidump(options, reader):
3909 stack_top = reader.ExceptionSP()
3910 stack_bottom = reader.StackBottom()
3911 stack_map = {reader.ExceptionIP(): -1}
3912 for slot in range(stack_top, stack_bottom, reader.MachinePointerSize()):
3913 maybe_address = reader.ReadUIntPtr(slot)
3917 heap = V8Heap(reader, stack_map)
3918 padawan = InspectionPadawan(reader, heap)
3921 if reader.exception is None:
3931 exception_thread = reader.ExceptionThread()
3933 print(" code: %08X" % reader.exception.exception.code)
3935 context = CONTEXT_FOR_ARCH[reader.arch]
3938 register_value = reader.Register(r)
3942 if reader.arch in [MD_CPU_ARCHITECTURE_ARM, MD_CPU_ARCHITECTURE_ARM64]:
3943 print(" cpsr: %s" % bin(reader.exception_context.cpsr)[2:])
3945 print(" eflags: %s" % bin(reader.exception_context.eflags)[2:])
3949 for module in reader.module_list.modules:
3950 name = GetModuleName(reader, module)
3953 reader.TryLoadSymbolsFor(name, module)
3956 print(" stack-top: %s" % heap.FormatIntPtr(reader.StackTop()))
3957 print(" stack-bottom: %s" % heap.FormatIntPtr(reader.StackBottom()))
3964 eip_symbol = reader.FindSymbol(reader.ExceptionIP())
3967 disasm_start = reader.ExceptionIP() - EIP_PROXIMITY
3970 full_range = reader.FindRegion(reader.ExceptionIP())
3975 lines = reader.GetDisasmLines(disasm_start, disasm_bytes)
3986 heap = V8Heap(reader, None)
3989 FullDump(reader, heap)
3992 InspectionShell(reader, heap).onecmd(options.command)
3996 InspectionShell(reader, heap).cmdloop("type help to get help")
4000 if reader.exception is not None: