Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / devices / common / regdef / RegisterArray.cc

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: RegisterArray.cc
// 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 ============================================
#include <iostream>
#include <stdlib.h>
#include <assert.h>
#include "Object.h"
#include "RegisterArray.h"
#include "Signature.h"
using namespace std;

RegisterArray::RegisterArray (string n, Block *b, Addr a, uint c, 
                              Addr s, uint w) :
  valueR(n, NULL, a, w)
{
  assert(b != NULL);
  assert(w == 1 || w == 2 || w == 4 || w == 8);
  assert((a % w) == 0);
  assert(c > 0);
  assert(s > 0 && (s % w) == 0);
  
  baseName = n;  
  fullName = b->getFullName() + "." + n;  
  block = b;

  startAddr = a;
  endAddr = a + (c - 1) * s;
  count = c;
  step = s;

  regType = NULL;				// no RegisterType yet
  regState = new RegisterState[count];		// undefined value
  regInfo = new RegisterInfo[count];		// unassigned and dirty
  mySignature = NULL;				// allocated lazily

  reinitRegister(&valueR);

  b->addRegisterArray(this);
}

RegisterArray::~RegisterArray ()
{
  delete regType;
  delete[] regState;
  delete[] regInfo;
  if (mySignature) {
    for (uint i=0; i<count; i++)
      delete mySignature[i];
    delete[] mySignature;
  }
}

void RegisterArray::printThis (ostream &os)
{
  assert(regType != NULL);

  os << getFullName() << " (0x" << hex << startAddr << " to 0x" << endAddr
     << ", count " << dec << count << ", step 0x" << hex << step 
     << ", width " << dec << regType->widthBytes << " bytes)\n" << dec;

  if (isSmall()) {
    for (uint index=0; index<count; index++) {
      Register *reg = &(*this)[index];
      reg->printThis(os);
    }
  }
}

void RegisterArray::resetThis ()
{
  assert(regType != NULL);

  regType->check(getFullName());

  if (regType->resetValue == 0)
    memset(regState, 0, sizeof(RegisterState) * count);
  else
    for (uint index=0; index<count; index++)
      regState[index].value = regType->resetValue;

  if (regType->resetAssigned == 0)
    memset(regInfo, 0, sizeof(RegisterInfo) * count);
  else
    for (uint index=0; index<count; index++) {
      regInfo[index].assigned = (regType->resetAssigned != 0);
      regInfo[index].clean = false;
    }
}

void RegisterArray::signThis (ofstream &ofs)
{
  assert(regType != NULL);

  regType->check(getFullName());

  if (mySignature == NULL) {
    mySignature = new Signature*[count];

    for (uint i=0; i<count; i++) {
      mySignature[i] = NULL;
    }
  }
  
  Signature::signScopeBegin(ofs, getFullName());

  for (uint index=0; index<count; index++) {
    ostringstream o;
    o << index;
    string s = "[" + o.str() + "]";
    string n = getBaseName() + s;
    string f = getFullName() + s;
    mySignature[index] = new Signature;
    mySignature[index]->add(new SignData(f, "", &regState[index].value));
    mySignature[index]->sign(ofs, n, "Register");
  }

  Signature::signScopeClose(ofs, getFullName());
}

void RegisterArray::traceThis (ofstream &ofs)
{
  for (uint index=0; index<count; index++) {
    if (mySignature && mySignature[index] && !regInfo[index].clean) {
      mySignature[index]->printThis(ofs);
      regInfo[index].clean = true;
    }
  }
}

bool RegisterArray::lookup (Addr a, uint *i)
{
  if (a >= startAddr && 
      a <= endAddr && 
      (a - startAddr) % step == 0) {
    uint64 index = (a - startAddr) / step;
    assert(index < count);
    if (i != NULL)
      *i = uint(index);
    return true;
  }  
  else
    return false;
}

Register &RegisterArray::operator[] (uint index)
{
  bindRegisterToIndex(&valueR, index);

  return valueR;			// return Register value by reference
}

void RegisterArray::reinitRegister (Register *r)
{
  assert(r != NULL);
  assert(r->regType != NULL);

  if (regType != NULL)
    delete regType;
  
  regType = r->regType;		// set array regType to instance regType

  delete r->regInfo;		// clear out register pointers
  delete r->regState;
  r->regInfo = NULL;
  r->regState = NULL;
  r->derived = true;		// do not delete dynamic state in ~Register
}

void RegisterArray::bindRegisterToIndex (Register *r, uint index)
{
  assert(regType != NULL);
  assert(index < count);

  Signature *signature = NULL;
  if (mySignature != NULL)
    signature = mySignature[index];

  r->init(block, startAddr + step * index, true, index,
          regType, &regState[index], &regInfo[index], signature);
}