Lines Matching full:address
214 ("address", ctypes.c_uint64),
684 def IsValidAddress(self, address):
685 return self.FindLocation(address) is not None
687 def ReadU8(self, address):
688 location = self.FindLocation(address)
691 def ReadU32(self, address):
692 location = self.FindLocation(address)
695 def ReadU64(self, address):
696 location = self.FindLocation(address)
699 def ReadUIntPtr(self, address):
701 return self.ReadU64(address)
703 return self.ReadU32(address)
705 return self.ReadU64(address)
707 return self.ReadU32(address)
709 def ReadBytes(self, address, size):
710 location = self.FindLocation(address)
820 def FindLocation(self, address):
824 if r.start <= address < r.start + r.size:
825 return self.memory_list64.base_rva + offset + address - r.start
829 if r.start <= address < r.start + r.memory.data_size:
830 return r.memory.rva + address - r.start
833 def GetDisasmLines(self, address, size):
838 address)
953 # Returns true if address is covered by some module that has loaded symbols.
962 # Find symbol covering the given address and return its name in format
1016 # than the absolute instruction address).
1041 def __init__(self, heap, map, address):
1044 self.address = address
1056 return "HeapObject(%s, %s)" % (self.heap.reader.FormatIntPtr(self.address),
1060 field_value = self.heap.reader.ReadUIntPtr(self.address + offset)
1064 field_value = self.heap.reader.ReadUIntPtr(self.address + offset)
1129 return self.heap.reader.ReadU8(self.address + offset)
1132 p.Print("Map(%08x)" % (self.address))
1170 def __init__(self, heap, map, address):
1171 HeapObject.__init__(self, heap, map, address)
1173 heap.reader.ReadU8(self.address + self.InstanceTypeOffset())
1181 def __init__(self, heap, map, address):
1182 HeapObject.__init__(self, heap, map, address)
1199 def __init__(self, heap, map, address):
1200 String.__init__(self, heap, map, address)
1201 self.chars = heap.reader.ReadBytes(self.address + self.CharsOffset(),
1215 def __init__(self, heap, map, address):
1216 String.__init__(self, heap, map, address)
1219 reader.ReadU32(self.address + ExternalString.RESOURCE_OFFSET)
1245 def __init__(self, heap, map, address):
1246 String.__init__(self, heap, map, address)
1278 def __init__(self, heap, map, address):
1279 HeapObject.__init__(self, heap, map, address)
1288 return "Oddball(%08x, <%s>)" % (self.address, str(self.to_string))
1293 return "Oddball(%08x, kind=%s)" % (self.address, kind)
1309 def __init__(self, heap, map, address):
1310 HeapObject.__init__(self, heap, map, address)
1314 p.Print("FixedArray(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1331 return "FixedArray(%08x, length=%d)" % (self.address, self.length)
1385 p.Print("Descriptors(%08x, length=%d)" % (array.address, length))
1390 p.Print("0x%x" % (array.address + array.MemberOffset(i)))
1418 p.Print("Transitions(%08x, length=%d)" % (array.address, length))
1446 def __init__(self, heap, map, address):
1447 HeapObject.__init__(self, heap, map, address)
1449 heap.reader.ReadU32(self.address + self.CodeEntryOffset())
1455 p.Print("JSFunction(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1475 (self.heap.reader.FormatIntPtr(self.address), inferred_name)
1505 def __init__(self, heap, map, address):
1506 HeapObject.__init__(self, heap, map, address)
1535 def __init__(self, heap, map, address):
1536 HeapObject.__init__(self, heap, map, address)
1548 def __init__(self, heap, map, address):
1549 HeapObject.__init__(self, heap, map, address)
1554 p.Print("CodeCache(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1574 def __init__(self, heap, map, address):
1575 HeapObject.__init__(self, heap, map, address)
1576 self.entry = self.address + Code.HeaderSize(heap)
1578 heap.reader.ReadU32(self.address + self.InstructionSizeOffset())
1582 p.Print("Code(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1635 address = tagged_address - 1
1636 if not self.reader.IsValidAddress(address): return None
1637 map_tagged_address = self.reader.ReadUIntPtr(address)
1640 meta_map = Map(self, None, address)
1651 object = cls(self, map, address)
1657 address = tagged_address - 1
1658 if not self.reader.IsValidAddress(address): return None
1659 object = Map(self, None, address)
1734 def save_page_address(self, page_kind, address):
1736 f.write("P %s 0x%x\n" % (page_kind, address))
1757 def get_style_class(self, address):
1758 return self.styles.get(address, None)
1760 def get_style_class_string(self, address):
1761 style = self.get_style_class(address)
1767 def set_comment(self, address, comment):
1768 self.address_comments[address] = comment
1770 f.write("C 0x%x %s\n" % (address, comment))
1773 def get_comment(self, address):
1774 return self.address_comments.get(address, "")
1819 address = tagged_address - 1
1820 if self.reader.IsValidAddress(address):
1821 map_tagged_address = self.reader.ReadUIntPtr(address)
1827 return cls(self, map, address)
1977 var address_str = "address-";
1988 function send_comment(address, comment) {
1990 address = encodeURIComponent(address)
1993 "setcomment?%(query_dump)s&address=" + address +
2019 function onpage(kind, address) {
2022 address = encodeURIComponent(address)
2030 "&address=" + address);
2109 address = query_components.get("val", [])
2110 if len(address) != 1:
2115 self.wfile, address[0])
2117 address = query_components.get("val", [])
2119 if len(address) != 1:
2124 self.wfile, address[0], exact[0])
2126 address = query_components.get("val", [])
2127 datakind = query_components.get("type", ["address"])
2128 if len(address) == 1 and len(datakind) == 1:
2131 self.wfile, address[0], datakind[0])
2146 address = query_components.get("address", [])
2148 if len(address) == 1 and len(comment) == 1:
2149 address = address[0]
2151 self.formatter(query_components).set_comment(address, comment)
2158 address = query_components.get("address", [""])
2159 if len(kind) == 1 and len(address) == 1:
2161 address = address[0]
2162 self.formatter(query_components).set_page_address(kind, address)
2211 address = int(straddress, 0)
2212 self.comments.set_comment(address, comment)
2214 print "Invalid address"
2218 address = int(straddress, 0)
2220 self.padawan.known_first_old_page = address
2222 self.padawan.known_first_map_page = address
2223 self.comments.save_page_address(kind, address)
2225 print "Invalid address"
2227 def td_from_address(self, f, address):
2228 f.write("<td %s>" % self.comments.get_style_class_string(address))
2293 f.write("<th>Start address</th>")
2294 f.write("<th>End address</th>")
2371 def format_object(self, address):
2372 heap_object = self.padawan.SenseObject(address)
2378 address = int(straddress, 0)
2379 if not self.reader.IsValidAddress(address):
2380 f.write("<h3>Address 0x%x not found in the dump.</h3>" % address)
2382 region = self.reader.FindRegion(address)
2383 if datakind == "address":
2384 self.output_words(f, region[0], region[0] + region[1], address, "Dump")
2386 self.output_ascii(f, region[0], region[0] + region[1], address)
2390 f.write("<h3>Unrecognized address format \"%s\".</h3>" % straddress)
2397 f.write("<h3>Address 0x%x not found in the dump.</h3>\n" %
2476 f.write("<h3>Address %x not found in the dump.</h3>" %
2500 address = start + i
2501 if address % 64 == 0:
2502 if address != start:
2504 f.write("0x%08x: " % address)
2505 if address < start_address:
2508 if address == highlight_address:
2510 code = self.reader.ReadU8(address)
2517 if address == highlight_address:
2525 address = int(straddress, 0)
2526 if not self.reader.IsValidAddress(address):
2527 f.write("<h3>Address 0x%x not found in the dump.</h3>" % address)
2529 region = self.reader.FindRegion(address)
2531 f, region[0], region[0] + region[1], address, strexact == "on")
2534 f.write("<h3>Unrecognized address format \"%s\".</h3>" % straddress)
2619 # than the absolute instruction address).
2643 def output_comment_box(self, f, prefix, address):
2645 "id=\"%s-address-0x%s\" onchange=\"comment()\" value=\"%s\">" %
2647 self.reader.FormatIntPtr(address),
2648 cgi.escape(self.comments.get_comment(address)) or ""))
2661 for address in results:
2663 (self.comments.get_style_class_string(address),
2664 self.format_address(address)))
2686 address = int(straddress, 0)
2689 self.output_comment_box(f, "search-", address)
2692 page_address = address & ~self.heap.PageAlignmentMask()
2700 if not self.reader.IsValidAddress(address):
2701 f.write("<h3>The contents at address %s not found in the dump.</h3>" % \
2705 self.output_words(f, address - 8, address + 32, address, "Dump")
2709 self.output_ascii(f, address, address + 256, address)
2713 self.output_disasm_range(f, address - 16, address + 16, address, True)
2715 aligned_res, unaligned_res = self.reader.FindWordList(address)
2719 address)
2724 address)
2728 f.write("<h3>No occurences of 0x%x found in the dump</h3>\n" % address)
2733 f.write("<h3>Unrecognized address format \"%s\".</h3>" % straddress)
2737 address = self.reader.ExceptionIP()
2738 if not self.reader.IsValidAddress(address):
2740 self.output_disasm_range(f, address - 16, address + 16, address, True)
2895 def do_da(self, address):
2897 Print ASCII string starting at specified address.
2899 address = int(address, 16)
2901 while self.reader.IsValidAddress(address):
2902 code = self.reader.ReadU8(address)
2907 address += 1
2909 print "Not an ASCII string at %s" % self.reader.FormatIntPtr(address)
2915 Interpret memory in the given region [address, address + num * word_size)
2918 Synopsis: dd 0x<address> 0x<num>
2930 print "Address is not contained within the minidump!"
2938 def do_do(self, address):
2940 Interpret memory at the given address as a V8 object. Automatic
2944 address = int(address, 16)
2945 if (address & self.heap.ObjectAlignmentMask()) == 0:
2946 address = address + 1
2947 elif (address & self.heap.ObjectAlignmentMask()) != 1:
2948 print "Address doesn't look like a valid pointer!"
2950 heap_object = self.padawan.SenseObject(address)
2954 print "Address cannot be interpreted as object!"
2956 def do_do_desc(self, address):
2960 start = int(address, 16)
2964 def do_do_map(self, address):
2968 start = int(address, 16)
2972 def do_do_trans(self, address):
2976 start = int(address, 16)
2980 def do_dp(self, address):
2982 Interpret memory at the given address as being on a V8 heap page
2985 address = int(address, 16)
2986 page_address = address & ~self.heap.PageAlignmentMask()
3001 def do_ko(self, address):
3006 address = int(address, 16)
3007 page_address = address & ~self.heap.PageAlignmentMask()
3010 def do_km(self, address):
3015 address = int(address, 16)
3016 page_address = address & ~self.heap.PageAlignmentMask()
3070 Unassemble memory in the region [address, address + size). If the
3072 Synopsis: u 0x<address> 0x<size>
3078 print "Address is not contained within the minidump!"
