Lines Matching refs:heap
62 heap. Code objects are disassembled and the addresses linked from the
122 def FullDump(reader, heap):
136 print(FormatDisasmLine(start, heap, line))
170 heap_object = heap.FindObject(maybe_address)
1154 def FormatDisasmLine(start, heap, line):
1156 stack_slot = heap.stack_map.get(line_address)
1160 code = AnnotateAddresses(heap, line[1])
1165 if heap.reader.arch == MD_CPU_ARCHITECTURE_X86:
1177 def AnnotateAddresses(heap, line):
1181 object = heap.FindObject(maybe_address)
1189 def __init__(self, heap, map, address):
1190 self.heap = heap
1205 self.heap.reader.FormatIntPtr(self.address),
1209 field_value = self.heap.reader.ReadTagged(self.address + offset)
1210 return self.heap.FindObjectOrSmi(field_value)
1213 field_value = self.heap.reader.ReadTagged(self.address + offset)
1214 if self.heap.IsSmi(field_value):
1215 return self.heap.SmiUntag(field_value)
1225 return self.heap.TaggedPointerSize()
1241 return self.InstanceSizesOffset() + self.heap.IntSize()
1257 return self.InstanceAttributesOffset() + self.heap.IntSize()
1260 return self.BitField3Offset() + self.heap.TaggedPointerSize()
1263 return self.PrototypeOffset() + self.heap.TaggedPointerSize()
1266 return self.ConstructorOrBackPointerOffset() + self.heap.TaggedPointerSize()
1270 self.heap.TaggedPointerSize())
1273 return self.DescriptorsOffset() + self.heap.TaggedPointerSize()
1276 return self.CodeCacheOffset() + self.heap.TaggedPointerSize()
1279 return self.heap.reader.ReadU8(self.address + offset)
1282 return self.heap.reader.ReadTagged(self.address + offset)
1327 def __init__(self, heap, map, address):
1328 HeapObject.__init__(self, heap, map, address)
1330 heap.reader.ReadU8(self.address + self.InstanceTypeOffset())
1336 return self.heap.TaggedPointerSize() * 2
1338 def __init__(self, heap, map, address):
1339 HeapObject.__init__(self, heap, map, address)
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(),
1372 def __init__(self, heap, map, address):
1373 String.__init__(self, heap, map, address)
1374 reader = heap.reader
1397 return self.heap.TaggedPointerSize() * 3
1400 return self.heap.TaggedPointerSize() * 4
1402 def __init__(self, heap, map, address):
1403 String.__init__(self, heap, map, address)
1427 return self.heap.TaggedPointerSize()
1430 return self.ToStringOffset() + self.heap.TaggedPointerSize()
1433 return self.ToNumberOffset() + self.heap.TaggedPointerSize()
1435 def __init__(self, heap, map, address):
1436 HeapObject.__init__(self, heap, map, address)
1455 return self.heap.TaggedPointerSize()
1458 return self.heap.TaggedPointerSize() * 2
1461 return self.ElementsOffset() + self.heap.TaggedPointerSize() * i
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))
1598 return 3 * self.heap.TaggedPointerSize()
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)
1612 p.Print("JSFunction(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1632 (self.heap.reader.FormatIntPtr(self.address), inferred_name)
1648 return 2 * self.heap.TaggedPointerSize()
1651 return 7 * self.heap.TaggedPointerSize()
1654 return 9 * self.heap.TaggedPointerSize()
1657 return 12 * self.heap.TaggedPointerSize() + 4 * self.heap.IntSize()
1660 return 12 * self.heap.TaggedPointerSize() + 5 * self.heap.IntSize()
1662 def __init__(self, heap, map, address):
1663 HeapObject.__init__(self, heap, map, address)
1668 if heap.TaggedPointerSize() == 8:
1670 heap.reader.ReadU32(self.StartPositionAndTypeOffset())
1673 heap.reader.ReadU32(self.EndPositionOffset())
1690 return self.heap.TaggedPointerSize()
1693 return self.SourceOffset() + self.heap.TaggedPointerSize()
1695 def __init__(self, heap, map, address):
1696 HeapObject.__init__(self, heap, map, address)
1703 return self.heap.TaggedPointerSize()
1706 return self.DefaultCacheOffset() + self.heap.TaggedPointerSize()
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))
1726 return self.heap.TaggedPointerSize()
1729 def HeaderSize(heap):
1730 return (heap.TaggedPointerSize() + heap.IntSize() + \
1731 4 * heap.TaggedPointerSize() + 3 * heap.IntSize() + \
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())
1741 lines = self.heap.reader.GetDisasmLines(self.entry, self.instruction_size)
1742 p.Print("Code(%s) {" % self.heap.reader.FormatIntPtr(self.address))
1750 return FormatDisasmLine(self.entry, self.heap, line)
1934 def __init__(self, heap, known_name):
1935 HeapObject.__init__(self, heap, None, None)
1943 def __init__(self, heap, known_name, instance_type):
1944 HeapObject.__init__(self, heap, None, None)
2031 def __init__(self, reader, heap):
2033 self.heap = heap
2041 return getattr(self.heap, name)
2044 return tagged_address & self.heap.PageAlignmentMask()
2047 page_address = tagged_address & ~self.heap.PageAlignmentMask()
2051 page_address = tagged_address & ~self.heap.PageAlignmentMask()
2055 page_address = tagged_address & ~self.heap.PageAlignmentMask()
2078 value = self.heap.SmiUntag(address)
2086 if self.heap.IsSmi(address):
2088 if not self.heap.IsTaggedAddress(address): return None
2100 found_obj = self.heap.FindObject(tagged_address)
2121 found_map = self.heap.FindMap(tagged_address)
2194 print("Stack Message (start=%s):" % self.heap.FormatIntPtr(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))
2223 print("Error Message (start=%s):" % self.heap.FormatIntPtr(slot))
2250 print(" message start: %s" % self.heap.FormatIntPtr(message_start))
2251 print(" stack_start: %s" % self.heap.FormatIntPtr(stack_start ))
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 ))
2277 address = self.heap.FormatIntPtr(int(address_org, 16))
2303 if self.heap.IsTaggedObjectAddress(prev_addr):
2356 if self.heap.IsSmi(length):
2357 length = self.heap.SmiUntag(length)
2360 relative_offset = self.heap.RelativeOffset(slot, maybe_address)
2393 address_type_marker = self.heap.AddressTypeMarker(maybe_address)
2402 heap_object = self.heap.FindObject(maybe_address)
2748 # Set up the heap
2759 self.heap = V8Heap(self.reader, stack_map)
2761 self.padawan = InspectionPadawan(self.reader, self.heap)
2837 self.heap.MachinePointerSize())
2959 self.heap.MachinePointerSize())
2962 "Tagged Dump", self.heap.TaggedPointerSize())
3196 stack_slot = self.heap.stack_map.get(line_address)
3213 if self.heap.reader.arch == MD_CPU_ARCHITECTURE_X86:
3289 page_address = address & ~self.heap.PageAlignmentMask()
3303 self.heap.MachinePointerSize())
3305 if self.heap.IsPointerCompressed():
3307 "Tagged Dump", self.heap.TaggedPointerSize())
3490 def __init__(self, reader, heap):
3493 self.heap = heap
3494 self.padawan = InspectionPadawan(reader, heap)
3631 elif not self.heap.IsTaggedObjectAddress(address):
3659 objects = self.heap.FindObjectPointers(start, end)
3673 DescriptorArray(FixedArray(self.heap, None, start)).Print(Printer())
3681 Map(self.heap, None, start).Print(Printer())
3689 TransitionArray(FixedArray(self.heap, None, start)).Print(Printer())
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
3703 page_address = address & ~self.heap.PageAlignmentMask()
3712 Teach V8 heap layout information to the inspector.
3715 dumping data. The first page of each heap space is of particular interest
3726 Teach V8 heap layout information to the inspector.
3731 page_address = address & ~self.heap.PageAlignmentMask()
3740 Teach V8 heap layout information to the inspector.
3745 page_address = address & ~self.heap.PageAlignmentMask()
3844 print(FormatDisasmLine(self.u_start, self.heap, line))
3907 heap = None
3917 heap = V8Heap(reader, stack_map)
3918 padawan = InspectionPadawan(reader, heap)
3940 heap.FormatIntPtr(register_value)))
3956 print(" stack-top: %s" % heap.FormatIntPtr(reader.StackTop()))
3957 print(" stack-bottom: %s" % heap.FormatIntPtr(reader.StackBottom()))
3982 print(FormatDisasmLine(disasm_start, heap, line))
3985 if heap is None:
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")