Initial commit of OpenSPARC T2 architecture model.

[OpenSPARC-T2-SAM] / sam-t2 / sam / system / blaze / stracer.cc

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: stracer.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 ============================================
////////////////////////////////////////////////////////////
//
// File: stracer.cc
//
// Copyright (C) 2005-2007 Sun Microsystems, Inc.
// All rights reserved.
//


#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "types.h"
#include "cpu_interface.h"
#include "symbols.h"
#include "stracer.h"
#include "ui.h"
#include "ui_elfsym.h"

// set to 1 to debug this module
#define DEBUG_ON 0


//////////////////////////////////////////
char *modes[] = { "u", "p", "h" };
typedef enum { MODE_USER, MODE_PRIV, MODE_HVISOR} prmode_t; 


 
// list of open debug tracers  
static STracerContainer g_stracer_list; 


////////////////////////////////////////////////////////////
//
// each debug tracer is associated with output stream; 
// tracers could shared to output trace to the same stream; 
//

static char console[] = "console";

STracer * STracerContainer::alloc(const char *fname,SymTable *symtable)
{
   STracer *s = head; 
   
   if (fname == NULL)
       fname = console; 
      
   // check if tracer is opened already
   while (s)
   {
       if (strcmp(s->trace_name, fname)==0)
           break; 
        else
           s = s->next;     
   }
      
   if (!s)
   {
       // add a new stream
       s = new STracer(fname,symtable); 
       s->next = head; 
       head    = s;     
   }
   s->ref++; // update ref counter
         
   return s; 
}
   
int STracerContainer::dealloc (STracer *t)
{   
   STracer *s    = head; 
   STracer *prev = NULL; 
      
   // find it on the list
   while (s)
   {
       if (t==s)
       {      
           // update ref counter  
           if (--s->ref > 0)
               return 1; 
           
           // remove it from the list 
           if (s == head)
               head = s->next; 
           else
               prev->next = s->next; 
                   
           delete s;  
           return 1;      
       }
       else
       {
           prev = s; 
           s = s->next; 
       }      
   }
      
   return 0;  
}
   
int STracerContainer::display(FILE *out)
{
   int ok = 0;
   STracer *s = head; 
      
   while (s)
   {
      fprintf (out,"trace to %s\n", s->trace_name );  
      ok = 1; 
      s = s->next; 
   }
   fprintf (out,"\n" );
   return ok; 
}

bool STracerContainer::is_found(STracer *t) 
{
   STracer *s = head; 
      
   while (s)
   {
      if(s==t) 
         return true; 
      s = s->next; 
   }

   return false; 
}
 


///////////////////////////////////////////////////////////////////////
//
// debug tracer constructor
//

STracer::STracer (const char *fname, SymTable *symtable)
{
   sym_table = symtable;
   
   // open a stream
   if (fname && fname != console)
       trace_name = strdup(fname);
   else
       trace_name = console; 
            
   if ( trace_name == console )
   { 
       stream = ui->get_output_file(); 
   }
   else
   {      
       stream = fopen (trace_name, "w"); 
       if ( stream == NULL )
       {
           ui->error("cannot open %s, trace to output\n", trace_name);
           trace_name = console; 
           stream = ui->get_output_file(); 
       } 
   }
      
   // set the stream to be unbuffered;
   // tracing will b slower but we don't lose trace data
   // in case of crash
   setbuf(stream, NULL);
   
   next = NULL;
   ref  = 0;     
}

STracer::~STracer ()
{
   if (stream != ui->get_output_file())
        fclose(stream); 

   if (trace_name != console)
       free(trace_name);    
}


int STracer::attach(VTracer_SAM_intf * /* intf */) { return 1; }






///////////////////////////////////////////////////////////////
//
//   print values from the trace record

static int print_regs_update
(
  int  cpuid, 
  int  nregs,           // total number of destination regs written
  VCPU_RegType *dreg,   // destination register type and index
  uint64_t *dval,       // destination reg value
  FILE *stream          // default is ui output
)
{
   Vcpu* cpu = g_vcpu[cpuid];

   for (int i=0; i<nregs; i++) 
   {
      int rindex = dreg[i].r.id;
      char reg_name[24];
      
      const char format[] = "%i:\t%s=0x%llx\n";
      
      switch(dreg[i].r.type)
      {
      case VCPU_PR_RTYPE:
          fprintf (stream, format, cpuid, cpu->get_reg_name(VCPU_PR_0 + rindex), dval[i]);  
          break; 
          
      case VCPU_ASR_RTYPE:
          fprintf (stream, format, cpuid, cpu->get_reg_name(VCPU_ASR_0 + rindex), dval[i]);
          break; 
          
      case VCPU_INT_RTYPE:
          fprintf (stream, format, cpuid, cpu->get_reg_name(VCPU_IRF_0 + rindex), dval[i]); 
          break;
          
      case VCPU_FP_SINGLE_RTYPE:   
          fprintf (stream, format, cpuid, cpu->get_reg_name(VCPU_FRF_0 + rindex), dval[i]); 
          break;                   
      
      case VCPU_FP_DOUBLE_RTYPE:
          // @@ rindex is 0, 2, 4, .. , 62
          fprintf (stream, format, cpuid, cpu->get_reg_name(VCPU_DRF_0 + rindex / 2), dval[i]); 
          break;
          
      case  VCPU_HPR_RTYPE:
          fprintf (stream, format, cpuid, cpu->get_reg_name(VCPU_HPR_0 + rindex), dval[i]);
          break; 
          
      default: // uknown type
          continue; 
      }
   }

   return 0;
}





void print_value(uint64_t val, uint64_t mask, FILE *stream)
{
   for (int i=60; i>=0; i-=4) 
   {

       if ((mask>>i) & 0xf) 
       {
           uint8_t hb = uint8_t(val>>i)&0xf;
           if(hb ==0) fprintf(stream, "0"); 
           else       fprintf(stream, "%1x", hb); 
       }
       else
           fprintf(stream, "-"); 
   }
}

int STracer::instr ( VCPU_Instruction *i ) 
{    
     // instruction line
     const int LSIZE = 128; 
     char ibuf[LSIZE];
     disassemble (i->opcode, i->pc_va, ibuf, LSIZE);  
     
     
     // check mode
     prmode_t mode = MODE_USER;
     if(i->hpstate & 4)
        mode = MODE_HVISOR; 
     else if (i->pstate & 4)
        mode = MODE_PRIV; 
        
     uint32_t context = i->pc_type==VCPU_VADDR ? i->icontext : Symbol::NO_CONTEXT;    
        
     // id, mode   
     int id = get_vcpu(i->cpuid)->id();
     fprintf(stream,"%i: ", id); 
         
     // symname, va   
     if (sym_table) sym_table->fputs(i->pc_va, context, stream); 
     fprintf(stream,"%llx", i->pc_va);
     
     // context
     if (i->pc_type==VCPU_VADDR) fprintf(stream,"(%x)", i->icontext);
     
     // pa, opcode, instr disassem,  branch taken flag
     fprintf(stream," : %llx [%08x] %s  %s %s\n", 
        i->pc_pa, i->opcode, modes[mode], ibuf, i->taken? "(taken)":"");
        
     // destination regs
     if(i->nregs > 0) 
        print_regs_update (id, i->nregs, i->dreg, i->dval, stream  );

     if (i->st_num > 0) 
     {
         fprintf(stream,"%i:\tstore ", id);
         for(int ii=0; ii<i->st_num; ii++)
         {
             //print_value(i->st_mem_value[ii],i->st_bitmask, stream);
             fprintf(stream, "%llx(%llx)", i->st_mem_value[ii], i->st_bitmask);
         }
              
         if (i->ea_type == VCPU_VADDR) // trace context
         {
             fprintf(stream," to %llx(%x):%llx ", i->ea_va, i->dcontext, i->ea_pa); 
             context = i->dcontext;
         }
         else
         {
             fprintf(stream," to %llx:%llx ", i->ea_va, i->ea_pa);
             context = Symbol::NO_CONTEXT; 
         }
             
         if (sym_table) sym_table->fputs(i->ea_va, context, stream); 
         fprintf(stream,"\n");    
     }
     if (i->ld_num > 0) 
     {
         fprintf(stream,"%i:\tload ", id);
         for(int ii=0; ii<i->ld_num; ii++)
         {
             //print_value(i->ld_mem_value[ii],i->ld_bitmask, stream);
             fprintf(stream," %llx(%llx)", i->ld_mem_value[ii], i->ld_bitmask);
         }
                       
         if (i->ea_type == VCPU_VADDR) // trace context
         {
             fprintf(stream," from %llx(%x):%llx ", i->ea_va, i->dcontext, i->ea_pa);
             context = i->dcontext;
         }
         else
         {
             fprintf(stream," from %llx:%llx ", i->ea_va, i->ea_pa); 
             context = Symbol::NO_CONTEXT;
         }
             
         if (sym_table) sym_table->fputs(i->ea_va, context, stream);
         fprintf(stream,"\n"); 
     }

     return 0; 
}

int STracer::trap  ( VCPU_Trap *t )
{
     int id = get_vcpu(t->cpuid)->id();
     
     fprintf(stream,"%i: TRAP 0x%x @pc=0x%llx\n", id, t->tno, t->pc_va);
     print_regs_update (id, t->nregs, t->dreg, t->dval, stream );
     return 0; 
}
 
int STracer::tlb   ( VCPU_TLB *s ) 
{ 
  int id = get_vcpu(s->cpuid)->id();
  
  fprintf(stream,"%i: %s%d n:%d 0x%llx:0x%llx %s ", id, 
          s->tlb_type==0 ? "ITLB":(s->tlb_type==1 ?"DTLB":"TLB"), 
          s->tlb_no, s->tlb_index, 
          s->tte_tag, s->tte_data, 
          s->demap?"removed ":"inserted");

  if (s->v()) fprintf(stream, "V ");
  if (s->nfo()) fprintf(stream, "NFO ");
  if (s->is_real) fprintf(stream, "R ");
  if (s->ie()) fprintf(stream, "IE ");
  if (s->e()) fprintf(stream, "E ");
  if (s->cp()) fprintf(stream,"CP ");
  if (s->cv()) fprintf(stream,"CV ");
  if (s->p()) fprintf(stream, "P ");
  if (s->ep()) fprintf(stream, "EP ");
  if (s->w()) fprintf(stream, "W ");
  if (s->l()) fprintf(stream, "L ");
  if (s->g()) fprintf(stream, "G ");

  uint64_t actual_page_size = (1ull << (13 + 3 * s->tte_page_size));
  if (actual_page_size >> 30) {
      fprintf(stream, ": %lldG, ", (actual_page_size>>30));
  } else if (actual_page_size >> 20) {
      fprintf(stream, ": %lldM, ", (actual_page_size >> 20));
  } else {
      fprintf(stream, ": %lldK, ", (actual_page_size >> 10));
  }

  fprintf(stream, "ctx 0x%x", s->tte_context);

  if (s->format) { // sun4v
      fprintf(stream, " partid 0x%x\n", s->partid);
  } else {
      fprintf(stream, "\n");
  }
  
  return 0; 

}


int STracer::hwop   ( VCPU_HwOp *s ) 
{ 
  int id = get_vcpu(s->cpuid)->id();
  fprintf(stream,"%i: hwtw load %s tte tag=0x%llx data=0x%llx from tsb_addr=0x%llx\n",
          id, s->op_type==0 ? "Instr":"Data", s->data[0], s->data[1], s->addr);
  
  return 0; 

}



int STracer::put_string(int cpuid, const char * str)
{
     fprintf(stream,"%s\n", str); 
     return 0;
}




///////////////////////////////////////////////////////
//
// set debug tracer on/off
//
int tracer_cmd 
(
   trace_cmd_t  cmd,   // on/off/show status
   int  *trace_flag,   // equal 1 to signal dtracer turn on/off, NULL - all vcpu's
   const char *fname,        // trace file name, if NULL - ui output
   bool separate       // if true, trace each vcpu to separate file/stream
)
{   
   if (cmd == STRACER_STATUS )
   { 
           
       bool    newline = true; 
       STracer *prev   = NULL; 
       for (int i=0; i<=g_vcpu_id_max; i++) 
       {   
          Vcpu *vcpu = get_vcpu(i); 
          if (vcpu == NULL)
              continue; 
         
          STracer *s = (STracer *)(vcpu->sys_intf.vtrace);
          if (g_stracer_list.is_found(s))
          {
              if (s != prev ) 
                 newline = true; 
              
              if (newline)
              {
                 printf("\ncollect trace to %s for cpu :", s->get_trace_name());
                 newline = false;
                 prev    = s;  
              }
              printf (" %i", i);     
          }
       }  
       
       if (!prev) 
           ui->output("debug tracer is off\n\n");
       else
       {
           #if(DEBUG_ON==1)
           ui->verbose("\n\n");
           g_stracer_list.display(ui->get_output_file());
           #endif     
           ui->verbose("\n");  
       }  
           
       return 1; 
   }
      
   
   if( cmd == STRACER_OFF ) // turn it off
   {   
       for (int i=0; i<=g_vcpu_id_max; i++) 
       {
           Vcpu *vcpu = get_vcpu(i); 
           if (vcpu == NULL)
              continue; 

           STracer *s = (STracer *)vcpu->sys_intf.vtrace;
           if ( s && (trace_flag == NULL || trace_flag[i] == 1) )
           {
              if (g_stracer_list.dealloc(s))
              { 
                 vcpu->sys_intf.vtrace = NULL; 
                 vcpu->config.trace_on = 0;
                 ui->output("debug tracer is off for cpu %i\n", vcpu->id());
              }
              else
              {
                 ui->error("cannot delete debug tracer for cpu %i\n,if you hooked up another analyzer - try to unload it first\n",
                         vcpu->id() );
                 return 0;        
              }
           }
       } 
   }
   else if (cmd == STRACER_ON) // turn it on
   {
      if (fname == NULL && separate)
      {
          ui->error("cannot trace to console cpu running on separate worker threads\n");
          return 0;     
      }
      else if ( separate )
      {           
          ui->output("collect trace for each cpu to separate files\n");
      } 
   
   
      for (int i=0; i<=g_vcpu_id_max; i++) 
      {
          Vcpu *vcpu = get_vcpu(i); 
          if (vcpu == NULL)
              continue;

          if ( trace_flag == NULL || trace_flag[i] == 1 )
          {
              if (vcpu->sys_intf.vtrace != NULL)
              {
                 ui->error("another tracer for cpu %i is already on, need to turn it off to hook up debug tracer\n",
                         vcpu->id()); 
              }
              else
              {
                 char trace_name[256];
                 if (separate)
                 {
                     sprintf(trace_name, "%s.cpu%i", fname, vcpu->id());
                 }
                 
                 
                 vcpu->sys_intf.vtrace = g_stracer_list.alloc(separate? trace_name:fname, g_sym_table); 
                 vcpu->config.trace_on = 1;
                 ui->output("debug tracer is turned on for cpu %i\n", vcpu->id());
              }
          }
      }
   
   }
   return 1;
   
}