grokdump.py: work around int size limits on xrange

tools/grokdump.py

 #!/usr/bin/env python
 #
 # Copyright 2012 the V8 project authors. All rights reserved.
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 #       notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
@@ skipping 117 matching lines @@
 
     if is_executable is not False:
       lines = reader.GetDisasmLines(start, size)
       for line in lines:
         print FormatDisasmLine(start, heap, line)
       print
 
     if is_ascii is not False:
       # Output in the same format as the Unix hd command
       addr = start
-      for slot in xrange(location, location + size, 16):
+      for i in xrange(0, size, 16):
+        slot = i + location
         hex_line = ""
         asc_line = ""
-        for i in xrange(0, 16):
+        for i in xrange(16):
           if slot + i < location + size:
             byte = ctypes.c_uint8.from_buffer(reader.minidump, slot + i).value
             if byte >= 0x20 and byte < 0x7f:
               asc_line += chr(byte)
             else:
               asc_line += "."
             hex_line += " %02x" % (byte)
           else:
             hex_line += "   "
           if i == 7:
             hex_line += " "
         print "%s  %s |%s|" % (reader.FormatIntPtr(addr),
                                hex_line,
                                asc_line)
         addr += 16
 
     if is_executable is not True and is_ascii is not True:
       print "%s - %s" % (reader.FormatIntPtr(start),
                          reader.FormatIntPtr(start + size))
-      for slot in xrange(start,
-                         start + size,
-                         reader.PointerSize()):
+      print start + size + 1;
+      for i in xrange(0, size, reader.PointerSize()):
+        slot = start + i
         maybe_address = reader.ReadUIntPtr(slot)
         heap_object = heap.FindObject(maybe_address)
         print "%s: %s" % (reader.FormatIntPtr(slot),
                           reader.FormatIntPtr(maybe_address))
         if heap_object:
           heap_object.Print(Printer())
           print
 
   reader.ForEachMemoryRegion(dump_region)
 
@@ skipping 479 matching lines @@
     if self.arch == MD_CPU_ARCHITECTURE_AMD64:
       return ctypes.c_uint64.from_buffer(self.minidump, location).value
     elif self.arch == MD_CPU_ARCHITECTURE_ARM:
       return ctypes.c_uint32.from_buffer(self.minidump, location).value
     elif self.arch == MD_CPU_ARCHITECTURE_X86:
       return ctypes.c_uint32.from_buffer(self.minidump, location).value
 
   def IsProbableASCIIRegion(self, location, length):
     ascii_bytes = 0
     non_ascii_bytes = 0
-    for loc in xrange(location, location + length):
+    for i in xrange(length):
+      loc = location + i
       byte = ctypes.c_uint8.from_buffer(self.minidump, loc).value
       if byte >= 0x7f:
         non_ascii_bytes += 1
       if byte < 0x20 and byte != 0:
         non_ascii_bytes += 1
       if byte < 0x7f and byte >= 0x20:
         ascii_bytes += 1
       if byte == 0xa:  # newline
         ascii_bytes += 1
     if ascii_bytes * 10 <= length:
       return False
     if length > 0 and ascii_bytes > non_ascii_bytes * 7:
       return True
     if ascii_bytes > non_ascii_bytes * 3:
       return None  # Maybe
     return False
 
   def IsProbableExecutableRegion(self, location, length):
     opcode_bytes = 0
     sixty_four = self.arch == MD_CPU_ARCHITECTURE_AMD64
-    for loc in xrange(location, location + length):
+    for i in xrange(length):
+      loc = location + i
       byte = ctypes.c_uint8.from_buffer(self.minidump, loc).value
       if (byte == 0x8b or           # mov
           byte == 0x89 or           # mov reg-reg
           (byte & 0xf0) == 0x50 or  # push/pop
           (sixty_four and (byte & 0xf0) == 0x40) or  # rex prefix
           byte == 0xc3 or           # return
           byte == 0x74 or           # jeq
           byte == 0x84 or           # jeq far
           byte == 0x75 or           # jne
           byte == 0x85 or           # jne far
@@ skipping 27 matching lines @@
         cb(self, r.start, r.size, location)
         offset += r.size
 
     if self.memory_list is not None:
       for r in self.memory_list.ranges:
         cb(self, r.start, r.memory.data_size, r.memory.rva)
 
   def FindWord(self, word, alignment=0):
     def search_inside_region(reader, start, size, location):
       location = (location + alignment) & ~alignment
-      for loc in xrange(location, location + size - self.PointerSize()):
+      for i in xrange(size - self.PointerSize()):
+        loc = location + i
         if reader._ReadWord(loc) == word:
           slot = start + (loc - location)
           print "%s: %s" % (reader.FormatIntPtr(slot),
                             reader.FormatIntPtr(word))
     self.ForEachMemoryRegion(search_inside_region)
 
   def FindWordList(self, word):
     aligned_res = []
     unaligned_res = []
     def search_inside_region(reader, start, size, location):
-      for loc in xrange(location, location + size - self.PointerSize()):
+      for i in xrange(size - self.PointerSize()):
+        loc = location + i
         if reader._ReadWord(loc) == word:
           slot = start + (loc - location)
           if slot % self.PointerSize() == 0:
             aligned_res.append(slot)
           else:
             unaligned_res.append(slot)
     self.ForEachMemoryRegion(search_inside_region)
     return (aligned_res, unaligned_res)
 
   def FindLocation(self, address):
@@ skipping 1577 matching lines @@
                 " more..."
                 " </a>)" %
                 (self.encfilename, highlight_address))
 
     f.write("<h3>%s 0x%x - 0x%x, "
             "highlighting <a href=\"#highlight\">0x%x</a> %s</h3>\n" %
             (desc, start_address, end_address, highlight_address, expand))
     f.write('<div class="code">')
     f.write("<table class=\"codedump\">\n")
 
-    for slot in xrange(start_address, end_address, size):
+    for j in xrange(0, end_address - start_address, size):
+      slot = start_address + j
       heap_object = ""
       maybe_address = None
       end_region = region[0] + region[1]
       if slot < region[0] or slot + size > end_region:
         straddress = "0x"
         for i in xrange(end_region, slot + size):
           straddress += "??"
         for i in reversed(
             xrange(max(slot, region[0]), min(slot + size, end_region))):
           straddress += "%02x" % self.reader.ReadU8(i)
@@ skipping 54 matching lines @@
 
     f.write("<h3>ASCII dump 0x%x - 0x%x, highlighting 0x%x %s</h3>" %
             (start_address, end_address, highlight_address, expand))
 
     line_width = 64
 
     f.write('<div class="code">')
 
     start = self.align_down(start_address, line_width)
 
-    for address in xrange(start, end_address):
+    for i in xrange(end_address - start):
+      address = start + i
       if address % 64 == 0:
         if address != start:
           f.write("<br>")
         f.write("0x%08x:&nbsp;" % address)
       if address < start_address:
         f.write("&nbsp;")
       else:
         if address == highlight_address:
           f.write("<span class=\"highlight\">")
         code = self.reader.ReadU8(address)
@@ skipping 48 matching lines @@
       if exact and not found and end_address == region[0] + region[1]:
         exactness = "&amp;exact=off"
       expand = ("(<a href=\"disasm.html?%s%s"
                 "&amp;val=0x%x#highlight\">more...</a>)" %
                 (self.encfilename, exactness, highlight_address))
 
     f.write("<h3>Disassembling 0x%x - 0x%x, highlighting 0x%x %s</h3>" %
             (start_address, end_address, highlight_address, expand))
     f.write('<div class="code">')
     f.write("<table class=\"codedump\">\n");
-    for i in xrange(0, len(lines)):
+    for i in xrange(len(lines)):
       line = lines[i]
       next_address = count
       if i + 1 < len(lines):
         next_line = lines[i + 1]
         next_address = next_line[0]
       self.format_disasm_line(
           f, start_address, line, next_address, highlight_address)
     f.write("</table>\n")
     f.write("</div>")
     return
@@ skipping 335 matching lines @@
      Interpret memory in the given region [address, address + num * word_size)
      (if available) as a sequence of words. Automatic alignment is not performed.
      If the num is not specified, a default value of 16 words is used.
      Synopsis: dd 0x<address> 0x<num>
     """
     args = args.split(' ')
     start = int(args[0], 16)
     num = int(args[1], 16) if len(args) > 1 else 0x10
     if (start & self.heap.ObjectAlignmentMask()) != 0:
       print "Warning: Dumping un-aligned memory, is this what you had in mind?"
-    for slot in xrange(start,
-                       start + self.reader.PointerSize() * num,
-                       self.reader.PointerSize()):
+    for i in xrange(0,
+                    self.reader.PointerSize() * num,
+                    self.reader.PointerSize()):
+      slot = start + i
       if not self.reader.IsValidAddress(slot):
         print "Address is not contained within the minidump!"
         return
       maybe_address = self.reader.ReadUIntPtr(slot)
       heap_object = self.padawan.SenseObject(maybe_address)
       print "%s: %s %s" % (self.reader.FormatIntPtr(slot),
                            self.reader.FormatIntPtr(maybe_address),
                            heap_object or '')
 
   def do_do(self, address):
@@ skipping 310 matching lines @@
     try:
       server = InspectionWebServer(PORT_NUMBER, options, args[0])
       print 'Started httpserver on port ' , PORT_NUMBER
       webbrowser.open('http://localhost:%i/summary.html' % PORT_NUMBER)
       server.serve_forever()
     except KeyboardInterrupt:
       print '^C received, shutting down the web server'
       server.socket.close()
   else:
     AnalyzeMinidump(options, args[0])