Lines Matching refs:address
229 ("address", ctypes.c_uint64),
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):
790 if start <= address < end: return module
793 def ReadU8(self, address):
794 location = self.FindLocation(address)
797 def ReadU32(self, address):
798 location = self.FindLocation(address)
801 def ReadU64(self, address):
802 location = self.FindLocation(address)
816 def ReadTagged(self, address):
818 return self.ReadU32(address)
819 return self.ReadU64(address)
821 def ReadUIntPtr(self, address):
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)
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)
856 address += 1
956 def FindLocation(self, address):
960 if r.start <= address < r.start + r.size:
961 return self.memory_list64.base_rva + offset + address - r.start
965 if r.start <= address < r.start + r.memory.data_size:
966 return r.memory.rva + address - r.start
969 def GetDisasmLines(self, address, size):
974 location = self.FindLocation(address)
1101 # Returns true if address is covered by some module that has loaded symbols.
1110 # Find symbol covering the given address and return its name in format
1164 # than the absolute instruction address).
1189 def __init__(self, heap, map, address):
1192 self.address = address
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)
1285 p.Print("Map(%08x)" % (self.address))
1327 def __init__(self, heap, map, address):
1328 HeapObject.__init__(self, heap, map, address)
1330 heap.reader.ReadU8(self.address + self.InstanceTypeOffset())
1338 def __init__(self, heap, map, address):
1339 HeapObject.__init__(self, heap, map, address)
1356 def __init__(self, heap, map, address):
1357 String.__init__(self, heap, map, address)
1358 self.chars = heap.reader.ReadBytes(self.address + self.CharsOffset(),
1372 def __init__(self, heap, map, address):
1373 String.__init__(self, heap, map, address)
1376 reader.ReadU32(self.address + ExternalString.RESOURCE_OFFSET)
1402 def __init__(self, heap, map, address):
1403 String.__init__(self, heap, map, address)
1435 def __init__(self, heap, map, address):
1436 HeapObject.__init__(self, heap, map, address)
1445 return "Oddball(%08x, <%s>)" % (self.address, str(self.to_string))
1450 return "Oddball(%08x, kind=%s)" % (self.address, kind)
1466 def __init__(self, heap, map, address):
1467 HeapObject.__init__(self, heap, map, address)
1471 p.Print("FixedArray(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1488 return "FixedArray(%08x, length=%d)" % (self.address, self.length)
1542 p.Print("Descriptors(%08x, length=%d)" % (array.address, length))
1547 p.Print("0x%x" % (array.address + array.MemberOffset(i)))
1575 p.Print("Transitions(%08x, length=%d)" % (array.address, length))
1603 def __init__(self, heap, map, address):
1604 HeapObject.__init__(self, heap, map, 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)
1662 def __init__(self, heap, map, address):
1663 HeapObject.__init__(self, heap, map, address)
1695 def __init__(self, heap, map, address):
1696 HeapObject.__init__(self, heap, map, address)
1708 def __init__(self, heap, map, address):
1709 HeapObject.__init__(self, heap, map, address)
1714 p.Print("CodeCache(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1734 def __init__(self, heap, map, address):
1735 HeapObject.__init__(self, heap, map, address)
1736 self.entry = self.address + Code.HeaderSize(heap)
1738 heap.reader.ReadU32(self.address + self.InstructionSizeOffset())
1742 p.Print("Code(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1798 address = tagged_address - 1
1799 if not self.reader.IsValidAddress(address): return None
1800 map_tagged_address = self.reader.ReadTagged(address)
1803 meta_map = Map(self, None, address)
1814 object = cls(self, map, address)
1819 address = self.FindMapAddress(tagged_address)
1820 if not address: return None
1821 object = Map(self, None, address)
1826 address = tagged_address - 1
1827 if not self.reader.IsValidAddress(address): return None
1828 return address
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
1868 def IsTaggedAddress(self, address):
1869 return (address & self.ObjectAlignmentMask()) == 1
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)
1894 if marker == " ": return address
1895 return "%s %s" % (address, marker)
1897 def RelativeOffset(self, slot, address):
1899 if self.IsTaggedObjectAddress(address):
1900 address -= 1
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)
1982 def save_page_address(self, page_kind, address):
1984 f.write("P %s 0x%x\n" % (page_kind, address))
1997 # stack address
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
2022 f.write("C 0x%x %s\n" % (address, comment))
2025 def get_comment(self, address):
2026 return self.address_comments.get(address, "")
2067 def IsFrameMarker(self, slot, address):
2077 def FormatSmi(self, address):
2078 value = self.heap.SmiUntag(address)
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
2089 tagged_address = address
2102 address = tagged_address - 1
2103 if self.reader.IsValidAddress(address):
2104 map_tagged_address = self.reader.ReadTagged(address)
2110 return cls(self, map, address)
2161 Returns the first address where the normal stack starts again.
2246 # Make sure the address is word aligned
2277 address = self.heap.FormatIntPtr(int(address_org, 16))
2278 if address_org != address:
2279 message = message.replace(address_org, address)
2287 def TryInferFramePointer(self, slot, address):
2290 if not self.reader.IsExceptionStackAddress(address): return 0
2291 next_address = self.reader.ReadUIntPtr(address)
2292 if next_address == address: return 0
2293 address = next_address
2296 def TryInferContext(self, address):
2301 while self.reader.IsExceptionStackAddress(address):
2302 prev_addr = self.reader.ReadUIntPtr(address-ptr_size)
2308 address = self.reader.ReadUIntPtr(address)
2314 address,count = possible_context[-1]
2316 self.context = address
2323 # Follow the framepointer into the address range
2523 var address_str = "address-";
2535 function send_comment(address, comment) {
2537 address = encodeURIComponent(address)
2540 "setcomment?%(query_dump)s&address=" + address +
2566 function onpage(kind, address) {
2569 address = encodeURIComponent(address)
2577 "&address=" + address);
2664 address = query_components.get("val", [])
2665 if len(address) != 1:
2670 out_buffer, address[0])
2673 address = query_components.get("val", [])
2675 if len(address) != 1:
2680 out_buffer, address[0], exact[0])
2683 address = query_components.get("val", [])
2684 datakind = query_components.get("type", ["address"])
2685 if len(address) == 1 and len(datakind) == 1:
2688 out_buffer, address[0], datakind[0])
2704 address = query_components.get("address", [])
2706 if len(address) == 1 and len(comment) == 1:
2707 address = address[0]
2709 self.formatter(query_components).set_comment(address, comment)
2716 address = query_components.get("address", [""])
2717 if len(kind) == 1 and len(address) == 1:
2719 address = address[0]
2720 self.formatter(query_components).set_page_address(kind, address)
2770 address = int(straddress, 0)
2771 self.comments.set_comment(address, comment)
2773 print("Invalid address")
2777 address = int(straddress, 0)
2779 self.padawan.known_first_old_page = address
2781 self.padawan.known_first_map_page = address
2782 self.comments.save_page_address(kind, address)
2784 print("Invalid address")
2786 def td_from_address(self, f, address):
2787 f.write("<td %s>" % self.comments.get_style_class_string(address))
2867 f.write("<th>Start address</th>")
2868 f.write("<th>End address</th>")
2945 def format_object(self, address):
2946 heap_object = self.padawan.SenseObject(address)
2952 address = int(straddress, 0)
2953 if not self.reader.IsValidAddress(address):
2954 f.write("<h3>Address 0x%x not found in the dump.</h3>" % address)
2956 region = self.reader.FindRegion(address)
2957 if datakind == "address":
2958 self.output_words(f, region[0], region[0] + region[1], address, "Dump",
2961 self.output_words(f, region[0], region[0] + region[1], address,
2964 self.output_ascii(f, region[0], region[0] + region[1], address)
2968 f.write("<h3>Unrecognized address format \"%s\".</h3>" % straddress)
3086 address = start + i
3087 if address % 64 == 0:
3088 if address != start:
3090 f.write("0x%08x: " % address)
3091 if address < start_address:
3094 if address == highlight_address:
3096 code = self.reader.ReadU8(address)
3103 if address == highlight_address:
3111 address = int(straddress, 0)
3112 if not self.reader.IsValidAddress(address):
3113 f.write("<h3>Address 0x%x not found in the dump.</h3>" % address)
3115 region = self.reader.FindRegion(address)
3117 f, region[0], region[0] + region[1], address, strexact == "on")
3120 f.write("<h3>Unrecognized address format \"%s\".</h3>" % straddress)
3212 # than the absolute instruction address).
3236 def output_comment_box(self, f, prefix, address):
3237 comment = self.comments.get_comment(address)
3242 "id=%s-address-0x%s onchange=c()%s>" %
3244 self.reader.FormatIntPtr(address),
3258 for address in results:
3260 (self.comments.get_style_class_string(address),
3261 self.format_address(address)))
3283 address = int(straddress, 0)
3286 self.output_comment_box(f, "search-", address)
3289 page_address = address & ~self.heap.PageAlignmentMask()
3297 if not self.reader.IsValidAddress(address):
3298 f.write("<h3>The contents at address %s not found in the dump.</h3>" % \
3302 self.output_words(f, address - 8, address + 32, address, "Dump",
3306 self.output_words(f, address - 8, address + 32, address,
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)
3321 address)
3326 address)
3330 f.write("<h3>No occurrences of 0x%x found in the dump</h3>" % address)
3335 f.write("<h3>Unrecognized address format \"%s\".</h3>" % straddress)
3339 address = self.reader.ExceptionIP()
3340 if not self.reader.IsValidAddress(address):
3342 self.output_disasm_range(f, address - 16, address + 16, address, True)
3522 address = 0;
3528 address = int(result)
3530 print("**** Could not convert '%s' => %s to valid address: %s" % (
3532 return address
3564 def do_da(self, address):
3566 return self.do_display_ascii(address)
3568 def do_display_ascii(self, address):
3570 Print ASCII string starting at specified 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):
3590 if len(address) == 0:
3591 address = None
3593 address = self.ParseAddressExpr(address)
3594 self.padawan.PrintStackTraceMessage(address)
3598 Interpret memory in the given region [address, address + num * word_size)
3602 If no address is given, dd continues printing at the next word.
3604 Synopsis: dd 0x<address>|$register [0x<num>]
3617 def do_do(self, address):
3619 return self.do_display_object(address)
3621 def do_display_object(self, address):
3623 Interpret memory at the given address as a V8 object.
3628 address = self.ParseAddressExpr(address)
3629 if self.reader.IsAlignedAddress(address):
3630 address = address + 1
3631 elif not self.heap.IsTaggedObjectAddress(address):
3634 heap_object = self.padawan.SenseObject(address)
3649 address range.
3660 for address in objects:
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)
3675 def do_do_map(self, address):
3679 start = self.ParseAddressExpr(address)
3683 def do_do_trans(self, address):
3687 start = self.ParseAddressExpr(address)
3691 def do_dp(self, address):
3693 return self.do_display_page(address)
3695 def do_display_page(self, address):
3697 Prints details about the V8 heap page of the given address.
3699 Interpret memory at the given address as being on a V8 heap page
3702 address = self.ParseAddressExpr(address)
3703 page_address = address & ~self.heap.PageAlignmentMask()
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()
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()
3815 Unassemble memory in the region [address, address + size).
3818 Synopsis: u 0x<address> 0x<size>
3826 # Skip the first instruction if we reuse the last address.
3845 # Set the next start address = last line
3926 print(" S = address on the exception stack")
3927 print(" C = address in loaded C/C++ module")
3928 print(" * = address in the minidump")