sam-t2/sam/cpus/vonk/ss/lib/cpu/bin/SS_State.py

# ========== Copyright Header Begin ==========================================
#
# OpenSPARC T2 Processor File: SS_State.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 ============================================

from SS_Access import *

X = '0'

RW = 'RW'
RO = 'RO'
R1C = 'R1C'
RW1C = 'RW1C'

class SS_Field:
  def old__init__(self,name,start,end,access,init):
    self.name = name
    self.start = start
    self.end = end
    self.access = access
    self.init = init
    self.width = end - start + 1

  def __init__(self,nseai):
    self.name = nseai[0]
    self.start = nseai[1]
    self.end = nseai[2]
    self.access = nseai[3]
    self.init = nseai[4]
    self.width = self.end - self.start + 1
    if self.end < self.start:
      raise RuntimeError, "end < start in field "+self.name

  def set_reg(self,reg):
    self.reg = reg
    if self.width == self.reg.size:
      self.mask = '~('+self.reg.type+')0'
    else:
      self.mask = '(('+self.reg.type+'(1) << '+str(self.width)+') - 1)'

  def cpp(self,file):
    if len(self.name):
      ofs = str(self.start)
      msk = '('+self.mask+' << '+ofs+')'
      set = '{ '+self.reg.type+' m = '+msk+'; _data = (_data &~ m) | ((v << '+ofs+') & m); return *this; }'
      get = '{ return (_data >> '+ofs+') & '+self.mask+'; }'
      for l in [
        '    '+self.reg.type+'\t'+self.name+'()\t\t\t'+get,
        '    '+self.reg.class_name+'&\t'+self.name+'( '+self.reg.type+' v )\t'+set,
        '    const static uint64_t\t\tOFFSET_'+self.name.upper()+' = '+ofs+';',
        '    const static uint64_t\t\tWIDTH_'+self.name.upper()+' = '+str(self.width)+';',
        '']:
        file.write(l+'\n')

  def ro_mask(self):
    if self.access == RO:
      return '('+self.mask+' << '+str(self.start)+')'
    else:
      return '0'

  def rw_mask(self):
    if self.access == RW:
      return '('+self.mask+' << '+str(self.start)+')'
    else:
      return '0'

  def r1c_mask(self):
    if self.access == R1C:
      return '('+self.mask+' << '+str(self.start)+')'
    else:
      return '0'

  def w1c_mask(self):
    if self.access == RW1C:
      return '('+self.mask+' << '+str(self.start)+')'
    else:
      return '0'

  def init_val(self):
    return '(('+self.reg.type+')('+str(self.init)+') << '+str(self.start)+')'


# Coding conventions have it that members and variables are all lower
# case with underscore(underbar) as spacer and types are capitalized
# with no underscores. capitalize_variable() converts member name to that

def capitalize_variable(name):
  name = name.capitalize()
  us = name.find('_')
  if us >= 0:
    name = name[:us] + capitalize_variable(name[us+1:])
  return name

class SS_CtrReg:
  def __init__(self,class_prefix,name,table,index,access,size,fields):
    self.class_prefix = class_prefix
    self.name = name
    self.table = table
    self.index = index
    self.access = access
    self.size = size
    self.fields = map(SS_Field,fields)
    self.class_name = self.class_prefix+'_'+capitalize_variable(self.name)
    self.type = 'uint' + str(self.size) + '_t'
    for f in self.fields:
      f.set_reg(self)


  def cpp(self,file):
    if self.size == 0:
      return
    rw_mask='0'
    w1c_mask='0'
    for i,field in enumerate(self.fields):
      if i == 0:
        rw_mask=rw_mask+' | '+field.rw_mask()
        w1c_mask=w1c_mask+' | '+field.w1c_mask()
      else:
        rw_mask=rw_mask+'\n             | '+field.rw_mask()
        w1c_mask=w1c_mask+'\n             | '+field.w1c_mask()

    file.write('class %s /*{{{*/\n' % self.class_name)
    file.write('{\n')
    file.write('  public:\n')
    file.write('    %s()\n' % self.class_name)
    file.write('    :_data(0)\n')
    if self.fields != []:
      file.write('    ,_mask(%s)\n' % rw_mask)
    file.write('    {}\n')
    if self.fields != []:
      file.write('    %s( %s d, %s m, %s i )\n' % (self.class_name,self.type,self.type,self.type))
    else:
      file.write('    %s( %s d )\n' % (self.class_name,self.type))
    file.write('    :_data(d)\n')
    if self.fields != []:
      file.write('    ,_mask(m)\n')
    file.write('    {}\n')
    file.write('\n')
    if self.fields != []:
      file.write('    void reset()         \t\t{ _data = 0; }\n')
    else:
      file.write('    void reset()         \t\t{}\n')
    file.write('\n')
    file.write('    void snapshot( SS_SnapShot& ss )\t{ ss.val(&_data); }\n')
    file.write('\n')
    file.write('    const char* name()   \t\t{ return "%s"; }\n' % self.name)
    file.write('\n')
    file.write('    %s operator()()      \t\t{ return _data; }\n' % self.type)
    file.write('\n')
    file.write('    %s& operator=( %s v )\t{ _data = v; return *this; }\n' % (self.class_name,self.type))
    file.write('\n')
    if self.fields == []:
      file.write('    void set( %s v )\t{ _data = v; }\n' % (self.type))
    else:
      file.write('    void set( %s v )\t{ _data = (_data &~ _mask) | (v & _mask); }\n' % (self.type))
    file.write('\n')
    for field in self.fields:
      field.cpp(file)
    file.write('  protected:\n')
    file.write('    %s _data;\n' % self.type)
    if self.fields != []:
      file.write('    %s _mask;\n' % self.type)
    file.write('};\n')
    file.write('/*}}}*/\n')

  def run_exe_rd(self):
    pass

  def run_exe_wr(self):
    pass


class SS_CtrTable:
  def __init__(self,regs):
    self.table = {}
    for r in regs:
      self.table[r.index] = r

  def reg_at(self,index):
    if self.table.has_key(index):
      return self.table[index]
    else:
      return None

#============================================================================
# SS_AsiCtrReg(prefix,name,fields)
#============================================================================

SHARED ='SS_SharedAsiCtrReg'
PRIVATE='SS_AsiCtrReg'

class SS_AsiCtrReg:
  def __init__(self,prefix,name,inheritance,fields,code=[],constructor_code=[]):
    self.class_prefix = prefix
    self.name = name
    self.inheritance = inheritance
    self.fields = map(SS_Field,fields)
    self.size = 64
    self.type = 'uint64_t'
    self.class_name = self.class_prefix+'_'+capitalize_variable(self.name)
    for f in self.fields:
      f.set_reg(self)
    self.code = code
    self.constructor_code = constructor_code


  def cpp(self,file):
    ro_mask ='\n      , uint64_t(0)'
    rw_mask ='\n      , uint64_t(0)'
    r1c_mask='\n      , uint64_t(0)'
    w1c_mask='\n      , uint64_t(0)'
    init    ='\n      , uint64_t(0)'
    for i,field in enumerate(self.fields):
      ro_mask=ro_mask+  '\n      | '+field.ro_mask()
      rw_mask=rw_mask+  '\n      | '+field.rw_mask()
      r1c_mask=r1c_mask+'\n      | '+field.r1c_mask()
      w1c_mask=w1c_mask+'\n      | '+field.w1c_mask()
      init=init+        '\n      | '+field.init_val()

    for l in [
      'class '+self.class_name+' : public '+self.inheritance+' /*{{{*/',
      '{\n',
      '  public:\n',
      '    '+self.class_name+'()\n',
      '     :\n',
      '      '+self.inheritance+'("'+self.name+'"'+ro_mask+r1c_mask+rw_mask+w1c_mask+init+')\n',
      '    {']:
      file.write(l)
    if self.constructor_code != []:
      file.write('\n')
      for line in self.constructor_code:
        file.write('      %s\n' % line)
    for l in [
      '    }',
      '',
      '    uint64_t operator()()\t\t{ return get(); }',
      '',
      '    '+self.class_name+'& operator=( uint64_t v )\t{ set(v); return *this; }',
      '']:
      file.write(l+'\n')

    for field in self.fields:
      field.cpp(file)

    if self.code != []:
      file.write('\n')
      for line in self.code:
        file.write('    %s\n' % line)

    for l in [
      '};',
      '/*}}}*/']:
      file.write(l+'\n')

  def run_exe_rd(self):
    pass

  def run_exe_wr(self):
    pass

class SS_RasCtrReg:
  def __init__(self,class_prefix,name,table,index,access,size,fields,code=[]):
    self.class_prefix = class_prefix
    self.name = name
    self.table = table
    self.index = index
    self.access = access
    self.size = size
    self.fields = map(SS_Field,fields)
    self.class_name = self.class_prefix+'_'+capitalize_variable(self.name)
    self.type = 'uint' + str(self.size) + '_t'
    for f in self.fields:
      f.set_reg(self)

    self.code = code

  def cpp(self,file):
    if self.size == 0:
      return
    mask='0'
    for i,field in enumerate(self.fields):
      if i == 0:
        mask=mask+' | '+field.rw_mask()
      else:
        mask=mask+'\n             | '+field.rw_mask()

    file.write('class %s /*{{{*/\n' % self.class_name)
    file.write('{\n')
    file.write('  public:\n')
    file.write('    %s()\n' % self.class_name)
    file.write('    :_data(0)\n')
    if self.fields != []:
      file.write('    ,_mask(%s)\n' % mask)
    file.write('    {}\n')
    if self.fields != []:
      file.write('    %s( %s d, %s m, %s i )\n' % (self.class_name,self.type,self.type,self.type))
    else:
      file.write('    %s( %s d )\n' % (self.class_name,self.type))
    file.write('    :_data(d)\n')
    if self.fields != []:
      file.write('    ,_mask(m)\n')
    file.write('    {}\n')
    file.write('\n')
    if self.fields != []:
      file.write('    void reset()         \t\t{ _data = 0; }\n')
    else:
      file.write('    void reset()         \t\t{}\n')
    file.write('\n')
    file.write('    void snapshot( SS_SnapShot& ss )\t{ ss.val(&_data); }\n')
    file.write('\n')
    file.write('    const char* name()   \t\t{ return "%s"; }\n' % self.name)
    file.write('\n')
    file.write('    %s operator()()      \t\t{ return _data; }\n' % self.type)
    file.write('\n')
    file.write('    %s& operator=( %s v )\t{ _data = v; return *this; }\n' % (self.class_name,self.type))
    file.write('\n')
    if self.fields == []:
      file.write('    void set( %s v )\t{ _data = v; }\n' % (self.type))
    else:
      file.write('    void set( %s v )\t{ _data = (_data &~ _mask) | (v & _mask); }\n' % (self.type))
    file.write('\n')
    for field in self.fields:
      field.cpp(file)
      file.write('    const static uint8_t bit_size_%s = %s;\n' % (field.name,field.width))

    if self.code != []:
      file.write('\n')
      for line in self.code:
        file.write('    %s;\n' % line)

    file.write('  protected:\n')
    file.write('    %s _data;\n' % self.type)
    if self.fields != []:
      file.write('    %s _mask;\n' % self.type)
    file.write('};\n')
    file.write('/*}}}*/\n')

  def run_exe_rd(self):
    pass

  def run_exe_wr(self):
    pass