Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / cpus / vonk / ss / lib / cpu / src / SS_BreakPoint.h

/*
* ========== Copyright Header Begin ==========================================
* 
* OpenSPARC T2 Processor File: SS_BreakPoint.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_BreakPoint_h__
#define __SS_BreakPoint_h__

#include "SS_Instr.h"
#include "BL_Mutex.h"
#include "SS_Trap.h"

extern "C" SS_Vaddr run_exe_breakpoint( SS_Vaddr pc, SS_Vaddr npc, SS_Strand* s, SS_Instr* i );

class SS_Strand;

class SS_BreakPoint/*{{{*/
{
 public:
   typedef uint_t Ident;       // Break point id type

   enum Error
   {
     OK,
     ID_UNKNOWN                // Specified breakpoint id is unknown
   };
   
   enum Break
   {
     ON_INST_VA,
     ON_INST_PA,
     ON_INST_WORD,
     ON_DATA_VA,
     ON_DATA_PA,
     ON_DATA_LOAD,
     ON_DATA_STORE,
     ON_TRAP,
     ON_RED_MODE
   };
   
   SS_BreakPoint( Break _type, SS_BreakPoint* _next=0 );

   Break          type;        // The type of the breakpoint
   Ident          id;          // The id of this breakpoint
   bool           enabled;     // Whether the breakpoint is enabled or not
   bool           triggered;   // Whether the breakpoint triggered a break or not
   SS_BreakPoint* next;        // Next breakpoint in the list of allocated breakpoints
   SS_BreakPoint* link;        // Next breakpoint in the link 

   bool trigger( SS_Strand* s );
   void unlink( SS_BreakPoint** root );

   SS_Instr  inst;             // The original instruction once breakpoint has been inserted
   union 
   {
     SS_Vaddr      va;         // The virtual address that causes the breakpoint match
     SS_Paddr      pa;         // The physical address that causes the breakpoint match
     SS_Trap::Type tt;         // trap type for trap breakpoints
   };

   void insert( SS_Instr* i )  // Insert this breakpoint in instruction i
   {
     orig = i;                 // Keep this method inline to avoid a call & save/restore
     inst.exe = i->exe;        // Copy fields individually ... instr cache striping
     inst.rs1 = i->rs1;
     inst.rs2 = i->rs2;
     inst.rs3 = i->rs3;
     inst.rd  = i->rd;
     inst.bp  = i->bp;
     inst.opc = i->opc;
     inst.flg = i->flg;
     i->bp = this;
     i->exe = run_exe_breakpoint;
   }

   void remove();              // Remove this breakpoint on instruction
    
 private:
   static BL_Mutex id_mutex;
   static Ident    id_count;

   SS_Instr* orig;             // The original place of breakpoint insertion
};
/*}}}*/

class SS_BreakTrap : public SS_BreakPoint/*{{{*/
{
 public:
   SS_BreakTrap( SS_Trap::Type _tt, SS_BreakPoint* _next ) 
    :
     SS_BreakPoint(ON_TRAP,_next)
   {
     tt = _tt;
   }
};
/*}}}*/
class SS_BreakRedMode : public SS_BreakPoint/*{{{*/
{
 public:
   SS_BreakRedMode( SS_BreakPoint* _next ) : SS_BreakPoint(ON_RED_MODE,_next) {}

};
/*}}}*/
class SS_BreakInstVa : public SS_BreakPoint/*{{{*/
{
 public:
   SS_BreakInstVa( SS_Vaddr _va, SS_BreakPoint* _next ) 
    :
     SS_BreakPoint(ON_INST_VA,_next)
   {
     va = _va;
   }

   // check_inst_va() checks is the va of the breakpoint matches
   // the giving va hen both have been applied to the mask first.

   bool check_inst_va( SS_Vaddr mask, SS_Vaddr _va )
   {
     assert(type == ON_INST_VA);
     return enabled && ((va  & mask) == (_va & mask));
   }
   
   bool break_inst_va( SS_Strand* strand, SS_Vaddr _va )
   {
     assert(type == ON_INST_VA);
     return enabled && (va == _va) && trigger(strand);
   }
   
};
/*}}}*/

#endif