Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / api / pfe / src / SS_Break.py

# ========== Copyright Header Begin ==========================================
# 
# OpenSPARC T2 Processor File: SS_Break.py
# Copyright (c) 2006 Sun Microsystems, Inc.  All Rights Reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES.
# 
# The above named program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public
# License version 2 as published by the Free Software Foundation.
# 
# The above named program is distributed in the hope that it will be 
# useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
# 
# You should have received a copy of the GNU General Public
# License along with this work; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
# 
# ========== Copyright Header End ============================================

break_type_name = {}

class BreakPoint:
  def __init__(self,strand,vonk,breakp):
    self.__strand__ = strand
    self.__vonk__   = vonk
    self.__breakp__ = breakp

  def is_enabled(self):
    return self.__breakp__.enabled
  def enable(self):
    self.__strand__.break_enable(self.__breakp__.id)
  def disable(self):
    self.__strand__.break_disable(self.__breakp__.id)

  def __repr__(self):
    type_name = break_type_name[self.__breakp__.type]
    s = '<type='+type_name
    if type_name == 'trap':
      s += '('+str(self.__breakp__.tt)+')'
    elif (type_name == 'inst_va'):
      s += '('+str(self.__breakp__.va)+')'
    elif (type_name == 'inst_pa'):
      s += '('+str(self.__breakp__.pa)+')'
    if self.is_enabled():
      s += ',enabled>'
    else:
      s += ',disabled>'
    return s

  def __str__(self):
    type_name = break_type_name[self.__breakp__.type]
    s = 'brk['+str(self.__breakp__.id)+'] '+type_name+' '
    if type_name == 'trap' or type_name == 'all_trap':
      tt = self.__breakp__.tt
      return s+'tt='+self.__vonk__.get_trap_info(tt).name+'('+hex(tt)+')'
    elif type_name == 'red_mode':
      return s+'entered'
    return s


class BreakIter:
  def __init__(self,strand,vonk):
    self.__strand__ = strand
    self.__vonk__   = vonk
    self.__breakp__ = strand.break_points

  def __iter__(self):
    return self

  def next(self):
    if self.__breakp__:
      breakp = self.__breakp__
      self.__breakp__ = self.__breakp__.next
      return (breakp.id, BreakPoint(self.__strand__,self.__vonk__,breakp))
    raise StopIteration


class BreakDict(dict):
  def __init__(self,strand,vonk):
    dict.__init__(self)
    self.__strand__ = strand
    self.__vonk__   = vonk
    self.callback   = {}

    break_trap_info = vonk.get_trap_info

    if len(break_type_name) == 0:
      for on in vonk.SS_BreakPoint.__dict__:
	if on[0:3] == 'ON_':
	  break_type_name[vonk.SS_BreakPoint.__dict__[on]] = on[3:].lower()

  def __iter__(self):
    return BreakIter(self.__strand__,self.__vonk__)

  def __len__(self):
    n = 0
    for b in self.__iter__():
      n += 1
    return n

  def __repr__(self):
    l = {}
    for id,bp in self.__iter__():
      l[id] = bp
    return str(l)

  def keys(self):
    l = []
    for id,bp in self.__iter__():
      l.append(id)
    return l

  def items(self):
    l = []
    for id,bp in self.__iter__():
      l.append(bp)
    return l

  def __getitem__(self,index):
    for id,bp in self.__iter__():
      if id == index:
	return bp
    raise IndexError

  def __setitem__(self,index):
    raise Exception('Breakpoint dictionary is read-only')

  def __delitem__(self,index):
    if self.__strand__.break_delete(index) != 0:
      raise IndexError
    del self.callback[index]

  def on_inst_va(self,va,callback=None):
    id = self.__strand__.break_on_inst_va(va)
    self.callback[id] = callback
    return id

  def on_red_mode(self,callback=None):
    id = self.__strand__.break_on_red_mode()
    self.callback[id] = callback
    return id

  def on_trap(self,traptype,callback=None):
    id = self.__strand__.break_on_trap(traptype)
    self.callback[id] = callback
    return id

  def hit_id(self):
    bp = self.__strand__.break_hit
    if bp:
      return bp.id
    else:
      return None

  def hit_bp(self):
    bp = self.__strand__.break_hit
    if bp:
      return BreakPoint(self.__strand__,self.__vonk__,bp)
    else:
      return None

  def hit(self):
    bp = self.__strand__.break_hit
    if bp:
      return bp.id,BreakPoint(self.__strand__,self.__vonk__,bp)
    else:
      return None