/Users/trevorw/projects/release/covered-0.7.4/src/expr.h File Reference

---

Detailed Description

Contains functions for handling expressions.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

12/1/2001

#include <stdio.h>
#include "defines.h"

Go to the source code of this file.

Functions
void	expression_create_nba (expression *expr, vsignal *lhs_sig, vector *rhs_vec)
	Creates, initializes and adds a non-blocking assignment structure to the given expression's element pointer.
expression *	expression_is_nba_lhs (expression *exp)
	Returns a pointer to the non-blocking assignment expression if the given expression is an assignable expression on the LHS of a non-blocking assignment.
expression *	expression_create (expression *right, expression *left, exp_op_type op, bool lhs, int id, int line, unsigned int first, unsigned int last, bool data)
	Creates new expression.
void	expression_set_value (expression *exp, vsignal *sig, func_unit *funit)
	Sets the specified expression value to the specified vector value.
void	expression_set_signed (expression *exp)
	Sets the signed bit for all appropriate parent expressions.
void	expression_resize (expression *expr, func_unit *funit, bool recursive, bool alloc)
	Recursively resizes specified expression tree leaf node.
int	expression_get_id (expression *expr, bool parse_mode)
	Returns expression ID of this expression.
expression *	expression_get_first_line_expr (expression *expr)
	Returns first line in this expression tree.
expression *	expression_get_last_line_expr (expression *expr)
	Returns last line in this expression tree.
unsigned int	expression_get_curr_dimension (expression *expr)
	Returns the current dimension of the given expression.
void	expression_find_rhs_sigs (expression *expr, str_link **head, str_link **tail)
	Finds all RHS signals in given expression tree.
expression *	expression_find_uline_id (expression *expr, int ulid)
	Finds the expression in this expression tree with the specified underline id.
bool	expression_find_expr (expression *root, expression *expr)
	Returns TRUE if the specified expression exists within the given root expression tree.
bool	expression_contains_expr_calling_stmt (expression *expr, statement *stmt)
	Searches for an expression that calls the given statement.
statement *	expression_get_root_statement (expression *exp)
	Finds the root statement for the given expression.
void	expression_assign_expr_ids (expression *root, func_unit *funit)
	Assigns each expression in the given tree a unique identifier.
void	expression_db_write (expression *expr, FILE *file, bool parse_mode, bool ids_issued)
	Writes this expression to the specified database file.
void	expression_db_write_tree (expression *root, FILE *file)
	Writes the entire expression tree to the specified data file.
void	expression_db_read (char **line, func_unit *curr_mod, bool eval)
	Reads current line of specified file and parses for expression information.
void	expression_db_merge (expression *base, char **line, bool same)
	Reads and merges two expressions and stores result in base expression.
void	expression_merge (expression *base, expression *other)
	Merges two expressions into the base expression.
const char *	expression_string_op (int op)
	Returns user-readable name of specified expression operation.
char *	expression_string (expression *exp)
	Returns user-readable version of the supplied expression.
void	expression_display (expression *expr)
	Displays the specified expression information.
bool	expression_operate (expression *expr, thread *thr, const sim_time *time)
	Performs operation specified by parameter expression.
void	expression_operate_recursively (expression *expr, func_unit *funit, bool sizing)
	Performs recursive expression operation (parse mode only).
bool	expression_is_static_only (expression *expr)
	Returns TRUE if specified expression is found to contain all static leaf expressions.
bool	expression_is_bit_select (expression *expr)
	Returns TRUE if specified expression is a part of an bit select expression tree.
bool	expression_is_in_rassign (expression *expr)
	Returns TRUE if specified expression is in an RASSIGN expression tree.
bool	expression_is_last_select (expression *expr)
	Returns TRUE if specified expression is the last select of a signal.
void	expression_set_assigned (expression *expr)
	Sets the expression signal supplemental field assigned bit if the given expression is an RHS of an assignment.
void	expression_set_changed (expression *expr)
	Sets the left/right changed expression bits for each expression in the tree.
void	expression_dealloc (expression *expr, bool exp_only)
	Deallocates memory used for expression.

---

Function Documentation

void expression_assign_expr_ids (  expression *  root, func_unit *  funit )

Assigns each expression in the given tree a unique identifier. Exceptions: anonymous  expression_resize expression_assign_expr_ids expression_assign_expr_ids Recursively iterates down the specified expression tree assigning unique IDs to each expression. Parameters: root  Pointer to root of the expression tree to assign unique IDs for funit  Pointer to functional unit containing this expression tree { PROFILE(EXPRESSION_ASSIGN_EXPR_IDS); if( root != NULL ) { /* Traverse children first */ expression_assign_expr_ids( root->left, funit ); expression_assign_expr_ids( root->right, funit ); /* Assign our expression a unique ID value */ root->ulid = curr_expr_id; curr_expr_id++; /* Resize ourselves */ expression_resize( root, funit, FALSE, FALSE ); } PROFILE_END; }

bool expression_contains_expr_calling_stmt (  expression *  expr, statement *  stmt )

Searches for an expression that calls the given statement. Returns: Returns TRUE if the given expression tree contains an expression that calls the given statement. Parameters: expr  Pointer to root of expression tree to search stmt  Pointer to statement to search for { PROFILE(EXPRESSION_CONTAINS_EXPR_CALLING_STMT); bool retval = (expr != NULL) && (((ESUPPL_TYPE( expr->suppl ) == ETYPE_FUNIT) && (expr->elem.funit->first_stmt == stmt)) || expression_contains_expr_calling_stmt( expr->left, stmt ) || expression_contains_expr_calling_stmt( expr->right, stmt )); PROFILE_END; return( retval ); }

expression* expression_create (  expression *  right, expression *  left, exp_op_type  op, bool  lhs, int  id, int  line, unsigned int  first, unsigned int  last, bool  data )

Creates new expression. Returns: Returns pointer to newly created expression. Exceptions: anonymous  Throw expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value Creates a new expression from heap memory and initializes its values for usage. Right and left expressions need to be created before this function is called. Parameters: right  Pointer to expression on right left  Pointer to expression on left op  Operation to perform for this expression lhs  Specifies this expression is a left-hand-side assignment expression id  ID for this expression as determined by the parent line  Line number this expression is on first  First column index of expression last  Last column index of expression data  Specifies if we should create a uint8 array for the vector value { PROFILE(EXPRESSION_CREATE); expression* new_expr; /* Pointer to newly created expression */ int rwidth = 0; /* Bit width of expression on right */ int lwidth = 0; /* Bit width of expression on left */ new_expr = (expression*)malloc_safe( sizeof( expression ) ); new_expr->suppl.all = 0; new_expr->suppl.part.lhs = (uint8)lhs & 0x1; new_expr->suppl.part.gen_expr = (generate_expr_mode > 0) ? 1 : 0; new_expr->suppl.part.root = 1; new_expr->op = op; new_expr->id = id; new_expr->ulid = -1; new_expr->line = line; new_expr->col = ((first & 0xffff) << 16) | (last & 0xffff); new_expr->exec_num = 0; new_expr->sig = NULL; new_expr->parent = (expr_stmt*)malloc_safe( sizeof( expr_stmt ) ); new_expr->parent->expr = NULL; new_expr->right = right; new_expr->left = left; new_expr->value = (vector*)malloc_safe( sizeof( vector ) ); new_expr->suppl.part.owns_vec = 1; new_expr->value->value.ul = NULL; new_expr->value->suppl.all = 0; new_expr->table = NULL; new_expr->elem.funit = NULL; new_expr->name = NULL; if( EXPR_OP_HAS_DIM( op ) ) { new_expr->elem.dim = (exp_dim*)malloc_safe( sizeof( exp_dim ) ); new_expr->elem.dim->curr_lsb = -1; } if( right != NULL ) { /* Get information from right */ assert( right->value != NULL ); rwidth = right->value->width; /* Set right expression parent to this expression */ assert( right->parent->expr == NULL ); right->parent->expr = new_expr; /* Reset root bit of right expression */ right->suppl.part.root = 0; } if( left != NULL ) { /* Get information from left */ assert( left->value != NULL ); lwidth = left->value->width; /* Set left expression parent to this expression (if this is not a case expression) */ if( (op != EXP_OP_CASE) && (op != EXP_OP_CASEX) && (op != EXP_OP_CASEZ) ) { assert( left->parent->expr == NULL ); left->parent->expr = new_expr; left->suppl.part.root = 0; } } Try { /* Create value vector */ if( ((op == EXP_OP_MULTIPLY) || (op == EXP_OP_LIST)) && (rwidth > 0) && (lwidth > 0) ) { /* For multiplication, we need a width the sum of the left and right expressions */ expression_create_value( new_expr, (lwidth + rwidth), data ); } else if( (op == EXP_OP_CONCAT) && (rwidth > 0) ) { expression_create_value( new_expr, rwidth, data ); } else if( (op == EXP_OP_EXPAND) && (rwidth > 0) && (lwidth > 0) && (left->value->value.ul != NULL) ) { /* If the left-hand expression is a known value, go ahead and create the value here; otherwise, hold off because our vector value will be coming. */ if( !vector_is_unknown( left->value ) ) { expression_create_value( new_expr, (vector_to_int( left->value ) * rwidth), data ); } else { expression_create_value( new_expr, 1, data ); } /* $time, $realtobits, $bitstoreal, $itor and $rtoi expressions are always 64-bits wide */ } else if( (op == EXP_OP_STIME) || (op == EXP_OP_SR2B) || (op == EXP_OP_SB2R) || (op == EXP_OP_SI2R) || (op == EXP_OP_SR2I) ) { expression_create_value( new_expr, 64, data ); /* $random, $urandom, $urandom_range, $shortrealtobits and $bitstoshortreal expressions are always 32-bits wide */ } else if( (op == EXP_OP_SRANDOM) || (op == EXP_OP_SURANDOM) || (op == EXP_OP_SURAND_RANGE) || (op == EXP_OP_SSR2B) || (op == EXP_OP_SB2SR) ) { expression_create_value( new_expr, 32, data ); } else if( (op == EXP_OP_LT) || (op == EXP_OP_GT) || (op == EXP_OP_EQ) || (op == EXP_OP_CEQ) || (op == EXP_OP_LE) || (op == EXP_OP_GE) || (op == EXP_OP_NE) || (op == EXP_OP_CNE) || (op == EXP_OP_LOR) || (op == EXP_OP_LAND) || (op == EXP_OP_UAND) || (op == EXP_OP_UNOT) || (op == EXP_OP_UOR) || (op == EXP_OP_UXOR) || (op == EXP_OP_UNAND) || (op == EXP_OP_UNOR) || (op == EXP_OP_UNXOR) || (op == EXP_OP_EOR) || (op == EXP_OP_NEDGE) || (op == EXP_OP_PEDGE) || (op == EXP_OP_AEDGE) || (op == EXP_OP_CASE) || (op == EXP_OP_CASEX) || (op == EXP_OP_CASEZ) || (op == EXP_OP_DEFAULT) || (op == EXP_OP_REPEAT) || (op == EXP_OP_RPT_DLY) || (op == EXP_OP_WAIT) || (op == EXP_OP_SFINISH) || (op == EXP_OP_SSTOP) || (op == EXP_OP_SSRANDOM) || (op == EXP_OP_STESTARGS) || (op == EXP_OP_SVALARGS) ) { /* If this expression will evaluate to a single bit, create vector now */ expression_create_value( new_expr, 1, data ); } else { /* If both right and left values have their width values set. */ if( (rwidth > 0) && (lwidth > 0) && (op != EXP_OP_MBIT_SEL) && (op != EXP_OP_MBIT_POS) && (op != EXP_OP_MBIT_NEG) && (op != EXP_OP_PARAM_MBIT) && (op != EXP_OP_PARAM_MBIT_POS) && (op != EXP_OP_PARAM_MBIT_NEG) ) { if( rwidth >= lwidth ) { /* Check to make sure that nothing has gone drastically wrong */ expression_create_value( new_expr, rwidth, data ); } else { /* Check to make sure that nothing has gone drastically wrong */ expression_create_value( new_expr, lwidth, data ); } } else { expression_create_value( new_expr, 0, FALSE ); } } } Catch_anonymous { expression_dealloc( new_expr, TRUE ); Throw 0; } /* if( (data == FALSE) && (generate_expr_mode == 0) ) { assert( new_expr->value->value.ul == NULL ); } */ PROFILE_END; return( new_expr ); }

void expression_create_nba (  expression *  expr, vsignal *  lhs_sig, vector *  rhs_vec )

Creates, initializes and adds a non-blocking assignment structure to the given expression's element pointer. Allocates a non-blocking assignment structure to the given expression and initializes it. Parameters: expr  Pointer to expression to add non-blocking assignment structure to lhs_sig  Pointer to left-hand-side signal rhs_vec  Pointer to right-hand-side vector { PROFILE(EXPRESSION_CREATE_NBA); exp_dim* dim = expr->elem.dim; /* Allocate memory */ nonblock_assign* nba = (nonblock_assign*)malloc_safe( sizeof( nonblock_assign ) ); /* Initialize the structure */ nba->lhs_sig = lhs_sig; nba->rhs_vec = rhs_vec; nba->suppl.is_signed = (expr->op == EXP_OP_SIG) ? rhs_vec->suppl.part.is_signed : FALSE; nba->suppl.added = 0; /* Now change the elem pointer from a dim to a dim_nba */ expr->elem.dim_nba = (dim_and_nba*)malloc_safe( sizeof( dim_and_nba ) ); expr->elem.dim_nba->dim = dim; expr->elem.dim_nba->nba = nba; /* Set the nba supplemental bit */ expr->suppl.part.nba = 1; /* Increment the number of nba structures */ nba_queue_size++; PROFILE_END; }

void expression_db_merge (  expression *  base, char **  line, bool  same )

Reads and merges two expressions and stores result in base expression. Exceptions: anonymous  Throw vector_db_merge Parses specified line for expression information and merges contents into the base expression. If the two expressions given are not the same (IDs, op, and/or line position differ) we know that the database files being merged were not created from the same design; therefore, display an error message to the user in this case. If both expressions are the same, perform the merge. Parameters: base  Expression to merge data into line  Pointer to CDD line to parse same  Specifies if expression to be merged needs to be exactly the same as the existing expression { PROFILE(EXPRESSION_DB_MERGE); int id; /* Expression ID field */ int linenum; /* Expression line number */ unsigned int column; /* Column information */ uint32 exec_num; /* Execution number */ uint32 op; /* Expression operation */ esuppl suppl; /* Supplemental field */ int right_id; /* ID of right child */ int left_id; /* ID of left child */ int chars_read; /* Number of characters read */ assert( base != NULL ); if( sscanf( *line, "%d %d %x %x %x %x %d %d%n", &id, &linenum, &column, &exec_num, &op, &(suppl.all), &right_id, &left_id, &chars_read ) == 8 ) { *line = *line + chars_read; if( (base->op != op) || (base->line != linenum) || (base->col != column) ) { print_output( "Attempting to merge databases derived from different designs. Unable to merge", FATAL, __FILE__, __LINE__ ); Throw 0; } else { /* Merge expression supplemental fields */ base->suppl.all = (base->suppl.all & ESUPPL_MERGE_MASK) | (suppl.all & ESUPPL_MERGE_MASK); /* Merge execution number information */ if( base->exec_num < exec_num ) { base->exec_num = exec_num; } if( ESUPPL_OWNS_VEC( suppl ) ) { /* Merge expression vectors */ vector_db_merge( base->value, line, same ); } } } else { print_output( "Unable to parse expression line in database. Unable to merge.", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void expression_db_read (  char **  line, func_unit *  curr_funit, bool  eval )

Reads current line of specified file and parses for expression information. Exceptions: anonymous  expression_create Throw Throw Throw Throw Throw vector_db_read Reads in the specified expression information, creates new expression from heap, populates the expression with specified information from file and returns that value in the specified expression pointer. If all is successful, returns TRUE; otherwise, returns FALSE. Parameters: line  String containing database line to read information from curr_funit  Pointer to current functional unit that instantiates this expression eval  If TRUE, evaluate expression if children are static { PROFILE(EXPRESSION_DB_READ); expression* expr; /* Pointer to newly created expression */ int linenum; /* Holder of current line for this expression */ unsigned int column; /* Holder of column alignment information */ uint32 exec_num; /* Holder of expression's execution number */ uint32 op; /* Holder of expression operation */ esuppl suppl; /* Holder of supplemental value of this expression */ int right_id; /* Holder of expression ID to the right */ int left_id; /* Holder of expression ID to the left */ expression* right; /* Pointer to current expression's right expression */ expression* left; /* Pointer to current expression's left expression */ int chars_read; /* Number of characters scanned in from line */ vector* vec; /* Holders vector value of this expression */ exp_link* expl; /* Pointer to found expression in functional unit */ if( sscanf( *line, "%d %d %x %x %x %x %d %d%n", &curr_expr_id, &linenum, &column, &exec_num, &op, &(suppl.all), &right_id, &left_id, &chars_read ) == 8 ) { *line = *line + chars_read; /* Find functional unit instance name */ if( curr_funit == NULL ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Internal error: expression (%d) in database written before its functional unit", curr_expr_id ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); Throw 0; } else { /* Find right expression */ if( right_id == 0 ) { right = NULL; } else if( (expl = exp_link_find( right_id, curr_funit->exp_head )) == NULL ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Internal error: root expression (%d) found before leaf expression (%d) in database file", curr_expr_id, right_id ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); Throw 0; } else { right = expl->exp; } /* Find left expression */ if( left_id == 0 ) { left = NULL; } else if( (expl = exp_link_find( left_id, curr_funit->exp_head )) == NULL ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Internal error: root expression (%d) found before leaf expression (%d) in database file", curr_expr_id, left_id ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); Throw 0; } else { left = expl->exp; } /* Create new expression */ expr = expression_create( right, left, op, ESUPPL_IS_LHS( suppl ), curr_expr_id, linenum, ((column >> 16) & 0xffff), (column & 0xffff), ESUPPL_OWNS_VEC( suppl ) ); expr->suppl.all = suppl.all; expr->exec_num = exec_num; if( op == EXP_OP_DELAY ) { expr->suppl.part.type = ETYPE_DELAY; expr->elem.scale = &(curr_funit->timescale); } if( ESUPPL_OWNS_VEC( suppl ) ) { Try { /* Read in vector information */ vector_db_read( &vec, line ); } Catch_anonymous { expression_dealloc( expr, TRUE ); Throw 0; } /* Copy expression value */ vector_dealloc( expr->value ); expr->value = vec; } /* Create temporary vectors if necessary */ expression_create_tmp_vecs( expr, expr->value->width ); /* Check to see if we are bound to a signal or functional unit */ if( ((*line)[0] != '\n') && ((*line)[0] != '\0') ) { (*line)++; /* Remove space */ switch( op ) { case EXP_OP_FUNC_CALL : bind_add( FUNIT_FUNCTION, *line, expr, curr_funit ); break; case EXP_OP_TASK_CALL : bind_add( FUNIT_TASK, *line, expr, curr_funit ); break; case EXP_OP_FORK : case EXP_OP_NB_CALL : bind_add( FUNIT_NAMED_BLOCK, *line, expr, curr_funit ); break; case EXP_OP_DISABLE : bind_add( 1, *line, expr, curr_funit ); break; default : bind_add( 0, *line, expr, curr_funit ); break; } } /* If we are an assignment operator, set our vector value to that of the right child */ if( (op == EXP_OP_ASSIGN) || (op == EXP_OP_DASSIGN) || (op == EXP_OP_BASSIGN) || (op == EXP_OP_RASSIGN) || (op == EXP_OP_NASSIGN) || (op == EXP_OP_DLY_ASSIGN) || (op == EXP_OP_IF) || (op == EXP_OP_WHILE) || (op == EXP_OP_DIM) ) { vector_dealloc( expr->value ); expr->value = right->value; } exp_link_add( expr, &(curr_funit->exp_head), &(curr_funit->exp_tail) ); /* If this expression is a constant expression, force the simulator to evaluate this expression and all parent expressions of it. */ if( eval && EXPR_IS_STATIC( expr ) && (ESUPPL_IS_LHS( suppl ) == 0) ) { exp_link_add( expr, &static_expr_head, &static_expr_tail ); } } } else { print_output( "Unable to read expression value", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void expression_db_write (  expression *  expr, FILE *  file, bool  parse_mode, bool  ids_issued )

Writes this expression to the specified database file. This function recursively displays the expression information for the specified expression tree to the coverage database specified by file. Parameters: expr  Pointer to expression to write to database file file  Pointer to database file to write to parse_mode  Set to TRUE when we are writing after just parsing the design (causes ulid value to be output instead of id) ids_issued  Set to TRUE if IDs were issued prior to calling this function { PROFILE(EXPRESSION_DB_WRITE); assert( expr != NULL ); fprintf( file, "%d %d %d %x %x %x %x %d %d", DB_TYPE_EXPRESSION, expression_get_id( expr, ids_issued ), expr->line, expr->col, ((((expr->op == EXP_OP_DASSIGN) || (expr->op == EXP_OP_ASSIGN)) && (expr->exec_num == 0)) ? (uint32)1 : expr->exec_num), expr->op, (expr->suppl.all & ESUPPL_MERGE_MASK), ((expr->op == EXP_OP_STATIC) ? 0 : expression_get_id( expr->right, ids_issued )), ((expr->op == EXP_OP_STATIC) ? 0 : expression_get_id( expr->left, ids_issued )) ); if( ESUPPL_OWNS_VEC( expr->suppl ) ) { fprintf( file, " " ); if( parse_mode && EXPR_OWNS_VEC( expr->op ) && (expr->value->suppl.part.owns_data == 0) ) { expr->value->suppl.part.owns_data = 1; } vector_db_write( expr->value, file, (expr->op == EXP_OP_STATIC), FALSE ); } if( expr->name != NULL ) { fprintf( file, " %s", expr->name ); } else if( expr->sig != NULL ) { fprintf( file, " %s", expr->sig->name ); /* This will be valid for parameters */ } fprintf( file, "\n" ); PROFILE_END; }

void expression_db_write_tree (  expression *  root, FILE *  ofile )

Writes the entire expression tree to the specified data file. Recursively iterates through the specified expression tree, outputting the expressions to the specified file. Parameters: root  Pointer to the root expression to display ofile  Output file to write expression tree to { PROFILE(EXPRESSION_DB_WRITE_TREE); if( root != NULL ) { /* Print children first */ if( EXPR_LEFT_DEALLOCABLE( root ) ) { expression_db_write_tree( root->left, ofile ); } expression_db_write_tree( root->right, ofile ); /* Now write ourselves */ expression_db_write( root, ofile, TRUE, TRUE ); } PROFILE_END; }

void expression_dealloc (  expression *  expr, bool  exp_only )

Deallocates memory used for expression. Deallocates all heap memory allocated with the malloc routine. Parameters: expr  Pointer to root expression to deallocate exp_only  Removes only the specified expression and not its children { PROFILE(EXPRESSION_DEALLOC); int op; /* Temporary operation holder */ exp_link* tmp_expl; /* Temporary pointer to expression list */ statement* tmp_stmt; /* Temporary pointer to statement */ if( expr != NULL ) { op = expr->op; if( ESUPPL_OWNS_VEC( expr->suppl ) ) { /* Free up memory from vector value storage */ vector_dealloc( expr->value ); expr->value = NULL; /* If this is a named block call or fork call, remove the statement that this expression points to */ if( (expr->op == EXP_OP_NB_CALL) || (expr->op == EXP_OP_FORK) ) { if( !exp_only && (expr->elem.funit != NULL) ) { #ifdef DEBUG_MODE if( debug_mode ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Removing statement block starting at line %d because it is a NB_CALL and its calling expression is being removed", expr->elem.funit->first_stmt->exp->line ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif stmt_blk_add_to_remove_list( expr->elem.funit->first_stmt ); } else { bind_remove( expr->id, FALSE ); } /* If this is a task call, remove the bind */ } else if( expr->op == EXP_OP_TASK_CALL ) { bind_remove( expr->id, FALSE ); } else if( expr->op == EXP_OP_FUNC_CALL ) { /* Remove this expression from the attached signal's expression list (if the signal has not been deallocated yet) */ if( expr->sig != NULL ) { exp_link_remove( expr, &(expr->sig->exp_head), &(expr->sig->exp_tail), FALSE ); } bind_remove( expr->id, FALSE ); /* Otherwise, we assume (for now) that the expression is a signal */ } else { if( expr->sig == NULL ) { /* Remove this expression from the binding list */ bind_remove( expr->id, expression_is_assigned( expr ) ); } else { /* Remove this expression from the attached signal's expression list */ exp_link_remove( expr, &(expr->sig->exp_head), &(expr->sig->exp_tail), FALSE ); /* Clear the assigned bit of the attached signal */ if( expression_is_assigned( expr ) ) { expr->sig->suppl.part.assigned = 0; /* If this signal must be assigned, remove all statement blocks that reference this signal */ if( (expr->sig->suppl.part.mba == 1) && !exp_only ) { tmp_expl = expr->sig->exp_head; while( tmp_expl != NULL ) { if( (tmp_stmt = expression_get_root_statement( tmp_expl->exp )) != NULL ) { #ifdef DEBUG_MODE if( debug_mode ) { print_output( "Removing statement block because a statement block is being removed that assigns an MBA", DEBUG, __FILE__, __LINE__ ); } #endif stmt_blk_add_to_remove_list( tmp_stmt ); } tmp_expl = tmp_expl->next; } } } } } } else { /* Remove our expression from its signal, if we have one */ if( expr->sig != NULL ) { exp_link_remove( expr, &(expr->sig->exp_head), &(expr->sig->exp_tail), FALSE ); } } /* Deallocate children */ if( !exp_only ) { if( EXPR_RIGHT_DEALLOCABLE( expr ) ) { expression_dealloc( expr->right, FALSE ); expr->right = NULL; } if( EXPR_LEFT_DEALLOCABLE( expr ) ) { expression_dealloc( expr->left, FALSE ); expr->left = NULL; } } /* If we have temporary vectors to deallocate, do so now */ if( (expr->elem.tvecs != NULL) && (EXPR_TMP_VECS( expr->op ) > 0) ) { unsigned int i; for( i=0; i<EXPR_TMP_VECS( expr->op ); i++ ) { vector_dealloc_value( &(expr->elem.tvecs->vec[i]) ); } free_safe( expr->elem.tvecs, sizeof( vecblk ) ); } /* If we have expression dimensional information, deallocate it now */ if( (expr->elem.dim != NULL) && EXPR_OP_HAS_DIM( expr->op ) ) { if( expr->suppl.part.nba == 1 ) { free_safe( expr->elem.dim_nba->dim, sizeof( exp_dim ) ); free_safe( expr->elem.dim_nba->nba, sizeof( nonblock_assign ) ); free_safe( expr->elem.dim_nba, sizeof( dim_and_nba ) ); } else { free_safe( expr->elem.dim, sizeof( exp_dim ) ); } } /* Free up memory for the parent pointer */ free_safe( expr->parent, sizeof( expr_stmt ) ); /* If name contains data, free it */ free_safe( expr->name, (strlen( expr->name ) + 1) ); /* Remove this expression memory */ free_safe( expr, sizeof( expression ) ); } PROFILE_END; }

void expression_display (  expression *  expr  )

Displays the specified expression information. Displays contents of the specified expression to standard output. This function is called by the funit_display function. Parameters: expr  Pointer to expression to display { int right_id; /* Value of right expression ID */ int left_id; /* Value of left expression ID */ assert( expr != NULL ); if( expr->left == NULL ) { left_id = 0; } else { left_id = expr->left->id; } if( expr->right == NULL ) { right_id = 0; } else { right_id = expr->right->id; } printf( " Expression (%p) => id: %d, op: %s, line: %d, col: %x, suppl: %x, exec_num: %u, left: %d, right: %d, ", expr, expr->id, expression_string_op( expr->op ), expr->line, expr->col, expr->suppl.all, expr->exec_num, left_id, right_id ); if( expr->value->value.ul == NULL ) { printf( "NO DATA VECTOR" ); } else { switch( expr->value->suppl.part.data_type ) { case VDATA_UL : vector_display_value_ulong( expr->value->value.ul, expr->value->width ); break; case VDATA_R64 : if( expr->value->value.r64->str != NULL ) { printf( "%s", expr->value->value.r64->str ); } else { printf( "%.16lf", expr->value->value.r64->val ); } break; case VDATA_R32 : if( expr->value->value.r32->str != NULL ) { printf( "%s", expr->value->value.r32->str ); } else { printf( "%.16f", expr->value->value.r32->val ); } break; default : assert( 0 ); break; } } printf( "\n" ); }

bool expression_find_expr (  expression *  root, expression *  expr )

Returns TRUE if the specified expression exists within the given root expression tree. Returns: Returns TRUE if the given expression exists within the given expression tree; otherwise, returns FALSE Parameters: root  Pointer to root of expression tree to search expr  Pointer to expression to search for { PROFILE(EXPRESSION_FIND_EXPR); bool retval = (root != NULL) && ((root == expr) || expression_find_expr( root->left, expr ) || expression_find_expr( root->right, expr )); PROFILE_END; return( retval ); }

void expression_find_rhs_sigs (  expression *  expr, str_link **  head, str_link **  tail )

Finds all RHS signals in given expression tree. Recursively parses specified expression list in search of RHS signals. When a signal name is found, it is added to the signal name list specified by head and tail. Parameters: expr  Pointer to expression tree to parse head  Pointer to head of signal name list to populate tail  Pointer to tail of signal name list to populate { PROFILE(EXPRESSION_FIND_RHS_SIGS); char* sig_name; /* Name of signal found */ /* Only continue if our expression is valid and it is an RHS */ if( (expr != NULL) && (ESUPPL_IS_LHS( expr->suppl ) == 0) ) { if( (expr->op == EXP_OP_SIG) || (expr->op == EXP_OP_TRIGGER) || (expr->op == EXP_OP_SBIT_SEL) || (expr->op == EXP_OP_MBIT_SEL) || (expr->op == EXP_OP_MBIT_POS) || (expr->op == EXP_OP_MBIT_NEG) ) { /* Get the signal name from the binder */ sig_name = bind_find_sig_name( expr ); assert( sig_name != NULL ); /* If the signal isn't already in the list, add it */ if( str_link_find( sig_name, *head ) == NULL ) { (void)str_link_add( sig_name, head, tail ); } else { free_safe( sig_name, (strlen( sig_name ) + 1) ); } } /* If this expression operation is neither a SIG or TRIGGER, keep searching tree */ if( (expr->op != EXP_OP_SIG) && (expr->op != EXP_OP_TRIGGER) ) { expression_find_rhs_sigs( expr->right, head, tail ); expression_find_rhs_sigs( expr->left, head, tail ); } } PROFILE_END; }

expression* expression_find_uline_id (  expression *  expr, int  ulid )

Finds the expression in this expression tree with the specified underline id. Returns: Returns a pointer to the found expression; otherwise, returns NULL if the expression could not be found. Recursively searches the given expression tree for the specified underline ID. If the expression is found, a pointer to it is returned; otherwise, returns NULL. Parameters: expr  Pointer to root expression to search under ulid  Underline ID to search for { PROFILE(EXPRESSION_FIND_ULINE_ID); expression* found_exp = NULL; /* Pointer to found expression */ if( expr != NULL ) { if( expr->ulid == ulid ) { found_exp = expr; } else { if( (found_exp = expression_find_uline_id( expr->left, ulid )) == NULL ) { found_exp = expression_find_uline_id( expr->right, ulid ); } } } PROFILE_END; return( found_exp ); }

unsigned int expression_get_curr_dimension (  expression *  expr  )

Returns the current dimension of the given expression. Returns: Returns the dimension index for the given expression Recursively iterates up expression tree, counting the number of dimensions deep that the given expression is. Parameters: expr  Pointer to expression to get dimension for { PROFILE(EXPRESSION_GET_CURR_DIMENSION); unsigned int dim; /* Return value for this function */ assert( expr != NULL ); if( expr->op == EXP_OP_DIM ) { dim = expression_get_curr_dimension( expr->left ) + 1; } else { if( (ESUPPL_IS_ROOT( expr->suppl ) == 0) && (expr->parent->expr->op == EXP_OP_DIM) && (expr->parent->expr->right == expr) ) { dim = expression_get_curr_dimension( expr->parent->expr ); } else { dim = 0; } } PROFILE_END; return( dim ); }

expression* expression_get_first_line_expr (  expression *  expr  )

Returns first line in this expression tree. Returns: Returns the line number of the first line in this expression. Parameters: expr  Pointer to root expression to extract first line from { PROFILE(EXPRESSION_GET_FIRST_LINE_EXPR); expression* first = NULL; if( expr != NULL ) { first = expression_get_first_line_expr( expr->left ); if( (first == NULL) || (first->line > expr->line) ) { first = expr; } } PROFILE_END; return( first ); }

int expression_get_id (  expression *  expr, bool  parse_mode )

Returns expression ID of this expression. Returns: Returns expression ID for this expression. If specified expression is non-NULL, return expression ID of this expression; otherwise, return a value of 0 to indicate that this is a leaf node. Parameters: expr  Pointer to expression to get ID from parse_mode  Specifies if ulid (TRUE) or id (FALSE) should be used { PROFILE(EXPRESSION_GET_ID); int id; if( expr == NULL ) { id = 0; } else { id = parse_mode ? expr->ulid : expr->id; } PROFILE_END; return( id ); }

expression* expression_get_last_line_expr (  expression *  expr  )

Returns last line in this expression tree. Returns: Returns the line number of the last line in this expression. Parameters: expr  Pointer to root expression to extract last line from { PROFILE(EXPRESSION_GET_LAST_LINE_EXPR); expression* last = NULL; if( expr != NULL ) { last = expression_get_last_line_expr( expr->right ); if( (last == NULL) || (last->line < expr->line) ) { last = expr; } } PROFILE_END; return( last ); }

statement* expression_get_root_statement (  expression *  exp  )

Finds the root statement for the given expression. Returns: Returns a pointer to the root statement of the specified expression if one exists; otherwise, returns NULL. Recursively traverses up expression tree that contains exp until the root expression is found (if one exists). If the root expression is found, return the pointer to the statement pointing to this root expression. If the root expression was not found, return NULL. Parameters: exp  Pointer to expression to get root statement for { PROFILE(EXPRESSION_GET_ROOT_STATEMENT); statement* stmt; /* Pointer to root statement */ if( exp == NULL ) { stmt = NULL; } else if( ESUPPL_IS_ROOT( exp->suppl ) == 1 ) { stmt = exp->parent->stmt; } else { stmt = expression_get_root_statement( exp->parent->expr ); } PROFILE_END; return( stmt ); }

bool expression_is_bit_select (  expression *  expr  )

Returns TRUE if specified expression is a part of an bit select expression tree. Returns: Returns TRUE if the specifies expression belongs in a single or mult-bit select expression Parameters: expr  Pointer to expression to check { PROFILE(EXPRESSION_IS_BIT_SELECT); bool retval = FALSE; /* Return value for this function */ if( (expr != NULL) && (ESUPPL_IS_ROOT( expr->suppl ) == 0) ) { if( (expr->parent->expr->op == EXP_OP_SBIT_SEL) || (expr->parent->expr->op == EXP_OP_MBIT_SEL) || (expr->parent->expr->op == EXP_OP_MBIT_POS) || (expr->parent->expr->op == EXP_OP_MBIT_NEG) ) { retval = TRUE; } else { retval = expression_is_bit_select( expr->parent->expr ); } } PROFILE_END; return( retval ); }

bool expression_is_in_rassign (  expression *  expr  )

Returns TRUE if specified expression is in an RASSIGN expression tree. Returns: Returns TRUE if the specified expression is in an RASSIGN expression tree; otherwise, returns FALSE. Parameters: expr  Pointer to expression to examine { PROFILE(EXPRESSION_IS_IN_RASSIGN); bool retval = FALSE; /* Return value for this function */ if( expr != NULL ) { if( expr->op == EXP_OP_RASSIGN ) { retval = TRUE; } else if( ESUPPL_IS_ROOT( expr->suppl ) == 0 ) { retval = expression_is_in_rassign( expr->parent->expr ); } } PROFILE_END; return( retval ); }

bool expression_is_last_select (  expression *  expr  )

Returns TRUE if specified expression is the last select of a signal. Returns: Returns TRUE if the specified expression is the last (most right-hand) part/bit select of a signal; otherwise, returns FALSE. Parameters: expr  Pointer to expression to check for last select { PROFILE(EXPRESSION_IS_LAST_SELECT); bool retval = (ESUPPL_IS_ROOT( expr->suppl ) == 1) || ( ((expr->parent->expr->op == EXP_OP_DIM) && (expr->parent->expr->right == expr) && (ESUPPL_IS_ROOT( expr->parent->expr->suppl ) == 0) && (expr->parent->expr->parent->expr->op != EXP_OP_DIM)) || (expr->parent->expr->op != EXP_OP_DIM) ); PROFILE_END; return( retval ); }

expression* expression_is_nba_lhs (  expression *  exp  )

Returns a pointer to the non-blocking assignment expression if the given expression is an assignable expression on the LHS of a non-blocking assignment. Returns: Returns a pointer to the non-blocking assignment if this expression is a child of the LHS that will be assigned via a non-blocking assignment; otherwise, returns a value of NULL. Parameters: exp  Pointer to child expression to check { PROFILE(EXPRESSION_IS_NBA_LHS); while( (exp->op != EXP_OP_NASSIGN) && (ESUPPL_IS_ROOT( exp->suppl ) == 0) && (exp->parent->expr->op != EXP_OP_SBIT_SEL) && (exp->parent->expr->op != EXP_OP_MBIT_SEL) && (exp->parent->expr->op != EXP_OP_MBIT_POS) && (exp->parent->expr->op != EXP_OP_MBIT_NEG) ) { exp = exp->parent->expr; } PROFILE_END; return( (exp->op == EXP_OP_NASSIGN) ? exp : NULL ); }

bool expression_is_static_only (  expression *  expr  )

Returns TRUE if specified expression is found to contain all static leaf expressions. Parameters: expr  Pointer to expression to evaluate { return( expression_is_static_only_helper( expr, NULL ) ); }

void expression_merge (  expression *  base, expression *  other )

Merges two expressions into the base expression. Performs an expression merge of two expressions, storing the result into the base expression. This function is used by the GUI for calculating module coverage. Parameters: base  Base expression that will contain merged results other  Other expression that will merge its results with the base results { PROFILE(EXPRESSION_MERGE); assert( base != NULL ); assert( base->op == other->op ); assert( base->line == other->line ); assert( base->col == other->col ); /* Merge expression supplemental fields */ base->suppl.all = (base->suppl.all & ESUPPL_MERGE_MASK) | (other->suppl.all & ESUPPL_MERGE_MASK); /* Merge execution number information */ if( base->exec_num < other->exec_num ) { base->exec_num = other->exec_num; } if( ESUPPL_OWNS_VEC( base->suppl ) ) { vector_merge( base->value, other->value ); } PROFILE_END; }

bool expression_operate (  expression *  expr, thread *  thr, const sim_time *  time )

Performs operation specified by parameter expression. Returns: Returns TRUE if the assigned expression value was different than the previously stored value; otherwise, returns FALSE. Exceptions: anonymous  func Performs expression operation. This function must only be run after its left and right expressions have been calculated during this clock period. Sets the value of the operation in its own vector value and updates the suppl uint8 as necessary. Parameters: expr  Pointer to expression to set value to thr  Pointer to current thread being simulated time  Pointer to current simulation time { PROFILE(EXPRESSION_OPERATE); bool retval = TRUE; /* Return value for this function */ if( expr != NULL ) { #ifdef DEBUG_MODE if( debug_mode ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, " In expression_operate, id: %d, op: %s, line: %d, addr: %p", expr->id, expression_string_op( expr->op ), expr->line, expr ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif assert( expr->value != NULL ); /* Call expression operation */ retval = exp_op_info[expr->op].func( expr, thr, time ); /* If this expression is attached to an FSM, perform the FSM calculation now */ if( expr->table != NULL ) { fsm_table_set( expr, time ); } /* Specify that we have executed this expression */ (expr->exec_num)++; } PROFILE_END; return( retval ); }

void expression_operate_recursively (  expression *  expr, func_unit *  funit, bool  sizing )

Performs recursive expression operation (parse mode only). Exceptions: anonymous  expression_resize expression_operate_recursively expression_operate_recursively Recursively performs the proper operations to cause the top-level expression to be set to a value. This function is called during the parse stage to derive pre-CDD widths of multi-bit expressions. Each MSB/LSB is an expression tree that needs to be evaluated to set the width properly on the MBIT_SEL expression. Parameters: expr  Pointer to top of expression tree to perform recursive operations funit  Pointer to functional unit containing this expression sizing  Set to TRUE if we are evaluating for purposes of sizing { PROFILE(EXPRESSION_OPERATE_RECURSIVELY); if( expr != NULL ) { /* Create dummy time */ sim_time time = {0,0,0,FALSE}; /* Evaluate children */ expression_operate_recursively( expr->left, funit, sizing ); expression_operate_recursively( expr->right, funit, sizing ); if( sizing ) { /* Non-static expression found where static expression required. Simulator should catch this error before us, so no user error (too much work to find expression in functional unit expression list for now. */ assert( (expr->op != EXP_OP_SBIT_SEL) && (expr->op != EXP_OP_MBIT_SEL) && (expr->op != EXP_OP_MBIT_POS) && (expr->op != EXP_OP_MBIT_NEG) ); /* Resize current expression only */ expression_resize( expr, funit, FALSE, TRUE ); } /* Perform operation */ (void)expression_operate( expr, NULL, &time ); if( sizing ) { /* Clear out the execution number value since we aren't really simulating this */ expr->exec_num = 0; } } PROFILE_END; }

void expression_resize (  expression *  expr, func_unit *  funit, bool  recursive, bool  alloc )

Recursively resizes specified expression tree leaf node. Exceptions: anonymous  expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value expression_create_value funit_size_elements expression_resize expression_resize expression_operate_recursively expression_set_value Resizes the given expression depending on the expression operation and its children's sizes. If recursive is TRUE, performs the resize in a depth-first fashion, resizing the children before resizing the current expression. If recursive is FALSE, only the given expression is evaluated and resized. Parameters: expr  Pointer to expression to potentially resize funit  Pointer to functional unit containing expression recursive  Specifies if we should perform a recursive depth-first resize alloc  If set to TRUE, allocates vector data for all expressions { PROFILE(EXPRESSION_RESIZE); unsigned int largest_width; /* Holds larger width of left and right children */ uint8 old_vec_suppl; /* Holds original vector supplemental field as this will be erased */ funit_inst* tmp_inst; /* Pointer to temporary instance */ int ignore = 0; /* Specifies the number of instances to ignore */ if( expr != NULL ) { uint8 new_owns_data; uint8 new_data_type; if( recursive ) { expression_resize( expr->left, funit, recursive, alloc ); expression_resize( expr->right, funit, recursive, alloc ); } /* Get vector supplemental field */ old_vec_suppl = expr->value->suppl.all; switch( expr->op ) { /* Only resize these values if we are recursively resizing */ case EXP_OP_PARAM : case EXP_OP_PARAM_SBIT : case EXP_OP_PARAM_MBIT : case EXP_OP_PARAM_MBIT_POS : case EXP_OP_PARAM_MBIT_NEG : case EXP_OP_SIG : case EXP_OP_SBIT_SEL : case EXP_OP_MBIT_SEL : case EXP_OP_MBIT_POS : case EXP_OP_MBIT_NEG : if( recursive && (expr->sig != NULL) ) { expression_set_value( expr, expr->sig, funit ); assert( expr->value->value.ul != NULL ); } break; /* These operations will already be sized so nothing to do here */ case EXP_OP_STATIC : case EXP_OP_TRIGGER : case EXP_OP_ASSIGN : case EXP_OP_DASSIGN : case EXP_OP_BASSIGN : case EXP_OP_NASSIGN : case EXP_OP_PASSIGN : case EXP_OP_RASSIGN : case EXP_OP_DLY_ASSIGN : case EXP_OP_IF : case EXP_OP_WHILE : case EXP_OP_LAST : case EXP_OP_DIM : case EXP_OP_STIME : case EXP_OP_SRANDOM : case EXP_OP_SURANDOM : case EXP_OP_SURAND_RANGE : break; /* These operations should always be set to a width 1 */ case EXP_OP_LT : case EXP_OP_GT : case EXP_OP_EQ : case EXP_OP_CEQ : case EXP_OP_LE : case EXP_OP_GE : case EXP_OP_NE : case EXP_OP_CNE : case EXP_OP_LOR : case EXP_OP_LAND : case EXP_OP_UAND : case EXP_OP_UNOT : case EXP_OP_UOR : case EXP_OP_UXOR : case EXP_OP_UNAND : case EXP_OP_UNOR : case EXP_OP_UNXOR : case EXP_OP_EOR : case EXP_OP_CASE : case EXP_OP_CASEX : case EXP_OP_CASEZ : case EXP_OP_DEFAULT : case EXP_OP_REPEAT : case EXP_OP_RPT_DLY : case EXP_OP_WAIT : case EXP_OP_SFINISH : case EXP_OP_SSTOP : case EXP_OP_NEDGE : case EXP_OP_PEDGE : case EXP_OP_AEDGE : case EXP_OP_PLIST : case EXP_OP_SSRANDOM : case EXP_OP_STESTARGS : case EXP_OP_SVALARGS : if( (expr->value->width != 1) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, 1, alloc ); } break; /* In the case of an EXPAND, we need to set the width to be the product of the value of the left child and the bit-width of the right child. */ case EXP_OP_EXPAND : expression_operate_recursively( expr->left, funit, TRUE ); if( vector_is_unknown( expr->left->value ) ) { unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "Unknown value used for concatenation multiplier, file: %s, line: %d", funit->filename, expr->line ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); Throw 0; } if( (expr->value->width != (vector_to_int( expr->left->value ) * expr->right->value->width)) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, (vector_to_int( expr->left->value ) * expr->right->value->width), alloc ); } break; /* In the case of a MULTIPLY or LIST (for concatenation) operation, its expression width must be the sum of its children's width. Remove the current vector and replace it with the appropriately sized vector. */ case EXP_OP_LIST : if( (expr->value->width != (expr->left->value->width + expr->right->value->width)) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, (expr->left->value->width + expr->right->value->width), alloc ); } break; /* A FUNC_CALL expression width is set to the same width as that of the function's return value. */ case EXP_OP_FUNC_CALL : if( expr->sig != NULL ) { assert( funit != NULL ); if( (funit->type != FUNIT_AFUNCTION) && (funit->type != FUNIT_ANAMED_BLOCK) ) { assert( expr->elem.funit != NULL ); tmp_inst = inst_link_find_by_funit( expr->elem.funit, db_list[curr_db]->inst_head, &ignore ); funit_size_elements( expr->elem.funit, tmp_inst, FALSE, FALSE ); } if( (expr->value->width != expr->sig->value->width) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, expr->sig->value->width, alloc ); } } break; default : /* If this expression is either the root, an LHS expression or a lower-level RHS expression, get its size from the largest of its children. */ if( (ESUPPL_IS_ROOT( expr->suppl ) == 1) || (ESUPPL_IS_LHS( expr->suppl ) == 1) || ((expr->parent->expr->op != EXP_OP_ASSIGN) && (expr->parent->expr->op != EXP_OP_DASSIGN) && (expr->parent->expr->op != EXP_OP_BASSIGN) && (expr->parent->expr->op != EXP_OP_NASSIGN) && (expr->parent->expr->op != EXP_OP_RASSIGN) && (expr->parent->expr->op != EXP_OP_DLY_OP)) ) { if( (expr->left != NULL) && ((expr->right == NULL) || (expr->left->value->width > expr->right->value->width)) ) { largest_width = expr->left->value->width; } else if( expr->right != NULL ) { largest_width = expr->right->value->width; } else { largest_width = 1; } if( (expr->value->width != largest_width) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, largest_width, alloc ); } /* If our parent is a DLY_OP, we need to get our value from the LHS of the DLY_ASSIGN expression */ } else if( expr->parent->expr->op == EXP_OP_DLY_OP ) { if( (expr->parent->expr->parent->expr->left->value->width != expr->value->width) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, expr->parent->expr->parent->expr->left->value->width, alloc ); } /* Otherwise, get our value from the size of the expression on the left-hand-side of the assignment */ } else { if( (expr->parent->expr->left->value->width != expr->value->width) || (expr->value->value.ul == NULL) ) { assert( expr->value->value.ul == NULL ); expression_create_value( expr, expr->parent->expr->left->value->width, alloc ); } } break; } /* Reapply original supplemental field (preserving the owns_data bit) now that expression has been resized */ new_owns_data = expr->value->suppl.part.owns_data; new_data_type = expr->value->suppl.part.data_type; expr->value->suppl.all = old_vec_suppl; expr->value->suppl.part.owns_data = new_owns_data; expr->value->suppl.part.data_type = new_data_type; } PROFILE_END; }

void expression_set_assigned (  expression *  expr  )

Sets the expression signal supplemental field assigned bit if the given expression is an RHS of an assignment. Checks to see if the expression is in the LHS of a BASSIGN expression tree. If it is, it sets the assigned supplemental field of the expression's signal vector to indicate the the value of this signal will come from Covered instead of the dumpfile. This is called in the bind_signal function after the expression and signal have been bound (only in parsing stage). Parameters: expr  Pointer to current expression to evaluate { PROFILE(EXPRESSION_SET_ASSIGNED); expression* curr; /* Pointer to current expression */ assert( expr != NULL ); if( ESUPPL_IS_LHS( expr->suppl ) == 1 ) { curr = expr; while( (ESUPPL_IS_ROOT( curr->suppl ) == 0) && (curr->op != EXP_OP_BASSIGN) && (curr->op != EXP_OP_RASSIGN) && (curr->parent->expr->op != EXP_OP_SBIT_SEL) && (curr->parent->expr->op != EXP_OP_MBIT_SEL) && (curr->parent->expr->op != EXP_OP_MBIT_POS) && (curr->parent->expr->op != EXP_OP_MBIT_NEG) ) { curr = curr->parent->expr; } /* If we are on the LHS of a BASSIGN operator, set the assigned bit to indicate that this signal will be assigned by Covered and not the dumpfile. */ if( (curr->op == EXP_OP_BASSIGN) || (curr->op == EXP_OP_RASSIGN) ) { expr->sig->suppl.part.assigned = 1; } } PROFILE_END; }

void expression_set_changed (  expression *  expr  )

Sets the left/right changed expression bits for each expression in the tree. Recursively iterates down expression tree, setting the left/right changed bits in each expression. This is necessary to get continuous assignments and FSM statements to simulate (even if their driving signals have not changed). Parameters: expr  Pointer to expression to set changed bits for { PROFILE(EXPRESSION_SET_CHANGED); if( expr != NULL ) { /* Set the children expressions */ expression_set_changed( expr->left ); expression_set_changed( expr->right ); /* Now set our bits */ expr->suppl.part.left_changed = 1; expr->suppl.part.right_changed = 1; } PROFILE_END; }

void expression_set_signed (  expression *  exp  )

Sets the signed bit for all appropriate parent expressions. Recursively sets the signed bit for all parent expressions if both the left and right expressions have the signed bit set. This function is called by the bind() function after an expression has been set to a signal. Parameters: exp  Pointer to current expression { PROFILE(EXPRESSION_SET_SIGNED); if( exp != NULL ) { /* If this expression is attached to a signal that has the signed bit set (which is not a bit select) or the valid left and right expressions have the signed bit set, set our is_signed bit and continue traversing up expression tree. */ if( ((exp->sig != NULL) && (exp->sig->value->suppl.part.is_signed == 1) && (exp->op != EXP_OP_SBIT_SEL) && (exp->op != EXP_OP_MBIT_SEL) && (exp->op != EXP_OP_PARAM_SBIT) && (exp->op != EXP_OP_PARAM_MBIT)) || ((((exp->left != NULL) && (exp->left->value->suppl.part.is_signed == 1)) || (exp->left == NULL)) && (((exp->right != NULL) && (exp->right->value->suppl.part.is_signed == 1)) || (exp->right == NULL)) && ((exp->op == EXP_OP_ADD) || (exp->op == EXP_OP_SUBTRACT) || (exp->op == EXP_OP_MULTIPLY) || (exp->op == EXP_OP_DIVIDE) || (exp->op == EXP_OP_MOD) || (exp->op == EXP_OP_STATIC) || (exp->op == EXP_OP_LT) || (exp->op == EXP_OP_GT) || (exp->op == EXP_OP_LE) || (exp->op == EXP_OP_GE) || (exp->op == EXP_OP_EQ) || (exp->op == EXP_OP_NE))) || (exp->value->suppl.part.is_signed == 1) ) { exp->value->suppl.part.is_signed = 1; /* If we are not the root expression, traverse up */ if( ESUPPL_IS_ROOT( exp->suppl ) == 0 ) { expression_set_signed( exp->parent->expr ); } } } PROFILE_END; }

void expression_set_value (  expression *  exp, vsignal *  sig, func_unit *  funit )

Sets the specified expression value to the specified vector value. Exceptions: anonymous  expression_operate_recursively expression_operate_recursively expression_operate_recursively Sets the specified expression (if necessary) to the value of the specified signal's vector value. Parameters: exp  Pointer to expression to set value to sig  Pointer to signal containing vector value to set expression to funit  Pointer to functional unit containing expression { PROFILE(EXPRESSION_SET_VALUE); assert( exp != NULL ); assert( exp->value != NULL ); assert( sig != NULL ); assert( sig->value != NULL ); /* Set our vector type to match the signal type */ exp->value->suppl.part.data_type = sig->value->suppl.part.data_type; /* If we are a SIG, PARAM or TRIGGER type, set our value to the signal's value */ if( (exp->op == EXP_OP_SIG) || (exp->op == EXP_OP_PARAM) || (exp->op == EXP_OP_TRIGGER) ) { exp->value->suppl = sig->value->suppl; exp->value->width = sig->value->width; exp->value->value.ul = sig->value->value.ul; exp->value->suppl.part.owns_data = 0; /* Otherwise, create our own vector to store the part select */ } else { unsigned int edim = expression_get_curr_dimension( exp ); int exp_width = vsignal_calc_width_for_expr( exp, sig ); exp_dim* dim; /* Allocate dimensional structure (if needed) and populate it with static information */ if( exp->elem.dim == NULL ) { exp->elem.dim = dim = (exp_dim*)malloc_safe( sizeof( exp_dim ) ); } else if( exp->suppl.part.nba == 1 ) { dim = exp->elem.dim_nba->dim; } else { dim = exp->elem.dim; } dim->curr_lsb = -1; if( sig->dim[edim].lsb < sig->dim[edim].msb ) { dim->dim_lsb = sig->dim[edim].lsb; dim->dim_be = FALSE; } else { dim->dim_lsb = sig->dim[edim].msb; dim->dim_be = TRUE; } dim->dim_width = exp_width; dim->last = expression_is_last_select( exp ); /* Set the expression width */ switch( exp->op ) { case EXP_OP_SBIT_SEL : case EXP_OP_PARAM_SBIT : break; case EXP_OP_MBIT_SEL : case EXP_OP_PARAM_MBIT : { int lbit, rbit; expression_operate_recursively( exp->left, funit, TRUE ); expression_operate_recursively( exp->right, funit, TRUE ); lbit = vector_to_int( exp->left->value ); rbit = vector_to_int( exp->right->value ); if( lbit <= rbit ) { exp_width = ((rbit - lbit) + 1) * exp_width; } else { exp_width = ((lbit - rbit) + 1) * exp_width; } } break; case EXP_OP_MBIT_POS : case EXP_OP_MBIT_NEG : case EXP_OP_PARAM_MBIT_POS : case EXP_OP_PARAM_MBIT_NEG : expression_operate_recursively( exp->right, funit, TRUE ); exp_width = vector_to_int( exp->right->value ) * exp_width; break; default : break; } /* Allocate a vector for this expression */ if( exp->value->value.ul != NULL ) { vector_dealloc_value( exp->value ); } expression_create_value( exp, exp_width, TRUE ); } PROFILE_END; }

char* expression_string (  expression *  exp  )

Returns user-readable version of the supplied expression. Returns a pointer to user_msg that will contain a user-friendly string version of the given expression Parameters: exp  Pointer to expression to display { PROFILE(EXPRESSION_STRING); unsigned int rv = snprintf( user_msg, USER_MSG_LENGTH, "%d (%s line %d)", exp->id, expression_string_op( exp->op ), exp->line ); assert( rv < USER_MSG_LENGTH ); PROFILE_END; return( user_msg ); }

const char* expression_string_op (  int  op  )

Returns user-readable name of specified expression operation. Returns: Returns a non-writable string that contains the user-readable name of the specified expression operation. Parameters: op  Expression operation to get string representation of { PROFILE(EXPRESSION_STRING_OP); assert( (op >= 0) && (op < EXP_OP_NUM) ); PROFILE_END; return( exp_op_info[op].name ); }

---