Source Code for Module vdb.renderers

  1  """
 
  2  A home for the vdb specific memory renderers.
 
  3  """ 
  4  
 
  5  import envi 
  6  import envi.bits as e_bits 
  7  import envi.memory as e_mem 
  8  import envi.memcanvas as e_canvas 
  9  
 
 10 -class OpcodeRenderer(e_canvas.MemoryRenderer): 
 11  
 
 12 -    def __init__(self, trace): 
 13          a = trace.getMeta("Architecture") 
 14          self.arch = envi.getArchModule(a) 
 15          self.pwidth = self.arch.getPointerSize() 
 16  
 
 17 -    def render(self, mcanv, va): 
 18          vastr = self.arch.pointerString(va) 
 19          # NOTE: we assume the memobj is a trace
 
 20          trace = mcanv.mem 
 21          sym = trace.getSymByAddr(va) 
 22          if sym != None: 
 23              mcanv.addVaText(str(sym), va=va) 
 24              mcanv.addText(":\n") 
 25          p = trace.readMemory(va, 16) 
 26          op = self.arch.makeOpcode(p, va=va) 
 27          obytes = p[:min(op.size, 8)] 
 28  
 
 29          mcanv.addVaText(vastr, va=va) 
 30          mcanv.addText(": %s " % obytes.encode('hex').ljust(17)) 
 31          op.render(mcanv) 
 32          mcanv.addText("\n") 
 33          return len(op) 
 34  
 
 35 -class SymbolRenderer(e_canvas.MemoryRenderer): 
 36 -    def __init__(self, trace): 
 37          a = trace.getMeta("Architecture") 
 38          self.arch = envi.getArchModule(a) 
 39          self.pwidth = self.arch.getPointerSize() 
 40  
 
 41 -    def render(self, mcanv, va): 
 42          # This is only used with tracer based stuff...
 
 43          trace = mcanv.mem 
 44          vastr = self.arch.pointerString(va) 
 45          # NOTE: we assume the memobj is a trace
 
 46          trace = mcanv.mem 
 47          p = trace.readMemoryFormat(va, 'P')[0] 
 48  
 
 49          isptr = trace.isValidPointer(p) 
 50  
 
 51          pstr = self.arch.pointerString(p) 
 52  
 
 53          mcanv.addVaText(vastr, va=va) 
 54          mcanv.addText(": ") 
 55          if isptr: 
 56              mcanv.addVaText(pstr, p) 
 57          else: 
 58              mcanv.addText(pstr) 
 59  
 
 60          if isptr: 
 61              sym = trace.getSymByAddr(p, exact=False) 
 62              if sym != None: 
 63                  mcanv.addText(' %s + %d' % (repr(sym), p-long(sym))) 
 64          mcanv.addText('\n') 
 65  
 
 66          return self.pwidth 
 67  
 
 68 -class DerefRenderer(e_canvas.MemoryRenderer): 
 69 -    def __init__(self, trace): 
 70          a = trace.getMeta("Architecture") 
 71          self.arch = envi.getArchModule(a) 
 72          self.pwidth = self.arch.getPointerSize() 
 73  
 
 74 -    def render(self, mcanv, va): 
 75          vastr = self.arch.pointerString(va) 
 76          # NOTE: we assume the memobj is a trace
 
 77          trace = mcanv.mem 
 78          p = trace.readMemoryFormat(va, 'P')[0] 
 79  
 
 80          isptr = trace.isValidPointer(p) 
 81  
 
 82          pstr = self.arch.pointerString(p) 
 83  
 
 84          vareg = "" 
 85          preg = "" 
 86  
 
 87          regs = trace.getRegisters() 
 88          for name,val in regs.items(): 
 89              if val == 0: 
 90                  continue 
 91              if val == va: 
 92                  vareg = "(%s)" % name 
 93              if val == p: 
 94                  preg = "(%s)" % name 
 95  
 
 96          bt = trace.getStackTrace() 
 97          if len(bt) > 1: 
 98              for i in range(1, len(bt)): 
 99                  spc, sfc = bt[i] 
100                  if sfc == 0: 
101                      break 
102                  if spc == 0: 
103                      break 
104                  if va == spc: 
105                      vareg = "(savepc)" 
106                  if va == sfc: 
107                      vareg = "(frame%d)" % i 
108                  if p == spc: 
109                      preg = "(savepc)" 
110                  if p == sfc: 
111                      preg = "(frame%d)" % i 
112  
 
113          vareg = vareg.ljust(8) 
114          preg = preg.ljust(8) 
115  
 
116          #sym = trace.getSymByAddr(va)
 
117          #if sym != None:
 
118              #pstr = repr(sym)
 
119  
 
120          mcanv.addVaText(vastr, va=va) 
121          mcanv.addText(" %s: " % vareg) 
122          if isptr: 
123              mcanv.addVaText(pstr, p) 
124          else: 
125              mcanv.addText(pstr) 
126          mcanv.addText(preg) 
127          if isptr: 
128              try: 
129                  addr,size,perm,fname = trace.getMemoryMap(p) 
130                  pname = e_mem.reprPerms(perm) 
131                  mcanv.addText(" ") 
132                  mcanv.addNameText(pname) 
133                  mcanv.addText(" ") 
134  
 
135                  bytes = trace.readMemory(p, 32) 
136                  if self.isAscii(bytes): 
137                      mcanv.addText("'%s'" % bytes.split("\x00")[0]) 
138  
 
139                  elif self.isBasicUnicode(bytes): 
140                      s = bytes.split("\x00\x00")[0].replace("\x00","") 
141                      mcanv.addText("u'%s'" % s) 
142  
 
143                  else: 
144                      mcanv.addText(bytes.encode('hex')) 
145  
 
146              except Exception, e: 
147                  mcanv.addText("ERROR: %s" % e) 
148          else: 
149              try: 
150                  for fd,ftype,fname in trace.getFds(): 
151                      if fd == p: 
152                          mcanv.addText('HANDLE/FD?: %s' % fname) 
153              except Exception, e: 
154                  pass 
155          mcanv.addText("\n") 
156  
 
157          return self.arch.getPointerSize() 
158  
 
159 -    def isAscii(self, bytes): 
160          bytes = bytes.split("\x00")[0] 
161          if len(bytes) < 4: 
162              return False 
163          for i in range(len(bytes)): 
164              o = ord(bytes[i]) 
165              if o < 0x20 or o > 0x7e: 
166                  return False 
167          return True 
168  
 
169 -    def isBasicUnicode(self, bytes): 
170          bytes = bytes.split("\x00\x00")[0] 
171          if len(bytes) < 8: 
172              return False 
173          nonull = bytes.replace("\x00", "") 
174          if (len(bytes) / 2) != len(nonull): 
175              return False 
176          return self.isAscii(nonull) 
177