Initial commit of OpenSPARC T2 architecture model.

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

// ========== Copyright Header Begin ==========================================
// 
// OpenSPARC T2 Processor File: symbols.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: symbols.cc
//
// Symbol table submodule
//
// Copyright (C) 2006 Sun Microsystems, Inc.
// All rights reserved.
//
// Symbol table implementation file
//

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


#define DEBUG_ON 0 

/////////////////////////////////////////////////////////
//
// Symbol class
//

Symbol::Symbol
(
  char* mname,     // module name
  char* sname,     // symbol name
  uint64_t vaddr,  // starting  address
  uint64_t size,   // size of address space taken this symbol
  uint32_t context // symbol context
)
: SymBase(NULL)
{  
   // add module name
   if (sname != NULL)
   {
       char sym_name[128];
       sprintf (sym_name, "%s:%s", mname, sname); 
       m_name    = strdup(sym_name);
       m_sname   = strdup(sname);
   }
   else
   {  
       m_name  = NULL;
       m_sname = NULL; 
   }
   m_next    = NULL;
       
   m_vaddr   = vaddr; 
   m_size    = size; 
   
   m_context = context; 
}
     
// destructor
Symbol::~Symbol () 
{
  if (m_name ) free(m_name);
  if (m_sname) free(m_sname);
}

//////////////////////////////////////////////////////////////
//
// Container class for all symbols
//

// constructor
SymTable::SymTable  
(
   uint32_t levels,      // total number of table levels +1
   uint32_t *idx_width   // number of bits for table index 
                         // on each level, plus last offset
)
{   
  
   int i;
   uint32_t *wd = idx_width; 
     
   const uint32_t default_level = MAX_LEVEL+1; // number of tables + 1
   uint32_t default_width[default_level] = {12,10,10,10,10,10,2}; 
     
     
   if ((idx_width == NULL) || (levels > default_level ))
   {
      levels = default_level; 
      wd = default_width;  
   }
     
   m_lev = levels-2; 
   int max_lev = m_lev + 1;
        
   for (i=max_lev; i>=0; i--)
   {
       m_width[i] = wd[i];
       m_size [i] = 1<<m_width[i];
       m_mask [i] = m_size[i] -1;
          
       m_sft  [i] = (i==max_lev) ? 0 : m_width[i+1];
       if ( i < max_lev) 
            m_sft [i] += m_sft[i+1];
       #if(DEBUG_ON)
       ui->verbose("\n symbol tbl level=%d, sft=%d, width=%d, size=0x%x, mask=0x%llx\n", 
               i, m_sft[i],m_width[i],m_size[i],m_mask[i]);
       #endif
            
   }   
         
   m_tbl = (void **) calloc(m_size[0], sizeof(void*));
      
   for (int j=0; j<SYM_TBL_SIZE; j++)
        m_bucket[j] = NULL;
           
   m_empty    = true; 
}

// destructor
SymTable::~SymTable ()
{
   for (int j=0; j<SYM_TBL_SIZE; j++)
   {
       if (m_bucket[j] != NULL)
           delete m_bucket[j];
   }
     
   delete_tbl ( m_tbl, 0 );      
}

// get a pointer in multi level  addr tables;
// nested tables are allocated if needed
void ** SymTable::alloc( uint64_t addr )
{  
  void ** tbl = m_tbl; 
  void ** ptr = NULL;
     
      
  for ( int i=0; i<m_lev; i++)
  {
     ptr = tbl + ((addr>>m_sft[i]) & m_mask[i]);
     void **next = (void**)(*ptr); 
     if (next == NULL)
     {
        // allocate a new table
        next = (void **) calloc ( m_size[i+1], sizeof(void*));
           
        // insert a pointer
        *ptr = next; 
     }
     tbl = next; 
  }
     
  // get a pointer to the leaf table entry
  return (tbl + ((addr>>m_sft[m_lev]) & m_mask[m_lev])); 
}
  
// recursively delete all tables on deeper levels
void SymTable::delete_tbl ( void ** tbl, uint32_t level)
{
   if ( level == m_lev ) 
   {
       // leaf table
       for ( int i=0; i<m_size[level]; i++ )
       {
           // remove all links
           SymBase *s = (SymBase *)tbl[i];
              
           while (s)
           {
               SymBase *r = s; 
               s = s->m_link; 
               if (r->m_origin)
                   delete (r); 
               else
               {
                   delete ( (Symbol*)r); 
               }    
           } 
              
       }     
       free ( tbl );   
   }    
   else  
   {
       for ( int i=0; i<m_size[level]; i++ )
       {
          if (tbl[i]) // nested table
              delete_tbl ( (void **)tbl[i], level+1 );
          free ( tbl[i] );     
       }  
   }
}

  
// search for symbols  specified by symbol name;
// return pointer to symbol if found; 0 otherwise
Symbol* SymTable::find 
( 
   char*   name,    // symbol name 
   Symbol* start    // start search from this one
)
{
  if ( this->is_empty() ) 
       return NULL; 
          
  Symbol *sym = start ? start->m_next : NULL; 
     
  if (start == NULL)
  {
      // hash index for the bucket
      sym = m_bucket[sym_hash(name)];
  }
 

  while (sym) // possibly iterate through the list
  {
      // check if name match
      if ( strcmp (sym->m_sname, name) == 0 ) 
      {   
          return sym;    
      }
      // traverse the list for this bucket
      sym = sym->m_next;
  }
  
  return NULL; 
}
 
// find symbol specified by address ;
// return 1 if found, 0 otherwise;
SymBase* SymTable::find
( 
   uint64_t addr,       // address used to lookup the symbol
   SymBase* start       // start from this symbol 
)
{
   SymBase* res = NULL; 
      
      
   SymBase* s = start ? start->m_link : NULL;  
      
   if(start==NULL)
      s = find ( addr );  
       
   if ( s == NULL )
        return 0;  // not found
           
   while (s)
   {
      Symbol *sym = (s->m_origin) ? (Symbol*)(s->m_origin) : (Symbol*)s;
         
      // check the range
      if ( (addr >= sym->m_vaddr) &&  
           (addr < (sym->m_vaddr+ sym->m_size)) ) 
      {
         // symbol is in the range
         res = (SymBase*)sym; 
         return res; 
      }  
                  
      s = s->m_link; 
   }
   return res;         
}
 
// find and output address for all symbols specified by name;
// return 1 if found, 0 otherwise;
int SymTable::fputs 
( 
  char *name,       // name used to lookup the symbol
  uint32_t context, // symbol context
  FILE * fp         // output symbol name to stream if found
)
{
  int res = 0;
      
  if ( this->is_empty() ) 
       return 0; 
  
  // hash index for the bucket
  int hindex = sym_hash ( name ); 
     
  Symbol *sym = m_bucket[hindex];

  while (sym) // possibly iterate over the list
  {
      // check if name match
      if ( 
           (context == Symbol::ANY_CONTEXT || context == sym->m_context) &&
           (strcmp (sym->m_sname, name) == 0)  
         ) 
      {   
          fprintf(fp,"\n%s at address=0x%llx, size=0x%llx \n", sym->m_name, sym->m_vaddr, sym->m_size);
          res = 1;  
      }
         
      // traverse the list for this bucket
      sym = sym->m_next;
  }
       
  return res;     
}
  
 
// find and output full symbol name by specified address ;
// return 1 if found, 0 otherwise;
int SymTable::fputs 
( 
   uint64_t addr,    // address used to lookup the symbol
   uint32_t context, // symbol context
   FILE * fp         // output symbol name to stream if found
)
{
   int res = 0; 
   SymBase *s = find ( addr );  
     
      
   if ( s == NULL )
        return 0;  // not found
           
   while (s)
   {
      Symbol *sym = (s->m_origin) ? (Symbol*)(s->m_origin) : (Symbol*)s;
         
      // check the range
      if (  
           (context == Symbol::ANY_CONTEXT || context == sym->m_context) && 
           (addr >= sym->m_vaddr) &&  
           (addr < (sym->m_vaddr+ sym->m_size)) 
         ) 
      {
         // symbol is in the range
         fprintf (fp, "%s+0x%llx ", sym->m_name, addr - sym->m_vaddr);  
         res = 1; 
      }

      #if(DEBUG_ON)          
      // debug print out
      if (s->m_origin) fprintf (fp, "\nredirected to ->");
      fprintf(fp, "0x%016llx : 0x%016llx : %s , sp=0x%llx \n",
                  sym->m_vaddr, sym->m_size, sym->m_name, s);  
      #endif        
          
      s = s->m_link; 
   }
   return res;         
}
     
// add a new symbol to the symbol table
// return 1 if added, 0 otherwise
int SymTable::add
(
   char * mname,    // module name
   char * name,     // symbol name
   uint64_t vaddr,  // starting address
   uint64_t size,   // range covered
   uint32_t context // symbol context
)
{
   if ((vaddr == ~uint64_t(0)) || (size == 0))
       return 0; 
     
   uint32_t awidth =  m_width[0] + m_sft[0];
   uint64_t max_addr = awidth < 64 ? (uint64_t(1)<<awidth) - 1 : ~uint64_t(0);
     
      
   if ( ~max_addr && (vaddr & ~max_addr) )
   {
       ui->warning( "Symbol: %s ingnored, address 0x%llx exceeds max addr 0x%llx for the sym table. \n",
                name, vaddr, max_addr); 
       return 0; 
   }
     
   // create a new symbol     
   Symbol *sym = new Symbol(mname, name, vaddr, size, context); 
     
   uint64_t addr = vaddr; 
     
   // block size
   uint32_t bsize = m_size[m_lev+1];
     
   // cover all range      
   for (uint64_t offset = 0; ((vaddr+offset) & ~m_mask[m_lev+1]) <= (vaddr+size); offset  += bsize)
   {
       SymBase *new_sym = (SymBase *)sym;  
         
       if (offset !=0 ) // not first symbol in the range
       {
          new_sym = sym->dup(); 
       } 
         
       // find a spot in address tables  
       SymBase **p_sym = (SymBase **)this->alloc(addr);

         
       if (*p_sym==NULL) // table slot is empty
       {
          // insert new symbol
          *p_sym = new_sym;
       }
       else // something is already there
       {
          // overlap with another symbol
          (*p_sym)->attach ( new_sym ); 
          #if(DEBUG_ON)
          ui->verbose("\nnew_sym=0x%llx: %s+0x%llx was attached to p_sym=0x%llx(0x%llx) \n",
                  new_sym, sym->m_name, offset, *p_sym, p_sym);
          #endif
       } 
         
       addr += bsize;
   }  

     
      
   // insert symbol into hash  list
   int hindex = sym_hash (name); // hash index
   sym->m_next = m_bucket[hindex];
   m_bucket[hindex] = sym;
     
   m_empty = false;
     
   return 1; 
}   
       
// print all symbols 
// from low to upper addresses
void SymTable::print ( char *filename, uint32_t context )
{
   uint64_t total = 0;
   
   
   if(filename)
   {
       FILE* fp = fopen (filename, "w"); 

       if ( fp == NULL )
       {
           ui->error("cannot open %s\n", filename);
           return;
       } 
       else
       {
           ui->verbose("Collect symbols to %s file\n", filename);
       }

       if (print_tbl ( fp, m_tbl, 0, total, context )==0)  
           fprintf(fp, "Total number of symbols: %i \n", total);

       fclose(fp);    
   }
   else
   {
       if (print_tbl ( ui->get_output_file(), m_tbl, 0, total, context )==0)  
           fprintf(ui->get_output_file(), "Total number of symbols: %i \n", total);

       // When logging is enabled we replicate output to log file.
       if (ui->get_log_file()
       && (print_tbl ( ui->get_log_file(), m_tbl, 0, total, context )==0))
           fprintf(ui->get_log_file(), "Total number of symbols: %i \n", total);
   }
}
  
// print one symbol
int print_sym ( FILE *fp, Symbol *s, uint32_t context )
{
  if (context != Symbol::ANY_CONTEXT && context != s->context())
     return 0; 

  fprintf(fp, "0x%016llx : 0x%016llx ",
                s->vaddr(), s->size()); 
                
  if (s->context() < Symbol::NO_CONTEXT)
     fprintf(fp, ": 0x%08lx : %s \n", s->context(), s->name());
  else
     fprintf(fp, ": %s \n", s->name()); 
     
  return 1;    
}  
  
// recursively print symbols for all tables on deeper levels
int SymTable::print_tbl 
( 
   FILE *fp,         // output to the stream 
   void ** tbl,      // table pointer
   uint32_t level,   // table level
   uint64_t &total,  // symbol counter
   uint32_t context
)
{
   if ( level == m_lev ) 
   {
       // leaf table 
       for ( int j=0; j<m_size[level]; j++ )
       {
          SymBase *sym = (Symbol *)tbl[j];
             
          while (sym)
          {
             if (sym->m_origin) // range mark - skip it
             {
                 sym = sym->m_link;
                 continue; 
             }    
                   
             Symbol *s = (Symbol *)sym;   
                
             if (print_sym (fp, s, context))
             {
                total++;  
                if ((fp == ui->get_output_file()) && ((total % 40) == 0))
                {
                   fprintf ( fp, "more? space, n - next page, q - quit\n");
                   char c; 
                   scanf("%c", &c); 
                   if (c == 'q')
                      return 1; 
                }
             }
             sym = sym->m_link;
          }
       }
       return 0; 
           
   }    
   else  
   {
       for ( int i=0; i<m_size[level]; i++ )
       {
          if (tbl[i]) // nested table
              if (print_tbl ( fp, (void **)tbl[i], level+1, total, context ) != 0)
                  return 1;  // quit   
       }  
   }
   return 0; 
}
  
// print all symbols without any order - 
// hash table order
int SymTable::hprint ( char *filename, uint32_t context )
{
  int index_max  = 0; 
  int icount_max = 0; 
  int total      = 0;
  int cont       = 0; 
  
  FILE *fp = ui->get_output_file(); 
  
  if(filename)
  {
      fp = fopen (filename, "w"); 
      if ( fp == NULL )
      {
         ui->error("cannot open %s\n", filename);
         return 1;
      } 
      else
      {
         ui->verbose("Collect symbols to %s file\n", filename);
      }
  }
  fprintf(fp, "Symbol table: \n");
    
  for ( int j = 0; j<SYM_TBL_SIZE; j++)
  {
      Symbol *sym = m_bucket[j];
      Symbol *prev = NULL; 
         
      int count = 0; 
            
      while (sym) // possibly iterate through the list
      {       
         if (print_sym (fp, sym, context))
         {        
            count +=1;
            total +=1; 
            if ((cont == 0) && (fp == ui->get_output_file()) && 
            ((total % 40) == 0))
            {
               fprintf ( fp, "more? space, n - next page, q - quit\n");
               char c; 
               scanf("%c", &c); 
               if (c == 'q')
                  goto quiting; 
               else if ( c == 'c' )     
                  cont = 1;  
            }
         }
         sym = sym->m_next;   
      }
         
      if (icount_max < count)
      {
         icount_max = count; 
         index_max  = j; 
      }
         
         
         
  } //for j 

quiting:      
  fprintf(fp, "Total number of symbols: %i \n", total); 
         
  fprintf(fp, "max list size = %i at idx = %i \n", icount_max, index_max); 
        
     
  return 0;
}