Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / api / sam / src / SS_VirtualStrand.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: SS_VirtualStrand.h
* 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 ============================================
*/

#ifndef __SS_VirtualStrand_h__
#define __SS_VirtualStrand_h__

#include "SS_Types.h"
#include "SS_Strand.h"
#include "SS_SamTracer.h"

#define bool_t bool

namespace Sam {
#include "vcpu.h"
#include "Memory.h"
}

class SS_SamTracer; // forward declaration

class SS_VirtualStrand : public Sam::Vcpu
{
  public:
    SS_VirtualStrand();


    int stepi( int64_t n=1 ) 
    { 
      uint64_t ret = 0; 
      
      if (config.delay >= n) 
      {
          config.delay -= n;  // skip n instructions
      }
      else  // step n instruction
      {
          int ii = n - config.delay;

          config.delay = 0;       

          // strand will not increments tick/stick after every step 
          if(sys_intf.vtrace) // tracer is enabled
          {
              strand->add_tracer(&tracer);
              ret = strand->trc_step(ii);
              strand->del_tracer(&tracer);
          }
	  else if (strand->trc_hook || strand->sim_state.ras_enabled())
	  {
              ret = strand->trc_step(ii);
	  }
          else
          {
              ret = strand->run_step(ii);
          }
      } 
      return ret; 
    }

    void update_stick(int64_t stickincr)
    {
      strand->run_tick(stickincr);
    }

    virtual void update_perfcntr (Sam::Vcpu::perfcntr which, int64_t incr)
    {
      strand->run_perf(strand, which, incr); // performance instrumentation counters
    }

    int interrupt( Sam::VCPU_InterruptRequest* );

    RegError get_reg_index( const char* reg_name, RegIndex* index )
    {
      for (int i=SS_Registers::INDEX_BEGIN; i < SS_Registers::ALIAS_END; i++)
      {
	// First check all the alias names like pc for asr5, etc
	// If reg_name is not an alias then check if it is say asr5

	const char* name = get_reg_name(i);
    
	if (!name) 
	  continue;

	if (strcmp(reg_name,name) == 0)
	{
	  *index = RegIndex(i);
	  return REG_OK;
	}
	else if (strcmp(reg_name,SS_Registers::get_name(SS_Registers::Index(i))) == 0)
	{
	  if (get_reg_name(i))
	  {
	    *index = RegIndex(i);
	    return REG_OK;
	  }
	  else
	    return REG_NOT_AVAILABLE;
	}
      }
      return REG_NOT_AVAILABLE;
    }

    const char* get_reg_name( RegIndex index )
    {
      return (strand->get_state_name)(strand,SS_Registers::Index(index));
    }

    RegError get_reg( RegIndex index, uint64_t* data )
    {
      return RegError((strand->get_state)(strand,SS_Registers::Index(index),data));
    }

    RegError set_reg( RegIndex index, uint64_t data )
    {
      return RegError((strand->set_state)(strand,SS_Registers::Index(index),data));
    }

    int get_asi(uint8_t asi, uint64_t addr, uint64_t &data)
    {
        return (strand->asi_map.rd64( strand, asi, addr, &data )) != SS_AsiSpace::OK;
    }
    int set_asi(uint8_t asi, uint64_t addr, uint64_t  data)
    {
        return (strand->asi_map.wr64( strand, asi, addr, data )) != SS_AsiSpace::OK;
    }

    TranslateError translate( TranslateMode mode, uint64_t addr, uint64_t context, uint64_t partitionid, uint64_t* phys_addr )
    {
        return (strand->cnv2pa)(strand,mode,addr,context,partitionid,phys_addr);
    }
      
    int get_tlb_entries(struct Sam::TLBInfo * &return_array);
    
    int read_mem  ( uint64_t addr, uint64_t *value, int size, int asi= 0x82, int is_physical=0 ); 
    int write_mem ( uint64_t addr, uint64_t  value, int size, int asi= 0x82, int is_physical=0 );  
        
    
    int set_breakpoint ( int *bp_id, Sam::VCPU_BpType type,  uint64_t value,  
                         Sam::VCPU_BpActionFn action, uint64_t mask= ~(uint64_t(0))); 
    
    int delete_breakpoint ( int bp_id = ~(0) ); 
         

    // print breakpoint list
    virtual int print_breakpoints ( FILE *fp ); 
        
    // print all regs to file/consol
    virtual int print_regs ( FILE *fp ) { return 1; }
    
    // print tlbs to file/consol
    virtual int print_tlbs ( FILE *fp );


    SS_Strand* strand;
     
    SS_SamTracer tracer; 
};

#endif