vpi.c File Reference

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include "vpi_user.h"
#include "binding.h"
#include "db.h"
#include "defines.h"
#include "instance.h"
#include "link.h"
#include "obfuscate.h"
#include "profiler.h"
#include "symtable.h"
#include "sys_tasks.h"
#include "util.h"

Data Structures
struct	sym_value_s
Typedefs
typedef struct sym_value_s	sym_value
Functions
void	vpi_print_output (const char *msg)
	Displays the given message to standard output.
void	sym_value_store (char *sym, char *value)
void	add_sym_values_to_sim ()
PLI_INT32	covered_value_change_bin (p_cb_data cb)
PLI_INT32	covered_value_change_real (p_cb_data cb)
PLI_INT32	covered_end_of_sim (p_cb_data cb)
PLI_INT32	covered_cb_error_handler (p_cb_data cb)
char *	gen_next_symbol ()
void	covered_create_value_change_cb (vpiHandle sig)
void	covered_parse_task_func (vpiHandle mod)
void	covered_parse_signals (vpiHandle mod)
void	covered_parse_instance (vpiHandle inst)
PLI_INT32	covered_sim_calltf (char *name)
void	covered_register ()
Variables
char	in_db_name [1024]
char	out_db_name [1024]
uint64	last_time = 0
sym_value *	sv_head = NULL
sym_value *	sv_tail = NULL
int	timestep_update = 0
bool	report_covered = FALSE
bool	flag_use_line_width = FALSE
int	line_width = DEFAULT_LINE_WIDTH
bool	report_instance = FALSE
int	flag_race_check = WARNING
tnode *	def_table = NULL
int	fork_depth = -1
int *	fork_block_depth
int	block_depth = 0
int	merge_in_num
char **	merge_in = NULL
char *	top_module = NULL
char *	top_instance = NULL
unsigned int	flag_global_generation = GENERATION_SV
int	generate_expr_mode = 0
bool	cli_debug_mode = FALSE
bool	flag_use_command_line_debug = FALSE
struct exception_context	the_exception_context [1]
str_link *	merge_in_head = NULL
str_link *	merge_in_tail = NULL
char *	cdd_message = NULL
char *	merged_file = NULL
bool	flag_output_exclusion_ids = FALSE
bool	report_exclusions = FALSE
str_link *	race_ignore_mod_head = NULL
str_link *	race_ignore_mod_tail = NULL
bool	instance_specified = FALSE
bool	debug_mode
symtable *	vcd_symtab
int	vcd_symtab_size
symtable **	timestep_tab
char **	curr_inst_scope
int	curr_inst_scope_size
funit_inst *	curr_instance
char	user_msg [USER_MSG_LENGTH]
isuppl	info_suppl
void(*	vlog_startup_routines [])()

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

5/6/2005

---

Typedef Documentation

typedef struct sym_value_s sym_value

Renaming sym_value_s structure for convenience.

---

Function Documentation

void add_sym_values_to_sim

(

)

Iterates through the sym_value list, adding the information to Covered's simulation core and deallocating its memory. Called by the covered_sim_calltf function.

References db_set_symbol_string(), free_safe, sym_value_s::next, PROFILE, PROFILE_END, sym_value_s::sym, and sym_value_s::value.

Referenced by covered_sim_calltf().

                             { PROFILE(ADD_SYM_VALUES_TO_SIM);

  sym_value* sval;  /* Pointer to current sym_value structure */

  sval = sv_head;
  while( sv_head != NULL ) {

    /* Assign the current sv_head to the sval pointer */
    sval    = sv_head;
    sv_head = sv_head->next;

    /* Set the given symbol to the given value in Covered's simulator */
    db_set_symbol_string( sval->sym, sval->value );

    /* Deallocate all memory associated with this sym_table structure */
    free_safe( sval->sym, (strlen( sval->sym ) + 1) );
    free_safe( sval->value, (strlen( sval->value ) + 1) );
    free_safe( sval, sizeof( sym_value ) );
  }

  PROFILE_END;

}

PLI_INT32 covered_cb_error_handler

(

p_cb_data

cb

)

References obf_file, PROFILE, and PROFILE_END.

Referenced by covered_sim_calltf().

                                                   { PROFILE(COVERED_CB_ERROR_HANDLER);

  struct t_vpi_error_info einfotab;
  struct t_vpi_error_info *einfop;
  char   s1[128];

  einfop = &einfotab;
  vpi_chk_error( einfop );

  if( einfop->state == vpiCompile ) {
    strcpy( s1, "vpiCompile" );
  } else if( einfop->state == vpiPLI ) {
    strcpy( s1, "vpiPLI" );
  } else if( einfop->state == vpiRun ) {
    strcpy( s1, "vpiRun" );
  } else {
    strcpy( s1, "**unknown**" );
  }

  vpi_printf( "covered VPI: ERR(%s) %s (level %d) at **%s(%d):\n  %s\n",
    einfop->code, s1, einfop->level, obf_file( einfop->file ), einfop->line, einfop->message );

  /* If serious error give up */
  if( (einfop->level == vpiError) || (einfop->level == vpiSystem) || (einfop->level == vpiInternal) ) {
    vpi_printf( "covered VPI: FATAL: encountered error - giving up\n" );
    vpi_control( vpiFinish, 0 );
  }

  PROFILE_END;

  return( 0 );

}

void covered_create_value_change_cb

(

vpiHandle

sig

)

Finds the given VPI signal in Covered's database and creates a callback function that will be called whenever this signal changes value during simulation. Also retrieves the initial value of the signal and stores it in the sym_value list and creates a symbol in the symtable structure for this signal.

Parameters:

sig

Pointer to vpiHandle for a given signal

References ssuppl_u::assigned, covered_value_change_bin(), covered_value_change_real(), db_assign_symbol(), DEBUG, debug_mode, vsignal_s::dim, funit_inst_s::funit, gen_next_symbol(), dim_range_s::lsb, vsignal_s::name, obf_sig, ssuppl_u::part, print_output(), PROFILE, PROFILE_END, scope_find_signal(), sig_link_s::sig, func_unit_s::sig_head, sig_link_find(), vsignal_s::suppl, sym_value_store(), user_msg, USER_MSG_LENGTH, vsignal_s::value, and vector_s::width.

Referenced by covered_parse_signals(), and covered_parse_task_func().

  { PROFILE(COVERED_CREATE_VALUE_CHANGE_CB);

  p_cb_data   cb;
  sig_link*   vsigl = NULL;
  vsignal*    vsig  = NULL;
  func_unit*  found_funit;
  char*       symbol;
  s_vpi_value value;

  /* Only add the signal if it is in our database and needs to be assigned from the simulator */
  if( (curr_instance->funit != NULL) &&
      (((vsigl = sig_link_find( vpi_get_str( vpiName, sig ), curr_instance->funit->sig_head )) != NULL) ||
       scope_find_signal( vpi_get_str( vpiName, sig ), curr_instance->funit, &vsig, &found_funit, 0 )) &&
      (((vsigl != NULL) && (vsigl->sig->suppl.part.assigned == 0)) ||
       ((vsig  != NULL) && (vsig->suppl.part.assigned == 0))) ) {

    if( vsigl != NULL ) {
      vsig = vsigl->sig;
    }

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Adding callback for signal: %s", obf_sig( vsig->name ) );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif

    /* Generate new symbol */
    if( (symbol = gen_next_symbol()) == NULL ) {
      vpi_printf( "covered VPI: INTERNAL ERROR:  Unable to generate unique symbol name\n" );
      /* Need to increase number of characters in symbol array */
      vpi_control( vpiFinish, 0 );
    }

    /* Add signal/symbol to symtab database */
    db_assign_symbol( vpi_get_str( vpiName, sig ), symbol, ((vsig->value->width + vsig->dim[0].lsb) - 1), vsig->dim[0].lsb ); 

    /* Get initial value of this signal and store it for later retrieval */
    if( vpi_get( vpiType, sig ) == vpiRealVar ) {

      char real_str[64];
      value.format = vpiRealVal;
      vpi_get_value( sig, &value );
      snprintf( real_str, 64, "%f", value.value.real );
      sym_value_store( symbol, real_str );

    } else {

      value.format = vpiBinStrVal;
      vpi_get_value( sig, &value );
      sym_value_store( symbol, value.value.str );

    }

    /* Add a callback for a value change to this net */
    cb                   = (p_cb_data)malloc( sizeof( s_cb_data ) );
    cb->reason           = cbValueChange;
    if( vpi_get( vpiType, sig ) == vpiRealVar ) {
      cb->cb_rtn         = covered_value_change_real;
    } else {
      cb->cb_rtn         = covered_value_change_bin;
    }
    cb->obj              = sig;
    cb->time             = (p_vpi_time)malloc( sizeof( s_vpi_time ) ); 
    cb->time->type       = vpiSimTime;
    cb->time->high       = 0;
    cb->time->low        = 0;
#ifdef NOIV
    cb->value            = (p_vpi_value)malloc( sizeof( s_vpi_value ) );
    if( vpi_get( vpiType, sig ) == vpiRealVar ) {
      cb->value->format    = vpiRealVal;
    } else {
      cb->value->format    = vpiBinStrVal;
      cb->value->value.str = NULL;
    }
#else
    cb->value            = NULL;
#endif
    cb->user_data        = symbol;
    vpi_register_cb( cb );

  }

  PROFILE_END;

}

PLI_INT32 covered_end_of_sim

(

p_cb_data

cb

)

References Catch_anonymous, curr_inst_scope, curr_inst_scope_size, db_close(), db_do_timestep(), db_write(), FALSE, free_safe, last_time, malloc_safe, out_db_name, isuppl_u::part, PROFILE, PROFILE_END, isuppl_u::scored, sim_dealloc(), symtable_dealloc(), sys_task_dealloc(), TRUE, Try, and vcd_symtab_size.

Referenced by covered_sim_calltf().

                                             { PROFILE(COVERED_END_OF_SIM);

  p_vpi_time final_time;

  (void)db_do_timestep( last_time, FALSE );

  /* Get the final simulation time */
  final_time       = (p_vpi_time)malloc_safe( sizeof( s_vpi_time ) );
  final_time->type = vpiSimTime;
  vpi_get_time( NULL, final_time );

  /* Flush any pending statement trees that are waiting for delay */
  last_time = ((uint64)final_time->high << 32) | (uint64)final_time->low;
  (void)db_do_timestep( last_time, FALSE );

  /* Perform one last simulation timestep */
  (void)db_do_timestep( 0, TRUE );

  /* Indicate that this CDD contains scored information */
  info_suppl.part.scored = 1;

  /* Write contents to database file */
  Try {
    db_write( out_db_name, FALSE, FALSE );
    vpi_printf( "covered VPI: Output coverage information to %s\n", out_db_name );
  } Catch_anonymous {
    vpi_printf( "covered VPI: Unable to write database file\n" );
  }

  /* Deallocate memory */
  if( curr_inst_scope_size > 0 ) {
    unsigned int i;
    for( i=0; i<curr_inst_scope_size; i++ ) {
      free_safe( curr_inst_scope[i], (strlen( curr_inst_scope[i] ) + 1) );
    }
    free_safe( curr_inst_scope, sizeof( char* ) );
    curr_inst_scope_size = 0;
  }
  symtable_dealloc( vcd_symtab );
  sim_dealloc();
  sys_task_dealloc();
  db_close();
  if( timestep_tab != NULL ) {
    free_safe( timestep_tab, (sizeof( symtable*) * vcd_symtab_size) );
  }

  PROFILE_END;

  return( 0 );

}

void covered_parse_instance

(

vpiHandle

inst

)

References covered_parse_signals(), covered_parse_task_func(), curr_inst_scope, curr_inst_scope_size, db_sync_curr_instance(), DEBUG, debug_mode, free_safe, obf_funit, obf_inst, print_output(), PROFILE, PROFILE_END, strdup_safe, user_msg, and USER_MSG_LENGTH.

Referenced by covered_sim_calltf().

                                              { PROFILE(COVERED_PARSE_INSTANCE);

  vpiHandle iter, handle;

  /* Set current scope in database */
  if( curr_inst_scope[0] != NULL ) {
    free_safe( curr_inst_scope[0], (strlen( curr_inst_scope[0] ) + 1) );
  }
  curr_inst_scope[0] = strdup_safe( vpi_get_str( vpiFullName, inst ) );
  curr_inst_scope_size = 1;

  /* Synchronize curr_instance to point to curr_inst_scope */
  db_sync_curr_instance();

  /* If current instance is known, parse this instance */
  if( curr_instance != NULL ) {

#ifdef DEBUG_MODE
    if( debug_mode ) {
      unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Found module to be covered: %s, hierarchy: %s",
                                  obf_funit( vpi_get_str( vpiName, inst ) ), obf_inst( curr_inst_scope[0] ) );
      assert( rv < USER_MSG_LENGTH );
      print_output( user_msg, DEBUG, __FILE__, __LINE__ );
    }
#endif

    /* Parse all signals */
    covered_parse_signals( inst );

    /* Parse all functions/tasks */
    covered_parse_task_func( inst );

  }

  /* Search children modules */
  if( (iter = vpi_iterate( vpiModule, inst )) != NULL ) {

    while( (handle = vpi_scan( iter )) != NULL ) {
      covered_parse_instance( handle );
    }

  }

  PROFILE_END;

}

void covered_parse_signals

(

vpiHandle

mod

)

References covered_create_value_change_cb(), DEBUG, debug_mode, obf_sig, print_output(), PROFILE, PROFILE_END, user_msg, and USER_MSG_LENGTH.

Referenced by covered_parse_instance().

                                            { PROFILE(COVERED_PARSE_SIGNALS);

  vpiHandle iter, handle;
  int       type;

  /* Parse nets */
  if( (iter = vpi_iterate( vpiNet, mod )) != NULL ) {
    while( (handle = vpi_scan( iter )) != NULL ) {
#ifdef DEBUG_MODE
      if( debug_mode ) {
        unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Found net: %s", obf_sig( vpi_get_str( vpiName, handle ) ) );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, DEBUG, __FILE__, __LINE__ );
      }
#endif
      covered_create_value_change_cb( handle );
    }
  }

  /* Parse regs */
  if( (iter = vpi_iterate( vpiReg, mod )) != NULL ) {
    while( (handle = vpi_scan( iter )) != NULL ) {
#ifdef DEBUG_MODE
      if( debug_mode ) {
        unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Found reg: %s", obf_sig( vpi_get_str( vpiName, handle ) ) );
        assert( rv < USER_MSG_LENGTH );
        print_output( user_msg, DEBUG, __FILE__, __LINE__ );
      }
#endif
      covered_create_value_change_cb( handle );
    }
  }

  /* Parse integers */
  if( (iter = vpi_iterate( vpiVariables, mod )) != NULL ) {
    while( (handle = vpi_scan( iter )) != NULL ) {
      type = vpi_get( vpiType, handle );
      if( (type == vpiIntegerVar) || (type == vpiTimeVar) || (type == vpiReg) || (type == vpiRealVar) ) {
#ifdef DEBUG_MODE
        if( debug_mode ) {
          unsigned int rv;
          if( type == vpiIntegerVar ) {
            rv = snprintf( user_msg, USER_MSG_LENGTH, "Found integer: %s", obf_sig( vpi_get_str( vpiName, handle ) ) );
          } else if( type == vpiTimeVar ) {
            rv = snprintf( user_msg, USER_MSG_LENGTH, "Found time: %s", obf_sig( vpi_get_str( vpiName, handle ) ) );
          } else if( type == vpiRealVar ) {
            rv = snprintf( user_msg, USER_MSG_LENGTH, "Found real: %s", obf_sig( vpi_get_str( vpiName, handle ) ) );
          } else if( type == vpiReg ) {
            rv = snprintf( user_msg, USER_MSG_LENGTH, "Found reg: %s", obf_sig( vpi_get_str( vpiName, handle ) ) );
          }
          assert( rv < USER_MSG_LENGTH );
          print_output( user_msg, DEBUG, __FILE__, __LINE__ );
        }
#endif
        covered_create_value_change_cb( handle );
      }
    }
  }

  PROFILE_END;

}

void covered_parse_task_func

(

vpiHandle

mod

)

References covered_create_value_change_cb(), curr_inst_scope, curr_inst_scope_size, db_sync_curr_instance(), DEBUG, debug_mode, free_safe, obf_funit, obf_sig, print_output(), PROFILE, PROFILE_END, strdup_safe, user_msg, and USER_MSG_LENGTH.

Referenced by covered_parse_instance().

                                              { PROFILE(COVERED_PARSE_TASK_FUNC);

  vpiHandle iter, handle;
  vpiHandle liter, scope;
  int       type;
        
  /* Parse all internal scopes for tasks and functions */
  if( (iter = vpi_iterate( vpiInternalScope, mod )) != NULL ) {

    while( (scope = vpi_scan( iter )) != NULL ) {
      
      type = vpi_get( vpiType, scope );

      if( (type == vpiTask) || (type == vpiFunction) || (type == vpiNamedBegin) ) {

#ifdef DEBUG_MODE
        if( debug_mode ) {
          unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Parsing task/function %s", obf_funit( vpi_get_str( vpiFullName, scope ) ) );
          assert( rv < USER_MSG_LENGTH );
          print_output( user_msg, DEBUG, __FILE__, __LINE__ );
        }
#endif

        /* Set current scope in database */
        if( curr_inst_scope[0] != NULL ) {
          free_safe( curr_inst_scope[0], (strlen( curr_inst_scope[0] ) + 1) );
        }
        curr_inst_scope[0]   = strdup_safe( vpi_get_str( vpiFullName, scope ) );
        curr_inst_scope_size = 1;

        /* Synchronize curr_instance to point to curr_inst_scope */
        db_sync_curr_instance();

        if( curr_instance != NULL ) {

          /* Parse signals */
          if( (liter = vpi_iterate( vpiNet, scope )) != NULL ) {
            while( (handle = vpi_scan( liter )) != NULL ) {
#ifdef DEBUG_MODE
              if( debug_mode ) {
                unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Found net: %s", obf_sig( vpi_get_str( vpiFullName, handle ) ) );
                assert( rv < USER_MSG_LENGTH );
                print_output( user_msg, DEBUG, __FILE__, __LINE__ );
              }
#endif
              covered_create_value_change_cb( handle );
            }
          }

          if( (liter = vpi_iterate( vpiReg, scope )) != NULL ) {
            while( (handle = vpi_scan( liter )) != NULL ) {
#ifdef DEBUG_MODE
              if( debug_mode ) {
                unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Found reg %s", obf_sig( vpi_get_str( vpiFullName, handle ) ) );
                assert( rv < USER_MSG_LENGTH );
                print_output( user_msg, DEBUG, __FILE__, __LINE__ );
              }
#endif
              covered_create_value_change_cb( handle );
            }
          }

          if( (liter = vpi_iterate( vpiVariables, scope )) != NULL ) {
            while( (handle = vpi_scan( liter )) != NULL ) {
              type = vpi_get( vpiType, handle );
#ifdef DEBUG_MODE
              if( debug_mode ) {
                unsigned int rv;
                if( type == vpiReg ) {
                  rv = snprintf( user_msg, USER_MSG_LENGTH, "Found reg %s", obf_sig( vpi_get_str( vpiFullName, handle ) ) );
                } else if( type == vpiIntegerVar ) {
                  rv = snprintf( user_msg, USER_MSG_LENGTH, "Found integer %s", obf_sig( vpi_get_str( vpiFullName, handle ) ) );
                } else if( type == vpiTimeVar ) {
                  rv = snprintf( user_msg, USER_MSG_LENGTH, "Found time %s", obf_sig( vpi_get_str( vpiFullName, handle ) ) );
                } else if( type == vpiRealVar ) {
                  rv = snprintf( user_msg, USER_MSG_LENGTH, "Found real %s", obf_sig( vpi_get_str( vpiFullName, handle ) ) );
                }
                assert( rv < USER_MSG_LENGTH );
                print_output( user_msg, DEBUG, __FILE__, __LINE__ );
              }
#endif
              covered_create_value_change_cb( handle );
            }
          }

          /* Recursively check scope */
          if( (liter = vpi_iterate( vpiInternalScope, scope )) != NULL ) {
            while( (handle = vpi_scan( liter )) != NULL ) {
              covered_parse_task_func( handle );
            }
          }

        }

      }

    }

  }

  PROFILE_END;

}

void covered_register

(

)

References covered_sim_calltf().

                        {
  s_vpi_systf_data tf_data;

  vpi_printf("VPI: Registering covered_sim system_task");

  tf_data.type      = vpiSysTask;
  tf_data.tfname    = "$covered_sim";
  tf_data.calltf    = covered_sim_calltf;
  tf_data.compiletf = 0;
  tf_data.sizetf    = 0;
  tf_data.user_data = "$covered_sim";

  vpi_register_systf( &tf_data );
  if (vpi_chk_error(NULL)) {
    vpi_printf("Error occured while setting up user %s\n",
               "defined system tasks and functions.");
    return;
  }

}

PLI_INT32 covered_sim_calltf

(

char *

name

)

References add_sym_values_to_sim(), bind_perform(), Catch_anonymous, covered_cb_error_handler(), covered_end_of_sim(), covered_parse_instance(), curr_inst_scope, curr_inst_scope_size, db_read(), debug_mode, FALSE, in_db_name, init_exception_context, malloc_safe_nolimit, out_db_name, PROFILE, PROFILE_END, profiler_set_filename(), profiler_set_mode(), PROFILING_OUTPUT_NAME, READ_MODE_NO_MERGE, sim_initialize(), symtable_create(), sys_task_store_plusarg(), the_exception_context, TRUE, Try, and vcd_symtab_size.

Referenced by covered_register().

                                           {
#endif
  PROFILE(COVERED_SIM_CALLTF);

  vpiHandle       systf_handle, arg_iterator, module_handle;
  vpiHandle       arg_handle;
  s_vpi_vlog_info info;
  p_cb_data       cb;
  int             i;
  char*           argvptr;
  sig_link*       vsigl;
  s_vpi_value     value;

  /* Initialize the exception handler context structure */
  init_exception_context( the_exception_context );

  systf_handle = vpi_handle( vpiSysTfCall, NULL );
  arg_iterator = vpi_iterate( vpiArgument, systf_handle );

  /* Create callback that will handle the end of simulation */
  cb            = (p_cb_data)malloc( sizeof( s_cb_data ) );
  cb->reason    = cbEndOfSimulation;
  cb->cb_rtn    = covered_end_of_sim;
  cb->obj       = NULL;
  cb->time      = NULL;
  cb->value     = NULL;
  cb->user_data = NULL;
  vpi_register_cb( cb );

#ifdef TBD
  /* Create error handling callback */
  cb            = (p_cb_data)malloc( sizeof( s_cb_data ) );
  cb->reason    = cbError;
  cb->cb_rtn    = covered_cb_error_handler;
  cb->obj       = NULL;
  cb->time      = NULL;
  cb->value     = NULL;
  cb->user_data = NULL;
  vpi_register_cb( cb );
#endif

  /* Get name of CDD database file from system call arguments */
  if( (arg_handle = vpi_scan( arg_iterator )) != NULL ) {
    s_vpi_value data;
    data.format = vpiStringVal;
    vpi_get_value( arg_handle, &data );
    strcpy( in_db_name, data.value.str );
  }

  /* Get name of CDD database to write to (default is cov.cdd) and debug mode */
  strcpy( out_db_name, "cov.cdd" );
  profiler_set_mode( FALSE );
  if( vpi_get_vlog_info( &info ) ) {
    for( i=1; i<info.argc; i++ ) {
      argvptr = info.argv[i];
      if( strncmp( "+covered_cdd=", argvptr, 13 ) == 0 ) {
        argvptr += 13;
        strcpy( out_db_name, argvptr );
      } else if( strncmp( "+covered_debug", argvptr, 14 ) == 0 ) {
        vpi_printf( "covered VPI: Turning debug mode on\n" );
        debug_mode = TRUE;
      } else if( strncmp( "+covered_profile=", argvptr, 17 ) == 0 ) {
        vpi_printf( "covered VPI: Turning profiler on.  Outputting to %s\n", argvptr + 17 );
        profiler_set_mode( TRUE );
        profiler_set_filename( argvptr + 17 );
      } else if( strncmp( "+covered_profile", argvptr, 16 ) == 0 ) {
        vpi_printf( "covered VPI: Turning profiler on.  Outputting to %s\n", PROFILING_OUTPUT_NAME );
        profiler_set_mode( TRUE );
        profiler_set_filename( PROFILING_OUTPUT_NAME );
      }
      sys_task_store_plusarg( info.argv[i] + 1 );
    }
  }

  /* Read in contents of specified database file */
  Try {
    db_read( in_db_name, READ_MODE_NO_MERGE ); 
  } Catch_anonymous {
    vpi_printf( "covered VPI: Unable to read database file\n" );
    vpi_control( vpiFinish, EXIT_FAILURE );
  }

  vpi_printf( "covered VPI: Read design information from %s\n", in_db_name );

  /* Bind expressions to signals/functional units */
  Try {
    bind_perform( TRUE, 0 );
  } Catch_anonymous {
    vpi_control( vpiFinish, EXIT_FAILURE );
  }

  /* Add static values to simulator */
  sim_initialize();

  /* Create initial symbol table */
  vcd_symtab = symtable_create();

  /* Initialize the curr_inst_scope structure */
  curr_inst_scope      = (char**)malloc( sizeof( char* ) );
  curr_inst_scope[0]   = NULL;
  curr_inst_scope_size = 1;

  /* Parse child instances - associate a signal in the design with a signal in Covered */
  while( (module_handle = vpi_scan( arg_iterator )) != NULL ) {
    covered_parse_instance( module_handle );
  }

  /* Create timestep symbol table array */
  if( vcd_symtab_size > 0 ) {
    timestep_tab = malloc_safe_nolimit( (sizeof( symtable*) * vcd_symtab_size) );
  }

  /* Add all of the sym_value structures to the simulation core */
  add_sym_values_to_sim();

  PROFILE_END;

  return 0;

}

PLI_INT32 covered_value_change_bin

(

p_cb_data

cb

)

Returns:

Returns 0.

This callback function is called whenever a signal changes within the simulator. It places this value in the Covered symtable and calls the db_do_timestep if this value change occurred on a new timestep.

Parameters:

cb

Pointer to callback data structure from vpi_user.h

References db_do_timestep(), db_set_symbol_string(), DEBUG, debug_mode, FALSE, last_time, obf_sig, print_output(), PROFILE, PROFILE_END, user_msg, and USER_MSG_LENGTH.

Referenced by covered_create_value_change_cb().

  { PROFILE(COVERED_VALUE_CHANGE_BIN);

#ifndef NOIV
  s_vpi_value value;

  /* Setup value */
  value.format = vpiBinStrVal;
  vpi_get_value( cb->obj, &value );

#ifdef DEBUG_MODE
  if( debug_mode ) {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "In covered_value_change_bin, name: %s, time: %" FMT64 "u, value: %s",
                                obf_sig( vpi_get_str( vpiFullName, cb->obj ) ), (((uint64)cb->time->high << 32) | (uint64)cb->time->low), value.value.str );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, DEBUG, __FILE__, __LINE__ );
  }
#endif

  if( (cb->time->low  != (PLI_INT32)(last_time & 0xffffffff)) || (cb->time->high != (PLI_INT32)((last_time >> 32) & 0xffffffff)) ) {
    if( !db_do_timestep( last_time, FALSE ) ) {
      vpi_control( vpiFinish, EXIT_SUCCESS );
    }
  }
  last_time = ((uint64)cb->time->high << 32) | (uint64)cb->time->low;
  
  /* Set symbol value */
  db_set_symbol_string( cb->user_data, value.value.str );
#else
#ifdef DEBUG_MODE
  if( debug_mode ) {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "In covered_value_change_bin, name: %s, time: %" FMT64 "u, value: %s",
                                obf_sig( vpi_get_str( vpiFullName, cb->obj ) ), (((uint64)cb->time->high << 32) | (uint64)cb->time->low), cb->value->value.str );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, DEBUG, __FILE__, __LINE__ );
  }
#endif

  if( (cb->time->low  != (PLI_INT32)(last_time & 0xffffffff)) || (cb->time->high != (PLI_INT32)((last_time >> 32) & 0xffffffff)) ) {
    if( !db_do_timestep( last_time, FALSE ) ) {
      vpi_control( vpiFinish, EXIT_SUCCESS );
    }
  }
  last_time = ((uint64)cb->time->high << 32) | (uint64)cb->time->low;

  /* Set symbol value */
  db_set_symbol_string( cb->user_data, cb->value->value.str );
#endif

  PROFILE_END;

  return( 0 );

}

PLI_INT32 covered_value_change_real

(

p_cb_data

cb

)

Returns:

Returns 0.

This callback function is called whenever a signal changes within the simulator. It places this value in the Covered symtable and calls the db_do_timestep if this value change occurred on a new timestep.

Parameters:

cb

Pointer to callback data structure from vpi_user.h

References db_do_timestep(), db_set_symbol_string(), DEBUG, debug_mode, FALSE, last_time, obf_sig, print_output(), PROFILE, PROFILE_END, user_msg, and USER_MSG_LENGTH.

Referenced by covered_create_value_change_cb().

  { PROFILE(COVERED_VALUE_CHANGE_REAL);

  char real_str[64];

#ifndef NOIV
  s_vpi_value value;

  /* Setup value */
  value.format = vpiRealVal;
  vpi_get_value( cb->obj, &value );

#ifdef DEBUG_MODE
  if( debug_mode ) {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "In covered_value_change_real, name: %s, time: %" FMT64 "u, value: %.16f",
                                obf_sig( vpi_get_str( vpiFullName, cb->obj ) ), (((uint64)cb->time->high << 32) | (uint64)cb->time->low), value.value.real );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, DEBUG, __FILE__, __LINE__ );
  }
#endif

  if( (cb->time->low  != (PLI_INT32)(last_time & 0xffffffff)) || (cb->time->high != (PLI_INT32)((last_time >> 32) & 0xffffffff)) ) {
    if( !db_do_timestep( last_time, FALSE ) ) {
      vpi_control( vpiFinish, EXIT_SUCCESS );
    }
  }
  last_time = ((uint64)cb->time->high << 32) | (uint64)cb->time->low;

  /* Set symbol value */
  snprintf( real_str, 64, "%.16f", value.value.real );
  db_set_symbol_string( cb->user_data, real_str );
#else
#ifdef DEBUG_MODE
  if( debug_mode ) {
    unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "In covered_value_change_real, name: %s, time: %" FMT64 "u, value: %.16f",
                                obf_sig( vpi_get_str( vpiFullName, cb->obj ) ), (((uint64)cb->time->high << 32) | (uint64)cb->time->low), cb->value->value.real );
    assert( rv < USER_MSG_LENGTH );
    print_output( user_msg, DEBUG, __FILE__, __LINE__ );
  }
#endif

  if( (cb->time->low  != (PLI_INT32)(last_time & 0xffffffff)) || (cb->time->high != (PLI_INT32)((last_time >> 32) & 0xffffffff)) ) {
    if( !db_do_timestep( last_time, FALSE ) ) {
      vpi_control( vpiFinish, EXIT_SUCCESS );
    }
  }
  last_time = ((uint64)cb->time->high << 32) | (uint64)cb->time->low;

  /* Set symbol value */
  snprintf( real_str, 64, "%.16f", cb->value->value.real );
  db_set_symbol_string( cb->user_data, real_str );
#endif

  PROFILE_END;

  return( 0 );

}

char* gen_next_symbol

(

)

References PROFILE, PROFILE_END, and strdup_safe.

Referenced by covered_create_value_change_cb().

                        { PROFILE(GEN_NEXT_SYMBOL);

  static char symbol[21]   = {32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,32,'\0'};
  static int  symbol_index = 19;
  int         i            = 19;

  while( (i >= symbol_index) && (symbol[i] == 126) ) {
    symbol[i] = 33;
    if( (i - 1) < symbol_index ) {
      symbol_index--;
      if( symbol_index < 0 ) {
        return( NULL );
      }
    }
    i--;
  }
  symbol[i]++;

  PROFILE_END;

  return( strdup_safe( symbol + symbol_index ) );

}

void sym_value_store	(	char *	sym,
		char *	value
	)

Stores the given signal symbol and initial value in the sym_value list that will be assigned to the simulator once the timestep table has been allocated.

Parameters:

	sym	Symbol string of signal to store
	value	Initial signal value to store

References malloc_safe, sym_value_s::next, PROFILE, PROFILE_END, strdup_safe, sym_value_s::sym, and sym_value_s::value.

Referenced by covered_create_value_change_cb().

  { PROFILE(SYM_VALUE_STORE);

  sym_value* sval;  /* Pointer to newly allocated sym_value structure */

  /* Allocate and initialize the sym_value structure */
  sval = (sym_value*)malloc_safe( sizeof( sym_value ) );
  sval->sym   = strdup_safe( sym );
  sval->value = strdup_safe( value );
  sval->next  = NULL; 

  /* Add the newly created sym_value structure to the sv list */
  if( sv_head == NULL ) {
    sv_head = sv_tail = sval;
  } else {
    sv_tail->next = sval;
    sv_tail       = sval;
  }

  PROFILE_END;

}

void vpi_print_output

(

const char *

msg

)

Displays the given message to standard output.

Parameters:

msg

Message to output to standard output

Outputs the given message to standard output using the vpi_printf function.

Referenced by print_output().

                                         {

  vpi_printf( "covered VPI: %s\n", msg );

}

---

Variable Documentation

int block_depth = 0

Referenced by db_parallelize_statement().

char* cdd_message = NULL

User-supplied message to include in the CDD database

Referenced by info_db_write(), info_dealloc(), merge_parse_args(), message_db_read(), report_print_header(), and score_parse_args().

bool cli_debug_mode = FALSE

Referenced by expression_assign(), expression_op_func__idec(), expression_op_func__iinc(), expression_op_func__pdec(), expression_op_func__pinc(), print_output(), sim_dealloc(), sim_initialize(), and sim_perform_nba().

char** curr_inst_scope

Specifies the string Verilog scope that is currently specified in the VCD file.

Referenced by covered_end_of_sim(), covered_parse_instance(), covered_parse_task_func(), covered_sim_calltf(), db_gen_curr_inst_scope(), db_set_vcd_scope(), db_vcd_upscope(), and lxt_parse().

int curr_inst_scope_size

Current size of curr_inst_scope array

Referenced by covered_end_of_sim(), covered_parse_instance(), covered_parse_task_func(), covered_sim_calltf(), db_close(), db_gen_curr_inst_scope(), db_set_vcd_scope(), db_vcd_upscope(), and lxt_parse().

funit_inst* curr_instance

Pointer to the current instance selected by the VCD parser. If this value is NULL, the current instance does not reside in the design specified for coverage.

bool debug_mode

If set to TRUE, causes debug information to be spewed to screen.

tnode* def_table = NULL

unsigned int flag_global_generation = GENERATION_SV

Specifies the supported global generation value

Referenced by parser_check_generation(), score_parse_args(), and search_init().

bool flag_output_exclusion_ids = FALSE

Outputs the exclusion ID for an output coverage point. The exclusion ID can be used by the exclude command for excluding/including coverage points.

Referenced by combination_event(), combination_list_missed(), combination_multi_expr_output(), combination_multi_vars(), combination_two_vars(), combination_unary(), fsm_display_arc_verbose(), line_display_verbose(), memory_display_verbose(), ovl_display_verbose(), report_parse_args(), report_print_header(), and toggle_display_verbose().

int flag_race_check = WARNING

Specifies how race conditions should be handled

Referenced by race_check_race_count(), race_handle_race_condition(), and score_parse_args().

bool flag_use_command_line_debug = FALSE

Specifies whether the command-line debugger should be enabled

Referenced by expression_assign(), expression_op_func__idec(), expression_op_func__iinc(), expression_op_func__pdec(), expression_op_func__pinc(), print_output(), score_parse_args(), sim_add_thread(), sim_initialize(), sim_kill_thread(), sim_perform_nba(), sim_simulate(), sim_thread_insert_into_delay_queue(), sim_thread_pop_head(), and sim_thread_push().

bool flag_use_line_width = FALSE

If set to a boolean value of TRUE, displays combination logic output in a by-line-width format (instead of the user specified Verilog source format).

Referenced by codegen_create_expr(), and report_parse_args().

int* fork_block_depth

Referenced by db_parallelize_statement().

int fork_depth = -1

Referenced by db_parallelize_statement().

int generate_expr_mode = 0

Referenced by db_add_function_task_namedblock(), db_add_instance(), and expression_create().

char in_db_name[1024]

Name of input CDD file

Referenced by covered_sim_calltf().

isuppl info_suppl

Informational line for the CDD file.

bool instance_specified = FALSE

Specifies if -i option was specified

Referenced by db_check_dumpfile_scopes(), parse_design(), and score_parse_args().

uint64 last_time = 0

Last simulation time seen from simulator

Referenced by covered_end_of_sim(), covered_value_change_bin(), and covered_value_change_real().

int line_width = DEFAULT_LINE_WIDTH

Specifies the number of characters wide that an expression will allowed to be output for if the flag_use_line_width value is set to TRUE.

Referenced by codegen_create_expr(), combination_multi_expr_output(), combination_multi_expr_output_length(), report_output_exclusion_reason(), and report_parse_args().

char** merge_in = NULL

str_link* merge_in_head = NULL

Pointer to head of list containing names of the input CDD files.

int merge_in_num

Specifies the number of merged CDD files.

Referenced by info_db_read(), info_db_write(), info_dealloc(), merge_check(), and merged_cdd_db_read().

str_link* merge_in_tail = NULL

Pointer to tail of list containing names of the input CDD files.

char* merged_file = NULL

Specifies the output filename of the CDD file that contains the merged data.

Referenced by command_merge(), info_db_write(), merge_check(), and merge_parse_args().

char out_db_name[1024]

Name of output CDD file

Referenced by covered_end_of_sim(), and covered_sim_calltf().

str_link* race_ignore_mod_head = NULL

Pointer to head of string list containing the names of modules that should be ignored for race condition checking.

str_link* race_ignore_mod_tail = NULL

Pointer to tail of string list containing the names of modules that should be ignored for race condition checking.

bool report_covered = FALSE

If set to a boolean value of TRUE, displays covered logic for a particular CDD file. By default, Covered will display uncovered logic. Must be used in conjunction with the -d v|d (verbose output) option.

Referenced by assertion_funit_verbose(), assertion_instance_verbose(), assertion_report(), combination_funit_verbose(), combination_instance_verbose(), combination_report(), fsm_display_state_verbose(), fsm_display_verbose(), fsm_funit_verbose(), fsm_instance_verbose(), fsm_report(), line_display_verbose(), line_funit_verbose(), line_instance_verbose(), line_report(), memory_funit_verbose(), memory_instance_verbose(), memory_report(), ovl_display_verbose(), report_parse_args(), toggle_funit_verbose(), toggle_instance_verbose(), and toggle_report().

bool report_exclusions = FALSE

If set to a boolean value of TRUE, displays excluded coverage points for a particular CDD file. By default, Covered will not display excluded coverage points. This can be useful when used in conjunction with the -x option for including excluded coverage points. Must be used in conjunction with the -d v|d (verbose output) option.

Referenced by assertion_funit_verbose(), assertion_instance_verbose(), combination_funit_verbose(), combination_instance_verbose(), combination_list_missed(), combination_report(), fsm_display_verbose(), fsm_funit_verbose(), fsm_instance_verbose(), fsm_report(), line_funit_verbose(), line_instance_verbose(), line_report(), memory_funit_verbose(), memory_instance_verbose(), memory_report(), report_parse_args(), toggle_funit_verbose(), toggle_instance_verbose(), and toggle_report().

bool report_instance = FALSE

If set to a boolean value of TRUE, provides a coverage information for individual functional unit instances. If set to a value of FALSE, reports coverage information on a functional unit basis, merging results from all instances of same functional unit.

Referenced by assertion_report(), combination_report(), command_report(), fsm_report(), line_report(), memory_report(), report_generate(), report_parse_args(), report_print_header(), and toggle_report().

sym_value* sv_head = NULL

Pointer to head of sym_value list

sym_value* sv_tail = NULL

Pointer to tail of sym_value list

struct exception_context the_exception_context[1]

Exception context structure used by cexcept.h for throwing and catching exceptions.

Referenced by covered_sim_calltf(), and main().

symtable** timestep_tab

Pointer to the current timestep table array. Please see the file description for how this structure is used.

int timestep_update = 0

Specifies timestep increment to display current time

Referenced by db_do_timestep(), and score_parse_args().

char* top_instance = NULL

Name of top-level instance name

Referenced by command_score(), db_check_dumpfile_scopes(), score_parse_args(), and search_init().

char* top_module = NULL

Name of top-level module to score

Referenced by command_score(), parse_design(), score_parse_args(), and search_init().

char user_msg[USER_MSG_LENGTH]

Holds some output that will be displayed via the print_output command. This is created globally so that memory does not need to be reallocated for each function that wishes to use it.

symtable* vcd_symtab

Pointer to the VCD symbol table. Please see the file description for how this structure is used.

int vcd_symtab_size

Maintains current number of nodes in the VCD symbol table. This value is used to create the appropriately sized timestep_tab array.

void(* vlog_startup_routines[])()

Initial value:

 {
        covered_register,
        0
}