binding.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include "binding.h"
#include "defines.h"
#include "expr.h"
#include "func_unit.h"
#include "link.h"
#include "obfuscate.h"
#include "ovl.h"
#include "util.h"
#include "vector.h"

Functions

void bind_add (int type, const char *name, expression *exp, func_unit *funit)
 Adds vsignal and expression to binding list.
void bind_append_fsm_expr (expression *fsm_exp, const expression *exp, const func_unit *curr_funit)
 Appends an FSM expression to a matching expression binding structure.
void bind_display_list ()
void bind_remove (int id, bool clear_assigned)
 Removes the expression with ID of id from binding list.
char * bind_find_sig_name (const expression *exp)
 Searches current binding list for the signal name associated with the given expression.
static bool bind_param (const char *name, expression *exp, func_unit *funit_exp, int exp_line, bool bind_locally)
bool bind_signal (char *name, expression *exp, func_unit *funit_exp, bool fsm_bind, bool cdd_reading, bool clear_assigned, int exp_line, bool bind_locally)
 Binds a signal to an expression.
static void bind_task_function_ports (expression *expr, func_unit *funit, char *name, int *order, func_unit *funit_exp)
static bool bind_task_function_namedblock (int type, char *name, expression *exp, func_unit *funit_exp, bool cdd_reading, int exp_line, bool bind_locally)
void bind_perform (bool cdd_reading, int pass)
 Performs vsignal/expression bind (performed after parse completed).
void bind_dealloc ()
 Deallocates memory used for binding.

Variables

db ** db_list
unsigned int curr_db
funit_link * funit_head
char user_msg [USER_MSG_LENGTH]
bool debug_mode
static exp_bind * eb_head
static exp_bind * eb_tail

Detailed Description

Author:
Trevor Williams (phase1geo@gmail.com)
Date:
3/4/2002
Binding
When a input, output, inout, reg, wire, etc. is parsed in a module a new signal structure is created and is placed into the current module's signal list. However, the expression list of the newly created signal is initially empty (because we have not encountered any expressions that use the signal yet). Each signal contains a list of expressions that the signal is a part of so that when the signal changes its value during simulation time, it can notify the expressions that it is a part of that they need to be re-evaluated.
Additionally, the expression structure contains a pointer to the signal from which it receives its value. However, not all expressions point to signals. Only the expressions which have an operation type of EXP_OP_SIG, EXP_OP_SBIT_SEL, EXP_OP_MBIT_SEL, and EXP_OP_FUNC_CALL have pointers to signals. These pointers are used for quick retrieval of the signal name when outputting expressions.
Because both signals and expressions point to each other, we say that signals and expressions need to be bound to each other. The process of binding takes place after all design file parsing has been completed, allowing an expression to be bound to a signal elsewhere in the design. Binding is performed twice at this point in the score command (occurs once for the merge and report commands). The first binding pass binds all expressions to local signals/parameters. This local binding is required to allow parameters and constant function calls in parameter assignments to be calculated correctly. As each binding is performed, it is removed from the list of all bindings that need to be performed for the design. After the first binding pass is performed, all parameters are resolved for their values and all generated logic is created, after which all other expressions that still need to bound are handled.
Implicit Signal Creation
In several Verilog simulators, the automatic creation of one-bit wires is allowed. These signals are considered "automatically created" because they are not declared in either the port list or the wire list for its particular module. Therefore, when the binding process occurs and a signal structure has not been created for a used signal (because the signal was not declared in the port list or wire list), the bind_signal function needs to do one of the following:
  1. If the signal name expresses a signal name that will be local to the current module (i.e., there aren't any periods in the signal name), automatically create a one-bit signal for the missing signal and bind this new signal to the expression that uses the implicit signal.
  2. If the signal name expresses a signal name that will be remote to the current module (i.e., if there are periods in the signal name), generate an error message to the user about using a bad hierarchical reference.

Function Documentation

void bind_add ( int  type,
const char *  name,
expression *  exp,
func_unit *  funit 
)

Adds vsignal and expression to binding list.

Adds the specified signal/function/task and expression to the bindings linked list. This bindings list will be handled after all input Verilog has been parsed.

Parameters:
type Type of thing being bound with the specified expression (0=signal, 1=functional unit)
name Signal/Function/Task scope to bind
exp Expression ID to bind
funit Pointer to module containing specified expression

References exp_bind_s::clear_assigned, exp_bind_s::exp, exp_bind_s::fsm, exp_bind_s::funit, expression_s::line, exp_bind_s::line, malloc_safe, exp_bind_s::name, exp_bind_s::next, PROFILE, PROFILE_END, strdup_safe, and exp_bind_s::type.

Referenced by bind_task_function_ports(), db_bind_expr_tree(), db_create_expression(), expression_db_read(), gen_item_resolve(), and static_expr_gen().

00124   { PROFILE(BIND_ADD);
00125   
00126   exp_bind* eb;   /* Temporary pointer to signal/expressing binding */
00127 
00128   assert( exp != NULL );
00129   
00130   /* Create new signal/expression binding */
00131   eb                 = (exp_bind *)malloc_safe( sizeof( exp_bind ) );
00132   eb->type           = type;
00133   eb->name           = strdup_safe( name );
00134   eb->clear_assigned = 0;
00135   eb->line           = exp->line;
00136   eb->funit          = funit;
00137   eb->exp            = exp;
00138   eb->fsm            = NULL;
00139   eb->next           = NULL;
00140   
00141   /* Add new signal/expression binding to linked list */
00142   if( eb_head == NULL ) {
00143     eb_head = eb_tail = eb;
00144   } else {
00145     eb_tail->next = eb;
00146     eb_tail       = eb;
00147   }
00148 
00149   PROFILE_END;
00150   
00151 }

void bind_append_fsm_expr ( expression *  fsm_exp,
const expression *  exp,
const func_unit *  curr_funit 
)

Appends an FSM expression to a matching expression binding structure.

Searches the expression binding list for the entry that matches the given exp and curr_funit parameters. When the entry is found, the FSM expression is added to the exp_bind structure to be sized when the expression is bound.

Parameters:
fsm_exp Expression pertaining to an FSM input state that needs to be sized when its associated expression is bound to its signal
exp Expression to match
curr_funit Functional unit that the FSM expression resides in (this will be the same functional unit as the expression functional unit)

References exp_bind_s::exp, exp_bind_s::fsm, exp_bind_s::funit, exp_bind_s::next, PROFILE, and PROFILE_END.

Referenced by fsm_db_read().

00164   { PROFILE(BIND_APPEND_FSM_EXPR);
00165 
00166   exp_bind* curr;
00167 
00168   curr = eb_head;
00169   while( (curr != NULL) && ((exp != curr->exp) || (curr_funit != curr->funit)) ) {
00170     curr = curr->next;
00171   }
00172 
00173   assert( curr != NULL );
00174 
00175   curr->fsm = fsm_exp;
00176 
00177   PROFILE_END;
00178 
00179 }

void bind_dealloc (  ) 

Deallocates memory used for binding.

Deallocates all memory used for the storage of the binding list.

References free_safe, exp_bind_s::name, exp_bind_s::next, PROFILE, and PROFILE_END.

Referenced by db_close().

00918                     { PROFILE(BIND_DEALLOC);
00919 
00920   exp_bind* tmp;  /* Temporary binding pointer */
00921 
00922   while( eb_head != NULL ) {
00923 
00924     tmp     = eb_head;
00925     eb_head = tmp->next;
00926 
00927     /* Deallocate the name, if specified */
00928     if( tmp->name != NULL ) {
00929       free_safe( tmp->name, (strlen( tmp->name ) + 1) );
00930     }
00931 
00932     /* Deallocate this structure */
00933     free_safe( tmp, sizeof( exp_bind ) );
00934 
00935   }
00936 
00937   /* Reset the head and tail pointers */
00938   eb_head = eb_tail = NULL;
00939 
00940   PROFILE_END;
00941 
00942 }

void bind_display_list (  ) 

Displays to standard output the current state of the binding list (debug purposes only).

References exp_bind_s::clear_assigned, exp_bind_s::exp, expression_string_op(), exp_bind_s::funit, FUNIT_AFUNCTION, FUNIT_ANAMED_BLOCK, FUNIT_ATASK, FUNIT_FUNCTION, FUNIT_NAMED_BLOCK, FUNIT_TASK, expression_s::id, expression_s::line, exp_bind_s::name, func_unit_s::name, exp_bind_s::next, obf_funit, obf_sig, expression_s::op, and exp_bind_s::type.

00184                          {
00185 
00186   exp_bind* curr;  /* Pointer to current expression binding */
00187 
00188   curr = eb_head;
00189  
00190   printf( "Expression binding list:\n" );
00191 
00192   while( curr != NULL ) {
00193 
00194     switch( curr->type ) {
00195       case FUNIT_AFUNCTION :
00196       case FUNIT_FUNCTION :
00197         printf( "  Expr: %d, %s, line %d;  Functional Unit: %s;  Function: %s\n",
00198                 curr->exp->id, expression_string_op( curr->exp->op ), curr->exp->line,
00199                 obf_funit( curr->funit->name ), obf_sig( curr->name ) );
00200         break;
00201       case FUNIT_ATASK :
00202       case FUNIT_TASK :
00203         printf( "  Expr: %d, %s, line %d;  Functional Unit: %s;  Task: %s\n",
00204                 curr->exp->id, expression_string_op( curr->exp->op ), curr->exp->line,
00205                 obf_funit( curr->funit->name ), obf_sig( curr->name ) );
00206         break;
00207       case FUNIT_ANAMED_BLOCK :
00208       case FUNIT_NAMED_BLOCK :
00209         printf( "  Expr: %d, %s, line %d;  Functional Unit: %s;  Named Block: %s\n",
00210                 curr->exp->id, expression_string_op( curr->exp->op ), curr->exp->line,
00211                 obf_funit( curr->funit->name ), obf_sig( curr->name ) );
00212         break;
00213       case 0 :
00214         if( curr->clear_assigned > 0 ) {
00215           printf( "  Signal to be cleared: %s\n", obf_sig( curr->name ) );
00216         } else {
00217           printf( "  Expr: %d, %s, line %d;  Functional Unit: %s;  Signal: %s\n",
00218                   curr->exp->id, expression_string_op( curr->exp->op ), curr->exp->line,
00219                   obf_funit( curr->funit->name ), obf_sig( curr->name ) );
00220         }
00221         break;
00222       default :  break;
00223     }
00224 
00225     curr = curr->next;
00226 
00227   }
00228 
00229 }

char* bind_find_sig_name ( const expression *  exp  ) 

Searches current binding list for the signal name associated with the given expression.

Returns:
Returns the name of the signal to be bound with the given expression (if one exists); otherwise, returns NULL if no match was found.
Parameters:
exp Pointer to expression to search for

References exp_bind_s::exp, free_safe, exp_bind_s::funit, funit_get_curr_module_safe(), malloc_safe, func_unit_s::name, exp_bind_s::name, exp_bind_s::next, PROFILE, PROFILE_END, scope_extract_front(), scope_find_signal(), and strdup_safe.

Referenced by expression_find_rhs_sigs().

00296   { PROFILE(BIND_FIND_SIG_NAME);
00297 
00298   exp_bind*  curr;         /* Pointer to current exp_bind link */
00299   vsignal*   found_sig;    /* Placeholder */
00300   func_unit* found_funit;  /* Specifies the functional unit containing this signal */
00301   char*      name = NULL;  /* Specifies the signal name relative to its parent module */
00302   char*      front;        /* Front part of functional unit hierarchy */
00303   char*      rest;         /* Rest of functional unit hierarchy (minus front) */
00304  
00305   /* Find matching binding element that matches the given expression */
00306   curr = eb_head;
00307   while( (curr != NULL) && (curr->exp != exp) ) {
00308     curr = curr->next;
00309   }
00310 
00311   /*
00312    If we found the matching expression, find the signal and construct its hierarchical pathname
00313    relative to its parent module.
00314   */
00315   if( curr != NULL ) {
00316     if( scope_find_signal( curr->name, curr->funit, &found_sig, &found_funit, -1 ) ) {
00317       if( funit_get_curr_module_safe( curr->funit ) == funit_get_curr_module_safe( found_funit ) ) {
00318         front = strdup_safe( found_funit->name );
00319         rest  = strdup_safe( found_funit->name );
00320         scope_extract_front( found_funit->name, front, rest );
00321         if( rest[0] != '\0' ) {
00322           unsigned int sig_size = strlen( curr->name ) + strlen( rest ) + 2;
00323           unsigned int rv;
00324           name = (char*)malloc_safe( sig_size );
00325           rv = snprintf( name, sig_size, "%s.%s", rest, curr->name );
00326           assert( rv < sig_size );
00327         }
00328         free_safe( front, (strlen( found_funit->name ) + 1) );
00329         free_safe( rest, (strlen( found_funit->name ) + 1) );
00330       }
00331     }
00332     if( name == NULL ) {
00333       name = strdup_safe( curr->name );
00334     }
00335   }
00336 
00337   PROFILE_END;
00338 
00339   return( name );
00340 
00341 }

static bool bind_param ( const char *  name,
expression *  exp,
func_unit *  funit_exp,
int  exp_line,
bool  bind_locally 
) [static]
Returns:
Returns TRUE if the given name referred to a parameter value that was bound; otherwise, returns FALSE.

Attempts to bind the specified expression to a parameter in the design. If binding is successful, returns TRUE; otherwise, returns FALSE.

Parameters:
name Name of parameter to bind to
exp Pointer to expression to bind parameter to
funit_exp Pointer to functional unit containing exp
exp_line Line number of given expression to bind (for error output purposes only)
bind_locally Set to TRUE if we are attempting to bind locally

References mod_parm_s::exp_head, exp_link_add(), EXP_OP_MBIT_NEG, EXP_OP_MBIT_POS, EXP_OP_MBIT_SEL, EXP_OP_PARAM, EXP_OP_PARAM_MBIT, EXP_OP_PARAM_MBIT_NEG, EXP_OP_PARAM_MBIT_POS, EXP_OP_PARAM_SBIT, EXP_OP_SBIT_SEL, EXP_OP_SIG, mod_parm_s::exp_tail, FALSE, expression_s::op, PROFILE, PROFILE_END, scope_find_param(), scope_local(), and TRUE.

Referenced by bind_perform().

00356   { PROFILE(BIND_PARAM);
00357 
00358   bool       retval = FALSE;  /* Return value for this function */
00359   mod_parm*  found_parm;      /* Pointer to found parameter in design for the given name */
00360   func_unit* found_funit;     /* Pointer to found functional unit containing given signal */
00361 
00362   /* Skip parameter binding if the name is not local and we are binding locally */
00363   if( scope_local( name ) || !bind_locally ) {
00364 
00365     /* Search for specified parameter in current functional unit */
00366     if( scope_find_param( name, funit_exp, &found_parm, &found_funit, exp_line ) ) {
00367 
00368       /* Swap operation type */
00369       switch( exp->op ) {
00370         case EXP_OP_SIG      :  exp->op = EXP_OP_PARAM;           break;
00371         case EXP_OP_SBIT_SEL :  exp->op = EXP_OP_PARAM_SBIT;      break;
00372         case EXP_OP_MBIT_SEL :  exp->op = EXP_OP_PARAM_MBIT;      break;
00373         case EXP_OP_MBIT_POS :  exp->op = EXP_OP_PARAM_MBIT_POS;  break;
00374         case EXP_OP_MBIT_NEG :  exp->op = EXP_OP_PARAM_MBIT_NEG;  break;
00375         default :
00376           assert( (exp->op == EXP_OP_SIG)      ||
00377                   (exp->op == EXP_OP_SBIT_SEL) ||
00378                   (exp->op == EXP_OP_MBIT_SEL) ||
00379                   (exp->op == EXP_OP_MBIT_POS) ||
00380                   (exp->op == EXP_OP_MBIT_NEG) );
00381           break;
00382       }
00383 
00384       /* Link the expression to the module parameter */
00385       exp_link_add( exp, &(found_parm->exp_head), &(found_parm->exp_tail) );
00386 
00387       /* Indicate that we have successfully bound */
00388       retval = TRUE;
00389 
00390     }
00391 
00392   }
00393 
00394   PROFILE_END;
00395 
00396   return( retval );
00397 
00398 }

void bind_perform ( bool  cdd_reading,
int  pass 
)

Performs vsignal/expression bind (performed after parse completed).

Exceptions:
anonymous Throw param_resolve bind_signal generate_resolve bind_task_function_namedblock bind_task_function_namedblock

In the process of binding, we go through each element of the binding list, finding the signal to be bound in the specified tree, adding the expression to the signal's expression pointer list, and setting the expression vector pointer to point to the signal vector.

Parameters:
cdd_reading Set to TRUE if we are binding after reading the CDD file; otherwise, set to FALSE
pass Specifies the starting pass to perform (setting this to 1 will bypass resolutions)

References bind_param(), bind_remove(), bind_signal(), bind_task_function_namedblock(), Catch_anonymous, exp_bind_s::clear_assigned, curr_db, DEBUG, debug_mode, exp_bind_s::exp, expression_get_root_statement(), FALSE, func_unit_s::filename, free_safe, exp_bind_s::fsm, exp_bind_s::funit, FUNIT_NAMED_BLOCK, FUNIT_TASK, expression_s::id, inst_link_s::inst, db_s::inst_head, instance_resolve(), expression_s::line, exp_bind_s::line, exp_bind_s::name, expression_s::name, inst_link_s::next, exp_bind_s::next, obf_file, print_output(), PROFILE, PROFILE_END, stmt_blk_add_to_remove_list(), strdup_safe, Throw, TRUE, Try, exp_bind_s::type, user_msg, USER_MSG_LENGTH, expression_s::value, VDATA_UL, vector_create(), VTYPE_EXP, and vector_s::width.

Referenced by command_exclude(), command_merge(), command_report(), covered_sim_calltf(), parse_and_score_dumpfile(), parse_design(), rank_read_cdd(), and report_read_cdd_and_ready().

00785   { PROFILE(BIND_PERFORM);
00786   
00787   exp_bind*  curr_eb;   /* Pointer to current expression bind structure */
00788   int        id;        /* Current expression id -- used for removal */
00789   bool       bound;     /* Specifies if the current expression was successfully bound or not */
00790   statement* tmp_stmt;  /* Pointer to temporary statement */
00791 
00792   Try {
00793 
00794     /* Make three passes through binding list, 0=local signal/param bindings, 1=remote signal/param bindings */
00795     for( ; pass<2; pass++ ) {
00796 
00797       curr_eb = eb_head;
00798       while( curr_eb != NULL ) {
00799 
00800         /* Figure out ID to clear from the binding list after the bind occurs */
00801         if( curr_eb->clear_assigned == 0 ) {
00802           id = curr_eb->exp->id;
00803         } else {
00804           id = curr_eb->clear_assigned;
00805         }
00806 
00807         /* If the expression has already been bound, do not attempt to do it again */
00808         if( (curr_eb->exp != NULL) && (curr_eb->exp->name != NULL) ) {
00809 
00810           bound = TRUE;
00811 
00812         } else {
00813 
00814           /* Handle signal/parameter binding */
00815           if( curr_eb->type == 0 ) {
00816 
00817             /* Attempt to bind the expression to a parameter; otherwise, bind to a signal */
00818             if( !(bound = bind_param( curr_eb->name, curr_eb->exp, curr_eb->funit, curr_eb->line, (pass == 0) )) ) {
00819               bound = bind_signal( curr_eb->name, curr_eb->exp, curr_eb->funit, FALSE, cdd_reading,
00820                                    (curr_eb->clear_assigned > 0), curr_eb->line, (pass == 0) );
00821             }
00822 
00823             /* If an FSM expression is attached, size it now */
00824             if( curr_eb->fsm != NULL ) {
00825               assert( curr_eb->exp != NULL );
00826               curr_eb->fsm->value = vector_create( curr_eb->exp->value->width, VTYPE_EXP, VDATA_UL, TRUE );
00827             }
00828 
00829           /* Otherwise, handle disable binding */
00830           } else if( curr_eb->type == 1 ) {
00831 
00832             /* Attempt to bind a named block -- if unsuccessful, attempt to bind with a task */
00833             if( !(bound = bind_task_function_namedblock( FUNIT_NAMED_BLOCK, curr_eb->name, curr_eb->exp, curr_eb->funit,
00834                                                          cdd_reading, curr_eb->line, (pass == 0) )) ) {
00835               bound = bind_task_function_namedblock( FUNIT_TASK, curr_eb->name, curr_eb->exp, curr_eb->funit,
00836                                                      cdd_reading, curr_eb->line, (pass == 0) );
00837             }
00838 
00839           /* Otherwise, handle function/task binding */
00840           } else {
00841 
00842             /*
00843              Bind the expression to the task/function.  If it is unsuccessful, we need to remove the statement
00844              that this expression is a part of.
00845             */
00846             bound = bind_task_function_namedblock( curr_eb->type, curr_eb->name, curr_eb->exp, curr_eb->funit,
00847                                                    cdd_reading, curr_eb->line, (pass == 0) );
00848 
00849           }
00850 
00851           /* If we have bound successfully, copy the name of this exp_bind to the expression */
00852           if( bound && (curr_eb->exp != NULL) ) {
00853             curr_eb->exp->name = strdup_safe( curr_eb->name );
00854           }
00855 
00856         }
00857 
00858         /*
00859          If the expression was unable to be bound, put its statement block in a list to be removed after
00860          binding has been completed.
00861         */
00862         if( !bound && (curr_eb->clear_assigned == 0) && (pass == 1) ) {
00863           if( (tmp_stmt = expression_get_root_statement( curr_eb->exp )) != NULL ) {
00864 #ifdef DEBUG_MODE
00865             if( debug_mode ) {
00866               unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Removing statement block containing line %d in file \"%s\", because it was unbindable",
00867                                           curr_eb->exp->line, obf_file( curr_eb->funit->filename ) );
00868               assert( rv < USER_MSG_LENGTH );
00869               print_output( user_msg, DEBUG, __FILE__, __LINE__ );
00870             }
00871 #endif        
00872             stmt_blk_add_to_remove_list( tmp_stmt );
00873           }
00874         }
00875 
00876         curr_eb = curr_eb->next;
00877 
00878         /* Remove this from the binding list */
00879         if( bound ) {
00880           bind_remove( id, FALSE );
00881         }
00882 
00883       }
00884 
00885 #ifndef VPI_ONLY
00886       /* If we are in parse mode, resolve all parameters, generate blocks and arrays of instances now */
00887       if( !cdd_reading && (pass == 0) ) {
00888         inst_link* instl = db_list[curr_db]->inst_head;
00889         while( instl != NULL ) {
00890           instance_resolve( instl->inst );
00891           instl = instl->next;
00892         }
00893       }
00894 #endif
00895 
00896     }
00897 
00898   } Catch_anonymous {
00899     exp_bind* tmp_eb;
00900     curr_eb = eb_head;
00901     while( curr_eb != NULL ) {
00902       tmp_eb  = curr_eb;
00903       curr_eb = curr_eb->next;
00904       free_safe( tmp_eb->name, (strlen( tmp_eb->name ) + 1) );
00905       free_safe( tmp_eb, sizeof( exp_bind ) );
00906     }
00907     eb_head = eb_tail = NULL;
00908     Throw 0;
00909   }
00910 
00911   PROFILE_END;
00912 
00913 }

void bind_remove ( int  id,
bool  clear_assigned 
)

Removes the expression with ID of id from binding list.

Removes the binding containing the expression ID of id. This needs to be called before an expression is removed.

Parameters:
id Expression ID of binding to remove
clear_assigned If set to TRUE, clears the assigned bit in the specified expression

References exp_bind_s::clear_assigned, exp_bind_s::exp, free_safe, expression_s::id, exp_bind_s::name, exp_bind_s::next, PROFILE, and PROFILE_END.

Referenced by bind_perform(), and expression_dealloc().

00238   { PROFILE(BIND_REMOVE);
00239 
00240   exp_bind* curr;  /* Pointer to current exp_bind link */
00241   exp_bind* last;  /* Pointer to last exp_bind link examined */
00242 
00243   curr = eb_head;
00244   last = eb_head;
00245 
00246   while( curr != NULL ) {
00247 
00248     if( ((curr->exp != NULL) && (curr->exp->id == id)) || (curr->clear_assigned == id) ) {
00249       
00250       if( clear_assigned ) {
00251 
00252         curr->clear_assigned = id;
00253         curr->exp            = NULL;
00254 
00255       } else {
00256 
00257         /* Remove this binding element */
00258         if( (curr == eb_head) && (curr == eb_tail) ) {
00259           eb_head = eb_tail = NULL;
00260         } else if( curr == eb_head ) {
00261           eb_head = eb_head->next;
00262         } else if( curr == eb_tail ) {
00263           eb_tail       = last;
00264           eb_tail->next = NULL;
00265         } else {
00266           last->next = curr->next;
00267         }
00268 
00269         /* Now free the binding element memory */
00270         free_safe( curr->name, (strlen( curr->name ) + 1) );
00271         free_safe( curr, sizeof( exp_bind ) );
00272 
00273       }
00274 
00275       curr = NULL;
00276       
00277     } else {
00278 
00279       last = curr;
00280       curr = curr->next;
00281 
00282     }
00283 
00284   }
00285 
00286   PROFILE_END;
00287 
00288 }

bool bind_signal ( char *  name,
expression *  exp,
func_unit *  funit_exp,
bool  fsm_bind,
bool  cdd_reading,
bool  clear_assigned,
int  exp_line,
bool  bind_locally 
)

Binds a signal to an expression.

Returns:
Returns TRUE if bind occurred successfully; otherwise, returns FALSE.
Exceptions:
anonymous expression_set_value

Performs a binding of an expression and signal based on the name of the signal. Looks up signal name in the specified functional unit and sets the expression and signal to point to each other. If the signal is unused, the bind does not occur and the function returns a value of FALSE. If the signal does not exist, it is considered to be an implicit signal and a 1-bit signal is created.

Parameters:
name String name of signal to bind to specified expression
exp Pointer to expression to bind
funit_exp Pointer to functional unit containing expression
fsm_bind If set to TRUE, handling binding for FSM binding
cdd_reading If set to TRUE, specifies that we are binding after reading a design from a CDD file (instead of the design files)
clear_assigned If set to TRUE, clears signal assigned bit
exp_line Line of specified expression (when expression is NULL)
bind_locally If TRUE, only search for specified signal within the same functional unit as this expression

References ssuppl_u::assigned, expression_s::col, DEBUG, debug_mode, vsignal_s::dim, ESUPPL_IS_LHS, statement_s::exp, exp_link_s::exp, vsignal_s::exp_head, exp_link_add(), EXP_OP_MBIT_NEG, EXP_OP_MBIT_POS, EXP_OP_MBIT_SEL, EXP_OP_PARAM, EXP_OP_PARAM_MBIT, EXP_OP_PARAM_MBIT_NEG, EXP_OP_PARAM_MBIT_POS, EXP_OP_PARAM_SBIT, EXP_OP_PASSIGN, EXP_OP_SBIT_SEL, EXP_OP_SIG, EXP_OP_TRIGGER, vsignal_s::exp_tail, expression_create_nba(), expression_get_root_statement(), expression_is_nba_lhs(), expression_set_assigned(), expression_set_signed(), expression_set_value(), FALSE, FATAL, func_unit_s::filename, esuppl_u::gen_expr, expression_s::id, expression_s::line, dim_range_s::lsb, malloc_safe, ssuppl_u::mba, dim_range_s::msb, func_unit_s::name, exp_link_s::next, ssuppl_u::not_handled, obf_file, obf_funit, obf_sig, expression_s::op, ovl_is_assertion_module(), esuppl_u::owns_vec, ssuppl_u::part, expression_s::part, esuppl_u::part, vsignal_s::pdim_num, print_output(), PROFILE, PROFILE_END, expression_s::right, scope_find_signal(), scope_local(), expression_s::sig, func_unit_s::sig_head, sig_link_add(), func_unit_s::sig_tail, SSUPPL_TYPE_GENVAR, SSUPPL_TYPE_IMPLICIT, SSUPPL_TYPE_MEM, stmt_blk_add_to_remove_list(), vsignal_s::suppl, expression_s::suppl, Throw, TRUE, ssuppl_u::type, user_msg, USER_MSG_LENGTH, vsignal_s::value, expression_s::value, vector_dealloc(), vsignal_create(), WARNING, and WARNING_WRAP.

Referenced by bind_perform(), and fsm_var_bind_expr().

00420   { PROFILE(BIND_SIGNAL);
00421 
00422   bool         retval = TRUE;  /* Return value for this function */
00423   vsignal*     found_sig;      /* Pointer to found signal in design for the given name */
00424   func_unit*   found_funit;    /* Pointer to found functional unit containing given signal */
00425   statement*   stmt;           /* Pointer to root statement for the given expression */
00426   exp_link*    expl;           /* Pointer to current expression link */
00427   unsigned int rv;             /* Return value from snprintf calls */
00428 
00429   /* Skip signal binding if the name is not local and we are binding locally */
00430   if( scope_local( name ) || !bind_locally || (!clear_assigned && (exp->op == EXP_OP_PASSIGN)) ) {
00431 
00432     /* Search for specified signal in current functional unit */
00433     if( !scope_find_signal( name, funit_exp, &found_sig, &found_funit, exp_line ) ) {
00434 
00435       /* If we are binding an FSM, output an error message */
00436       if( fsm_bind ) {
00437         rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find specified FSM signal \"%s\" in module \"%s\" in file %s",
00438                        obf_sig( name ), obf_funit( funit_exp->name ), obf_file( funit_exp->filename ) );
00439         assert( rv < USER_MSG_LENGTH );
00440         print_output( user_msg, FATAL, __FILE__, __LINE__ );
00441         retval = FALSE;
00442 
00443       /* If the expression is within a generate expression, emit an error message */
00444       } else if( (exp != NULL) && (exp->suppl.part.gen_expr == 1) ) {
00445         rv = snprintf( user_msg, USER_MSG_LENGTH, "Generate expression could not find variable (%s), file %s, line %d",
00446                        obf_sig( name ), obf_file( funit_exp->filename ), exp_line );
00447         assert( rv < USER_MSG_LENGTH );
00448         print_output( user_msg, FATAL, __FILE__, __LINE__ );
00449         Throw 0;
00450 
00451       /* Otherwise, implicitly create the signal and bind to it if the signal exists on the LHS of the equation */
00452       } else if( (exp != NULL) && (ESUPPL_IS_LHS( exp->suppl ) == 1) ) {
00453         rv = snprintf( user_msg, USER_MSG_LENGTH, "Implicit declaration of signal \"%s\", creating 1-bit version of signal", obf_sig( name ) );
00454         assert( rv < USER_MSG_LENGTH );
00455         print_output( user_msg, WARNING, __FILE__, __LINE__ );
00456         rv = snprintf( user_msg, USER_MSG_LENGTH, "module \"%s\", file \"%s\", line %d",
00457                        obf_funit( funit_exp->name ), obf_file( funit_exp->filename ), exp_line );
00458         assert( rv < USER_MSG_LENGTH );
00459         print_output( user_msg, WARNING_WRAP, __FILE__, __LINE__ );
00460         found_sig = vsignal_create( name, SSUPPL_TYPE_IMPLICIT, 1, exp->line, exp->col.part.first );
00461         found_sig->pdim_num   = 1;
00462         found_sig->dim        = (dim_range*)malloc_safe( sizeof( dim_range ) * 1 );
00463         found_sig->dim[0].msb = 0;
00464         found_sig->dim[0].lsb = 0;
00465         sig_link_add( found_sig, &(funit_exp->sig_head), &(funit_exp->sig_tail) );
00466 
00467       /* Otherwise, don't attempt to bind the signal */
00468       } else {
00469         retval = FALSE;
00470       }
00471 
00472     } else {
00473 
00474       /* If the found signal is not handled, do not attempt to bind to it */
00475       if( found_sig->suppl.part.not_handled == 1 ) {
00476         retval = FALSE;
00477       }
00478 
00479       /*
00480        If the expression is a generate expression on the LHS and the found signal is not a generate variable, emit an error message
00481        and exit immediately.
00482       */
00483       if( (exp != NULL) && (exp->suppl.part.gen_expr == 1) && (ESUPPL_IS_LHS( exp->suppl ) == 1) && (found_sig->suppl.part.type != SSUPPL_TYPE_GENVAR) ) {
00484         rv = snprintf( user_msg, USER_MSG_LENGTH, "Attempting to bind an generate expression to a signal that is not a genvar, file %s, line %d",
00485                        obf_file( funit_exp->filename ), exp_line );
00486         assert( rv < USER_MSG_LENGTH );
00487         print_output( user_msg, FATAL, __FILE__, __LINE__ );
00488         Throw 0;
00489       }
00490 
00491     }
00492 
00493     if( retval ) {
00494 
00495       /* Bind signal and expression if we are not clearing or this is an MBA */
00496       if( !clear_assigned ) {
00497 
00498         assert( exp != NULL );
00499 
00500         /* Add expression to signal expression list */
00501         exp_link_add( exp, &(found_sig->exp_head), &(found_sig->exp_tail) );
00502 
00503         /* Set expression to point at signal */
00504         exp->sig = found_sig;
00505 
00506         /* If this is a port assignment, we need to link the expression and signal together immediately */
00507         if( exp->op == EXP_OP_PASSIGN ) {
00508           vector_dealloc( exp->value );
00509           exp->suppl.part.owns_vec = 0;
00510           exp->value = found_sig->value;
00511         }
00512 
00513         if( ((exp->op == EXP_OP_SIG)            ||
00514              (exp->op == EXP_OP_SBIT_SEL)       ||
00515              (exp->op == EXP_OP_MBIT_SEL)       ||
00516              (exp->op == EXP_OP_MBIT_POS)       ||
00517              (exp->op == EXP_OP_MBIT_NEG)       ||
00518              (exp->op == EXP_OP_PARAM)          ||
00519              (exp->op == EXP_OP_PARAM_SBIT)     ||
00520              (exp->op == EXP_OP_PARAM_MBIT)     ||
00521              (exp->op == EXP_OP_PARAM_MBIT_POS) ||
00522              (exp->op == EXP_OP_PARAM_MBIT_NEG) ||
00523              (exp->op == EXP_OP_TRIGGER)) &&
00524             (cdd_reading || (found_sig->suppl.part.type == SSUPPL_TYPE_GENVAR)) ) {
00525           expression_set_value( exp, found_sig, funit_exp );
00526         }
00527 
00528         /*
00529          Create a non-blocking assignment handler for the given expression if the attached signal is a memory
00530          and the expression is assignable on the LHS of a non-blocking assignment operator.  Only perform this
00531          if we are reading from the CDD file and binding.
00532         */
00533         if( cdd_reading && (found_sig->suppl.part.type == SSUPPL_TYPE_MEM) ) {
00534           expression* nba_exp;
00535           if( (nba_exp = expression_is_nba_lhs( exp )) != NULL ) {
00536             expression_create_nba( exp, found_sig, nba_exp->right->value );
00537           }
00538         }
00539 
00540       }
00541 
00542       if( !cdd_reading ) {
00543 
00544         /* Check to see if this signal should be assigned by Covered or the dumpfile */
00545         if( clear_assigned ) {
00546           found_sig->suppl.part.assigned = 0;
00547         }
00548 
00549         if( !clear_assigned &&
00550             ((exp->op == EXP_OP_SIG)      ||
00551              (exp->op == EXP_OP_SBIT_SEL) ||
00552              (exp->op == EXP_OP_MBIT_SEL) ||
00553              (exp->op == EXP_OP_MBIT_POS) ||
00554              (exp->op == EXP_OP_MBIT_NEG)) &&
00555             !ovl_is_assertion_module( funit_exp ) ) {
00556           expression_set_assigned( exp );
00557         }
00558 
00559         /* Set signed bits */
00560         if( !clear_assigned ) {
00561           expression_set_signed( exp );
00562         }
00563 
00564         /*
00565          If the signal is found for the given expression but the signal is marked as "must be assigned" but is also marked as
00566          "won't be assigned", we need to remove all statement blocks that contain this signal from coverage consideration.
00567         */
00568         if( (found_sig->suppl.part.assigned == 0) && (found_sig->suppl.part.mba == 1) ) {
00569           expl = found_sig->exp_head;
00570           while( expl != NULL ) {
00571             if( (stmt = expression_get_root_statement( expl->exp )) != NULL ) {
00572 #ifdef DEBUG_MODE
00573               if( debug_mode ) {
00574                 unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Removing statement block %d, line %d because it needed to be assigned but would not be",
00575                                             stmt->exp->id, stmt->exp->line );
00576                 assert( rv < USER_MSG_LENGTH );
00577                 print_output( user_msg, DEBUG, __FILE__, __LINE__ );
00578               }
00579 #endif
00580               stmt_blk_add_to_remove_list( stmt );
00581             }
00582             expl = expl->next;
00583           }
00584         }
00585 
00586       }
00587 
00588     }
00589 
00590   } else {
00591 
00592     retval = FALSE;
00593 
00594   }
00595 
00596   PROFILE_END;
00597 
00598   return( retval );
00599 
00600 }

static bool bind_task_function_namedblock ( int  type,
char *  name,
expression *  exp,
func_unit *  funit_exp,
bool  cdd_reading,
int  exp_line,
bool  bind_locally 
) [static]
Returns:
Returns TRUE if there were no errors in binding the specified expression to the needed functional unit; otherwise, returns FALSE to indicate that we had an error.
Exceptions:
anonymous Throw

Binds an expression to a function/task/named block.

Parameters:
type Type of functional unit to bind
name Name of functional unit to bind
exp Pointer to expression containing FUNC_CALL/TASK_CALL operation type to bind
funit_exp Pointer to functional unit containing exp
cdd_reading Set to TRUE when we are reading from the CDD file (FALSE when parsing)
exp_line Line number of expression that is being bound (used when exp is NULL)
bind_locally If set to TRUE, only attempt to bind a task/function local to the expression functional unit

References bind_task_function_ports(), vsuppl_u::data_type, expression_s::elem, ETYPE_FUNIT, vsignal_s::exp_head, exp_link_add(), EXP_OP_FORK, EXP_OP_NB_CALL, vsignal_s::exp_tail, FALSE, FATAL, func_unit_s::filename, expression_s::funit, FUNIT_ANAMED_BLOCK, FUNIT_FUNCTION, funit_get_port_count(), FUNIT_NAMED_BLOCK, FUNIT_NO_SCORE, FUNIT_TASK, get_funit_type(), expression_s::left, expression_s::line, func_unit_s::name, obf_file, expression_s::op, vsuppl_u::part, esuppl_u::part, print_output(), PROFILE, PROFILE_END, scope_extract_back(), scope_find_task_function_namedblock(), scope_local(), expression_s::sig, sig_link_s::sig, func_unit_s::sig_head, sig_link_find(), vector_s::suppl, expression_s::suppl, Throw, func_unit_s::type, esuppl_u::type, user_msg, USER_MSG_LENGTH, vsignal_s::value, and expression_s::value.

Referenced by bind_perform().

00701   { PROFILE(BIND_TASK_FUNCTION_NAMEDBLOCK);
00702 
00703   bool       retval = FALSE;  /* Return value for this function */
00704   sig_link*  sigl;            /* Temporary signal link holder */
00705   func_unit* found_funit;     /* Pointer to found task/function functional unit */
00706   char       rest[4096];      /* Temporary string */
00707   char       back[4096];      /* Temporary string */
00708   int        port_order;      /* Port order value */
00709   int        port_cnt;        /* Number of ports in the found function/task's port list */
00710 
00711   assert( (type == FUNIT_FUNCTION) || (type == FUNIT_TASK) || (type == FUNIT_NAMED_BLOCK) || (type == FUNIT_ANAMED_BLOCK) );
00712 
00713   /* Don't continue if the name is not local and we are told to bind locally */
00714   if( scope_local( name ) || !bind_locally ) {
00715 
00716     if( scope_find_task_function_namedblock( name, type, funit_exp, &found_funit, exp_line, !bind_locally, 
00717                                              ((exp->op != EXP_OP_NB_CALL) && (exp->op != EXP_OP_FORK)) ) ) {
00718 
00719       exp->elem.funit      = found_funit;
00720       exp->suppl.part.type = ETYPE_FUNIT;
00721       retval = (found_funit->type != FUNIT_NO_SCORE);
00722 
00723       if( retval ) {
00724 
00725         /* If this is a function, bind the return value signal */
00726         if( type == FUNIT_FUNCTION ) {
00727 
00728           scope_extract_back( found_funit->name, back, rest );
00729           sigl = sig_link_find( back, found_funit->sig_head );
00730 
00731           assert( sigl != NULL );
00732 
00733           /* Add expression to signal expression list */
00734           exp_link_add( exp, &(sigl->sig->exp_head), &(sigl->sig->exp_tail) );
00735 
00736           /* Set expression to point at signal */
00737           exp->sig = sigl->sig;
00738 
00739           /* Make sure that our vector type matches that of the found signal */
00740           exp->value->suppl.part.data_type = sigl->sig->value->suppl.part.data_type;
00741 
00742         }
00743 
00744         /* If this is a function or task, bind the ports as well */
00745         if( ((type == FUNIT_FUNCTION) || (type == FUNIT_TASK)) && !cdd_reading ) {
00746 
00747           /* First, bind the ports */
00748           port_order = 0;
00749           bind_task_function_ports( exp->left, found_funit, name, &port_order, funit_exp );
00750 
00751           /* Check to see if the call port count matches the actual port count */
00752           if( (port_cnt = funit_get_port_count( found_funit )) != port_order ) {
00753             unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Number of arguments in %s call (%d) does not match its %s port list (%d), file %s, line %d",
00754                                         get_funit_type( type ), port_order, get_funit_type( type ), port_cnt, obf_file( funit_exp->filename ), exp->line );
00755             assert( rv < USER_MSG_LENGTH );
00756             print_output( user_msg, FATAL, __FILE__, __LINE__ );
00757             Throw 0;
00758           }
00759 
00760         }
00761 
00762       }
00763 
00764     }
00765 
00766   }
00767 
00768   PROFILE_END;
00769 
00770   return( retval );
00771 
00772 }

static void bind_task_function_ports ( expression *  expr,
func_unit *  funit,
char *  name,
int *  order,
func_unit *  funit_exp 
) [static]

Binds a given task/function call port parameter to the matching signal in the specified task/function.

Parameters:
expr Pointer to port expression to potentially bind to the specified port
funit Pointer to task/function to bind port list to
name Hierachical name of function to bind port list to
order Tracks the port order for the current task/function call parameter
funit_exp Pointer to functional unit containing the given expression

References ssuppl_u::assigned, bind_add(), EXP_OP_PASSIGN, EXP_OP_PLIST, FALSE, expression_s::left, vsignal_s::name, sig_link_s::next, expression_s::op, ssuppl_u::part, PROFILE, PROFILE_END, expression_s::right, sig_link_s::sig, func_unit_s::sig_head, SSUPPL_TYPE_INOUT_NET, SSUPPL_TYPE_INOUT_REG, SSUPPL_TYPE_INPUT_NET, SSUPPL_TYPE_INPUT_REG, SSUPPL_TYPE_OUTPUT_NET, SSUPPL_TYPE_OUTPUT_REG, vsignal_s::suppl, TRUE, and ssuppl_u::type.

Referenced by bind_task_function_namedblock().

00612   { PROFILE(BIND_TASK_FUNCTION_PORTS);
00613 
00614   sig_link* sigl;            /* Pointer to current signal link to examine */
00615   int       i;               /* Loop iterator */
00616   bool      found;           /* Specifies if we have found a matching port */
00617   char      sig_name[4096];  /* Hierarchical path to matched port signal */
00618 
00619   assert( funit != NULL );
00620 
00621   if( expr != NULL ) {
00622 
00623     /* If the expression is a list, traverse left and right expression trees */
00624     if( expr->op == EXP_OP_PLIST ) {
00625 
00626       bind_task_function_ports( expr->left,  funit, name, order, funit_exp );
00627       bind_task_function_ports( expr->right, funit, name, order, funit_exp );
00628 
00629     /* Otherwise, we have found an expression to bind to a port */
00630     } else {
00631 
00632       assert( expr->op == EXP_OP_PASSIGN );
00633 
00634       /* Find the port that matches our order */
00635       found = FALSE;
00636       i     = 0;
00637       sigl  = funit->sig_head;
00638       while( (sigl != NULL) && !found ) {
00639         if( (sigl->sig->suppl.part.type == SSUPPL_TYPE_INPUT_NET)  ||
00640             (sigl->sig->suppl.part.type == SSUPPL_TYPE_INPUT_REG)  ||
00641             (sigl->sig->suppl.part.type == SSUPPL_TYPE_OUTPUT_NET) ||
00642             (sigl->sig->suppl.part.type == SSUPPL_TYPE_OUTPUT_REG) ||
00643             (sigl->sig->suppl.part.type == SSUPPL_TYPE_INOUT_NET)  ||
00644             (sigl->sig->suppl.part.type == SSUPPL_TYPE_INOUT_REG) ) {
00645           if( i == *order ) {
00646             found = TRUE;
00647           } else {
00648             i++;
00649             sigl = sigl->next;
00650           }
00651         } else {
00652           sigl = sigl->next;
00653         }
00654       }
00655 
00656       /*
00657        If we found our signal to bind to, do it now; otherwise, just skip ahead (the error will be handled by
00658        the calling function.
00659       */
00660       if( sigl != NULL ) {
00661 
00662         /* Create signal name to bind */
00663         unsigned int rv = snprintf( sig_name, 4096, "%s.%s", name, sigl->sig->name );
00664         assert( rv < 4096 );
00665 
00666         /* Add the signal to the binding list */
00667         bind_add( 0, sig_name, expr, funit_exp );
00668 
00669         /* Specify that this vector will be assigned by Covered and not the dumpfile */
00670         sigl->sig->suppl.part.assigned = 1;
00671 
00672         /* Increment the port order number */
00673         (*order)++;
00674 
00675       }
00676 
00677     }
00678 
00679   }
00680 
00681   PROFILE_END;
00682 
00683 }

Variable Documentation

unsigned int curr_db

Index of current database in db_list array that is being handled.

db** db_list

Array of database pointers storing all currently loaded databases.

bool debug_mode

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

Referenced by bind_perform(), bind_signal(), covered_create_value_change_cb(), covered_parse_instance(), covered_parse_signals(), covered_parse_task_func(), covered_sim_calltf(), covered_value_change_bin(), covered_value_change_real(), db_add_declared_param(), db_add_defparam(), db_add_enum(), db_add_expression(), db_add_file_version(), db_add_function_task_namedblock(), db_add_instance(), db_add_module(), db_add_override_param(), db_add_signal(), db_add_statement(), db_add_typedef(), db_add_vector_param(), db_assign_symbol(), db_bind_expr_tree(), db_connect_statement_false(), db_connect_statement_true(), db_create_attr_param(), db_create_expr_from_static(), db_create_expression(), db_create_statement(), db_do_timestep(), db_end_enum_list(), db_end_function_task_namedblock(), db_end_module(), db_find_gen_item(), db_find_signal(), db_find_typedef(), db_gen_item_connect(), db_gen_item_connect_false(), db_gen_item_connect_true(), db_get_curr_gen_block(), db_parallelize_statement(), db_parse_attribute(), db_read(), db_remove_statement(), db_remove_statement_from_current_funit(), db_set_symbol_char(), db_set_symbol_string(), db_set_vcd_scope(), db_statement_connect(), db_vcd_upscope(), expression_assign(), expression_dealloc(), expression_op_func__idec(), expression_op_func__iinc(), expression_op_func__pdec(), expression_op_func__pinc(), expression_operate(), gen_item_create_bind(), gen_item_create_expr(), gen_item_create_inst(), gen_item_create_sig(), gen_item_create_stmt(), gen_item_create_tfn(), gen_item_resolve(), instance_resolve_helper(), parse_and_score_dumpfile(), parse_design(), print_output(), race_check_modules(), rank_perform(), rank_selected_cdd_cov(), set_debug(), sim_add_thread(), sim_expr_changed(), sim_expression(), sim_initialize(), sim_kill_thread(), sim_perform_nba(), sim_simulate(), sim_thread(), sim_thread_insert_into_delay_queue(), sim_thread_pop_head(), sim_thread_push(), and vsignal_vcd_assign().

exp_bind* eb_head [static]

Pointer to the head of the signal/functional unit/expression binding list.

exp_bind* eb_tail [static]

Pointer to the tail of the signal/functional unit/expression binding list.

funit_link* funit_head

Referenced by assertion_report(), combination_report(), db_add_instance(), db_add_module(), db_close(), db_read(), fsm_report(), fsm_var_add(), fsm_var_bind_add(), fsm_var_bind_expr(), fsm_var_bind_stmt(), line_report(), memory_report(), race_report(), report_generate(), report_read_cdd_and_ready(), search_init(), and toggle_report().

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.

Referenced by bind_perform(), bind_signal(), bind_task_function_namedblock(), check_option_value(), codegen_gen_expr(), combination_underline_tree(), command_exclude(), command_merge(), command_rank(), command_report(), command_score(), covered_create_value_change_cb(), covered_parse_instance(), covered_parse_signals(), covered_parse_task_func(), covered_value_change_bin(), covered_value_change_real(), db_add_declared_param(), db_add_defparam(), db_add_enum(), db_add_expression(), db_add_file_version(), db_add_function_task_namedblock(), db_add_instance(), db_add_module(), db_add_override_param(), db_add_signal(), db_add_statement(), db_add_typedef(), db_add_vector_param(), db_assign_symbol(), db_bind_expr_tree(), db_check_dumpfile_scopes(), db_connect_statement_false(), db_connect_statement_true(), db_create_attr_param(), db_create_expr_from_static(), db_create_expression(), db_create_statement(), db_do_timestep(), db_end_function_task_namedblock(), db_end_module(), db_find_gen_item(), db_find_signal(), db_find_typedef(), db_gen_item_connect(), db_gen_item_connect_false(), db_gen_item_connect_true(), db_parallelize_statement(), db_read(), db_remove_statement(), db_remove_statement_from_current_funit(), db_set_symbol_char(), db_set_symbol_string(), db_set_vcd_scope(), db_statement_connect(), db_vcd_upscope(), db_write(), defparam_add(), directory_load(), enumerate_resolve(), exclude_apply_exclusions(), exclude_assert_from_id(), exclude_expr_from_id(), exclude_fsm_from_id(), exclude_get_message(), exclude_line_from_id(), exclude_memory_from_id(), exclude_parse_args(), exclude_toggle_from_id(), expression_assign(), expression_create_value(), expression_db_read(), expression_dealloc(), expression_op_func__bitstoreal(), expression_op_func__bitstoshortreal(), expression_op_func__itor(), expression_op_func__realtobits(), expression_op_func__rtoi(), expression_op_func__shortrealtobits(), expression_op_func__test_plusargs(), expression_op_func__urandom_range(), expression_op_func__value_plusargs(), expression_operate(), expression_resize(), expression_string(), fsm_arg_parse_attr(), fsm_arg_parse_trans(), fsm_db_read(), fsm_var_bind_expr(), funit_db_read(), funit_db_write(), gen_item_create_bind(), gen_item_create_expr(), gen_item_create_inst(), gen_item_create_sig(), gen_item_create_stmt(), gen_item_create_tfn(), gen_item_resolve(), instance_resolve_helper(), lxt2_rd_iter_radix(), lxt2_rd_iter_radix0(), lxt2_rd_process_block(), main(), merge_parse_args(), merged_cdd_db_read(), param_find_and_set_expr_value(), parse_and_score_dumpfile(), parse_design(), parse_readline(), profiler_report(), race_check_race_count(), race_handle_race_condition(), rank_check_index(), rank_output(), rank_parse_args(), rank_perform(), rank_read_cdd(), read_command_file(), report_parse_args(), report_parse_metrics(), scope_find_param(), scope_find_signal(), scope_find_task_function_namedblock(), score_generate_pli_tab_file(), score_generate_top_dumpvars_module(), score_generate_top_vpi_module(), score_parse_args(), search_add_directory_path(), search_add_extensions(), search_add_file(), search_add_include_path(), search_add_no_score_funit(), sim_expr_changed(), sim_expression(), sim_thread(), stmt_blk_specify_removal_reason(), substitute_env_vars(), vcd_parse_def(), vcd_parse_sim(), VLerror(), VLwarn(), and vsignal_vcd_assign().

Generated on Sun Nov 21 00:55:36 2010 for Covered by  doxygen 1.6.3