Exemplo n.º 1
0
  def __init__(self, vm_data = None, asm_data = None, parent = None):
    QAbstractTableModel.__init__(self, parent)
    if vm_data is not None:
      self.words = vm_data.vm.memory
      self.mem_len = vm_data.vm.MEMORY_SIZE
      self.modified = [False for _ in xrange(self.mem_len)]
      self.is_readable = vm_data.is_readable
      self.is_locked = lambda x: not (vm_data.is_readable(x) and vm_data.is_writeable(x))
      self.ca = vm_data.ca()

      self.symtable = asm_data.symtable
      self.end_addr = asm_data.end_address

      self.disasm = Disasm()
      self.inited = True
    else:
      self.inited = False
Exemplo n.º 2
0
 def __show(self, thread, addr, sym, filename, line):
     assert (sym)
     view = None
     #find a view that matches the current filename
     for v in self._Composite__views:
         if v.filename() == filename:
             view = v
             book = self.__book
             book.set_current_page(book.page_num(v.widget()))
             break
     #not found, add a new view
     if not view:
         w = self.__book
         if line:
             view = Source(w)
             view.read(thread, addr, sym)
         else:
             view = Disasm(w)
         self.add(view, filename)
     assert view
     view.show(thread, addr, sym)
     self.__current_view = view
Exemplo n.º 3
0
def execute(vmachine):
    # some common stuff
    if not vmachine.is_readable(vmachine.cur_addr):
        raise MemReadLockedError((vmachine.cur_addr, vmachine.cur_addr))

    proc_name = Disasm.disasm(vmachine.get_cur_word())[0]
    if proc_name == "in":
        proc_name = "in_"  # it's done, because can't define function with name "in"

    if proc_name is not None:
        vmachine.jump_to = None
        before_cycles = vmachine["cycles"]

        exec_all.__dict__[proc_name](vmachine)

        if vmachine.jump_to is None:
            vmachine["cur_addr"] += 1
        else:
            vmachine["cur_addr"] = vmachine.jump_to

        return vmachine["cycles"] - before_cycles
    else:
        raise UnknownInstructionError(tuple(vmachine.get_cur_word()))
Exemplo n.º 4
0
def execute(vmachine):
  # some common stuff
  if not vmachine.is_readable(vmachine.cur_addr):
    raise MemReadLockedError( (vmachine.cur_addr, vmachine.cur_addr) )

  proc_name = Disasm.disasm(vmachine.get_cur_word())[0]
  if proc_name == "in":
    proc_name = "in_" # it's done, because can't define function with name "in"

  if proc_name is not None:
    vmachine.jump_to = None
    before_cycles = vmachine["cycles"]

    exec_all.__dict__[proc_name](vmachine)

    if vmachine.jump_to is None:
      vmachine["cur_addr"] += 1
    else:
      vmachine["cur_addr"] = vmachine.jump_to

    return vmachine["cycles"] - before_cycles
  else:
    raise UnknownInstructionError(tuple(vmachine.get_cur_word()))
Exemplo n.º 5
0
class DisassemblerModel(QAbstractTableModel):
  def __init__(self, vm_data = None, asm_data = None, parent = None):
    QAbstractTableModel.__init__(self, parent)
    if vm_data is not None:
      self.words = vm_data.vm.memory
      self.mem_len = vm_data.vm.MEMORY_SIZE
      self.modified = [False for _ in xrange(self.mem_len)]
      self.is_readable = vm_data.is_readable
      self.is_locked = lambda x: not (vm_data.is_readable(x) and vm_data.is_writeable(x))
      self.ca = vm_data.ca()

      self.symtable = asm_data.symtable
      self.end_addr = asm_data.end_address

      self.disasm = Disasm()
      self.inited = True
    else:
      self.inited = False

  def addBreakpoint(self, index):
    i = index.row()
    if i in self.breaks:
      self.breaks.remove(i)
    else:
      self.breaks.add(i)
    self.lineChanged(i)

  def rowCount(self, parent):
    if self.inited:
      return self.mem_len
    else:
      return 0

  def columnCount(self, parent):
    return 3 # addr, word, disasm line

  def data(self, index, role = Qt.DisplayRole):
    if not index.isValid():
      return QVariant()

    i = index.row()

    if role == Qt.TextAlignmentRole:
      if index.column() in (0,1):
        # address, mix word
        return QVariant(Qt.AlignHCenter | Qt.AlignVCenter)
      else:
        # disasm line
        return QVariant(Qt.AlignLeft | Qt.AlignVCenter)

    elif role == Qt.BackgroundRole:
      changed_row = self.modified[i]
      ca_row =  i == self.ca
      locked_row = self.is_locked(i)
      if changed_row and ca_row and locked_row:
        return QVariant(QColor(200, 150, 0))

      elif changed_row and ca_row:
        return QVariant(QColor(220, 220, 0))
      elif changed_row and locked_row:
        return QVariant(QColor(200, 25, 0))
      elif locked_row and ca_row:
        return QVariant(QColor(255, 175, 0))

      elif changed_row:
        return QVariant(QColor(Qt.lightGray))
      elif ca_row:
        return QVariant(QColor(255, 255, 0))
      elif locked_row:
        return QVariant(QColor(255, 50, 0))
      else:
        return QVariant()

    elif role == Qt.DisplayRole:
      if index.column() == 0:
        return QVariant(str(i))

      elif index.column() == 1:
        if self.is_readable(i):
          return QVariant(self.words[i].addr_str()) # print first two bytes as one address
        else:
          return QVariant(self.tr("LOCKED"))

      else:
        if self.is_readable(i):
          return QVariant(self.disasm.disasm2str(self.words[i], i, self.symtable, self.end_addr, "\t"))
        else:
          return QVariant(self.tr("LOCKED"))

    elif role == Qt.ToolTipRole:
        if index.column() == 1:
          if self.is_readable(i):
            return QVariant(word2toolTip( self.words[i] ))
          else:
            return QVariant(self.tr("This memory cell is locked for reading"))
        else:
          return QVariant()

    else:
      return QVariant()

  def headerData(self, section, orientation, role = Qt.DisplayRole):
    if role == Qt.TextAlignmentRole:
      if orientation == Qt.Vertical:
        return QVariant(Qt.AlignRight | Qt.AlignVCenter)
      else:
        return QVariant(Qt.AlignHCenter | Qt.AlignVCenter)
    elif role == Qt.DisplayRole:
      if orientation == Qt.Horizontal:
        return QVariant(self.tr(("Addr", "Mix word", "Disassemled word")[section]))
      else:
        return QVariant(u"     ")#str(section))
    elif role == Qt.BackgroundRole and orientation == Qt.Vertical and section in self.breaks:
      # breakpoint
      return QVariant(QColor(Qt.red))
    else:
      return QVariant()

  def lineChanged(self, addr):
    """dataChange for all line"""
    self.emit(SIGNAL("dataChanged(QModelIndex, QModelIndex)"),
        self.index(addr, 0),
        self.index(addr, 3))
    self.emit(SIGNAL("headerDataChanged(Qt::Orientation, int, int)"),
        Qt.Vertical, addr, addr)

  def hook(self, item, old, new):
    if item == "cur_addr": # cpu hook
      self.ca = new
      self.lineChanged(old)
      self.lineChanged(new)
    elif isinstance(item, int): # mem hook
      self.modified[item] = True
      self.lineChanged(item)
    elif item in ("rw", "w"): # lock hook
      for addr in old.symmetric_difference(new):
        self.lineChanged(addr)