/Users/trevorw/projects/release/covered-0.7.4/src/gen_item.c File Reference

---

Detailed Description

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

7/10/2006

#include <string.h>
#include <stdio.h>
#include "binding.h"
#include "defines.h"
#include "expr.h"
#include "func_unit.h"
#include "gen_item.h"
#include "instance.h"
#include "link.h"
#include "obfuscate.h"
#include "param.h"
#include "scope.h"
#include "statement.h"
#include "util.h"
#include "vector.h"
#include "vsignal.h"

Functions
int	parse_static_expr (char *str, func_unit *funit, int lineno, bool no_genvars)
void	gen_item_stringify (gen_item *gi, char *str, unsigned int str_len)
void	gen_item_display (gen_item *gi)
	Displays the specified generate item to standard output.
void	gen_item_display_block_helper (gen_item *root)
void	gen_item_display_block (gen_item *root)
	Displays an entire generate block.
bool	gen_item_compare (gen_item *gi1, gen_item *gi2)
gen_item *	gen_item_find (gen_item *root, gen_item *gi)
	Searches for a generate item in the generate block of root that matches gi.
void	gen_item_remove_if_contains_expr_calling_stmt (gen_item *gi, statement *stmt)
	Searches for an expression in the generate list that calls the given statement.
void	gen_item_get_genvar (char *varname, char **pre, char **genvar, char **post)
bool	gen_item_varname_contains_genvar (char *name)
	Returns TRUE if the specified variable name contains a generate variable within it.
char *	gen_item_calc_signal_name (const char *name, func_unit *funit, int line, bool no_genvars)
	Returns the actual signal name specified by the given signal name which references a generated hierarchy.
gen_item *	gen_item_create_expr (expression *expr)
	Creates a generate item for an expression.
gen_item *	gen_item_create_sig (vsignal *sig)
	Creates a generate item for a signal.
gen_item *	gen_item_create_stmt (statement *stmt)
	Creates a generate item for a statement.
gen_item *	gen_item_create_inst (funit_inst *inst)
	Creates a generate item for an instance.
gen_item *	gen_item_create_tfn (funit_inst *inst)
	Creates a generate item for a namespace.
gen_item *	gen_item_create_bind (const char *name, expression *expr)
	Creates a generate item for a binding.
void	gen_item_resize_stmts_and_sigs (gen_item *gi, func_unit *funit)
	Resizes all statements and signals in the given generate item block.
void	gen_item_assign_ids (gen_item *gi, func_unit *funit)
	Assigns unique signal ID or expression IDs to all expressions for specified statement block.
void	gen_item_db_write (gen_item *gi, uint32 type, FILE *ofile)
	Outputs the current generate item to the given output file if it matches the type specified.
void	gen_item_db_write_expr_tree (gen_item *gi, FILE *ofile)
	Outputs the entire expression tree from the given generate statement.
bool	gen_item_connect (gen_item *gi1, gen_item *gi2, int conn_id, bool stop_on_null)
	Connects a generate item block to a new generate item.
void	gen_item_resolve (gen_item *gi, funit_inst *inst)
void	gen_item_bind (gen_item *gi)
	Checks generate item and if it is a bind, adds it to binding pool and returns TRUE.
void	generate_resolve (funit_inst *root)
	Resolves all generate items in the design.
bool	generate_remove_stmt_helper (funit_inst *root, statement *stmt)
bool	generate_remove_stmt (statement *stmt)
	Removes the given generate statement from the correct instance.
void	gen_item_dealloc (gen_item *gi, bool rm_elem)
	Deallocates all associated memory for the given generate item.
Variables
db **	db_list
unsigned int	curr_db
char	user_msg [USER_MSG_LENGTH]
bool	debug_mode
func_unit *	curr_funit
int	curr_sig_id

---

Function Documentation

void gen_item_assign_ids (  gen_item *  gi, func_unit *  funit )

Assigns unique signal ID or expression IDs to all expressions for specified statement block. Exceptions: anonymous  statement_assign_expr_ids Assigns unique expression and signal IDs to each expression in the tree given for a generated statement or for the given signal. Parameters: gi  Pointer to generate item to check and assign expression IDs for funit  Pointer to functional unit containing this generate item { PROFILE(GEN_ITEM_ASSIGN_IDS); if( gi->suppl.part.removed == 0 ) { /* Assign expression IDs if this is a statement */ if( gi->suppl.part.type == GI_TYPE_STMT ) { statement_assign_expr_ids( gi->elem.stmt, funit ); } else if( gi->suppl.part.type == GI_TYPE_SIG ) { gi->elem.sig->id = curr_sig_id; curr_sig_id++; } } PROFILE_END; }

void gen_item_bind (  gen_item *  gi  )

Checks generate item and if it is a bind, adds it to binding pool and returns TRUE. Updates the specified expression name to be that of the generate item name if the current generate item is a BIND type. Parameters: gi  Pointer to generate item to examine { PROFILE(GEN_ITEM_BIND); if( gi->suppl.part.type == GI_TYPE_BIND ) { /* Remove the current name */ free_safe( gi->elem.expr->name, (strlen( gi->elem.expr->name ) + 1) ); /* Assign the new name */ gi->elem.expr->name = strdup_safe( gi->varname ); } PROFILE_END; }

char* gen_item_calc_signal_name (  const char *  name, func_unit *  funit, int  line, bool  no_genvars )

Returns the actual signal name specified by the given signal name which references a generated hierarchy. Parameters: name  Name of signal that we possibly need to convert if it contains generate variable(s) funit  Pointer to current functional unit line  Line number in which the signal's expression exists no_genvars  If set to TRUE, we need to make sure that we do not see a generate variable in the generate hierarchical expression. Returns: Returns allocated string containing the signal name with embedded generate variables evaluated Exceptions: anonymous  parse_static_expr Throw Iterates through the given name, substituting any found generate variables with their current value. { PROFILE(GEN_ITEM_CALC_SIGNAL_NAME); char* new_name = NULL; /* Return value of this function */ char* tmpname; /* Temporary name of current part of variable */ char* pre; /* String prior to the generate variable */ char* genvar; /* Generate variable */ char* post; /* String after the generate variable */ char intstr[20]; /* String containing an integer value */ char* ptr; /* Pointer to allocated memory for name */ /* Allocate memory */ tmpname = strdup_safe( name ); ptr = tmpname; new_name = strdup_safe( "" ); Try { do { gen_item_get_genvar( tmpname, &pre, &genvar, &post ); if( genvar != NULL ) { unsigned int rv = snprintf( intstr, 20, "%d", parse_static_expr( genvar, funit, line, no_genvars ) ); assert( rv < 20 ); new_name = (char*)realloc_safe( new_name, (strlen( new_name ) + 1), (strlen( new_name ) + strlen( pre ) + strlen( intstr ) + 3) ); strncat( new_name, pre, strlen( pre ) ); strncat( new_name, "[", 1 ); strncat( new_name, intstr, strlen( intstr ) ); strncat( new_name, "]", 1 ); tmpname = post; } else { new_name = (char*)realloc_safe( new_name, (strlen( new_name ) + 1), (strlen( new_name ) + strlen( pre ) + 1) ); strncat( new_name, pre, strlen( pre ) ); } } while( genvar != NULL ); } Catch_anonymous { free_safe( new_name, (strlen( new_name ) + 1) ); free_safe( ptr, (strlen( name ) + 1) ); Throw 0; } /* Deallocate memory */ free_safe( ptr, (strlen( name ) + 1) ); /* Make sure that the new_name is set to something */ assert( new_name != NULL ); return( new_name ); }

bool gen_item_compare (  gen_item *  gi1, gen_item *  gi2 )  [static]

Returns: Returns TRUE if the two specified generate items are equivalent; otherwise, returns FALSE. Parameters: gi1  Pointer to first generate item to compare gi2  Pointer to second generate item to compare { PROFILE(GEN_ITEM_COMPARE); bool retval = FALSE; /* Return value for this function */ if( (gi1 != NULL) && (gi2 != NULL) && (gi1->suppl.part.type == gi2->suppl.part.type) ) { switch( gi1->suppl.part.type ) { case GI_TYPE_EXPR : retval = (gi1->elem.expr->id == gi2->elem.expr->id) ? TRUE : FALSE; break; case GI_TYPE_SIG : retval = scope_compare( gi1->elem.sig->name, gi2->elem.sig->name ); break; case GI_TYPE_STMT : retval = (gi1->elem.stmt->exp->id == gi2->elem.stmt->exp->id) ? TRUE : FALSE; break; case GI_TYPE_INST : case GI_TYPE_TFN : retval = (strcmp( gi1->elem.inst->name, gi2->elem.inst->name ) == 0) ? TRUE : FALSE; break; case GI_TYPE_BIND : retval = ((gi1->elem.expr->id == gi2->elem.expr->id) && (strcmp( gi1->varname, gi2->varname ) == 0)) ? TRUE : FALSE; break; default : break; } } PROFILE_END; return( retval ); }

bool gen_item_connect (  gen_item *  gi1, gen_item *  gi2, int  conn_id, bool  stop_on_null )

Connects a generate item block to a new generate item. Returns: Returns TRUE if the connection was successful; otherwise, returns FALSE. Parameters: gi1  Pointer to generate item block to connect to gi2 gi2  Pointer to generate item to connect to gi1 conn_id  Connection ID stop_on_null  Sets stop bit(s) if a NULL next_true/next_false pointer is found { PROFILE(GEN_ITEM_CONNECT); bool retval = FALSE; /* Return value for this function */ /* Set the connection ID */ gi1->suppl.part.conn_id = conn_id; /* If both paths go to the same destination, only parse one path */ if( gi1->next_true == gi1->next_false ) { /* If the TRUE path is NULL, connect it to the new statement */ if( gi1->next_true == NULL ) { gi1->next_true = gi2; gi1->next_false = gi2; if( (gi1->next_true->suppl.part.conn_id == conn_id) || stop_on_null ) { gi1->suppl.part.stop_true = 1; gi1->suppl.part.stop_false = 1; } retval = TRUE; } else if( gi1->next_true->suppl.part.conn_id == conn_id ) { gi1->suppl.part.stop_true = 1; gi1->suppl.part.stop_false = 1; /* If the TRUE path leads to a loop/merge, stop traversing */ } else if( gi1->next_true != gi2 ) { retval |= gen_item_connect( gi1->next_true, gi2, conn_id, stop_on_null ); } } else { /* Traverse FALSE path */ if( gi1->next_false == NULL ) { gi1->next_false = gi2; if( (gi1->next_false->suppl.part.conn_id == conn_id) || stop_on_null ) { gi1->suppl.part.stop_false = 1; } else { gi1->next_false->suppl.part.conn_id = conn_id; } retval = TRUE; } else if( gi1->next_false->suppl.part.conn_id == conn_id ) { gi1->suppl.part.stop_false = 1; } else if( gi1->next_false != gi2 ) { retval |= gen_item_connect( gi1->next_false, gi2, conn_id, stop_on_null ); } /* Traverse TRUE path */ if( gi1->next_true == NULL ) { gi1->next_true = gi2; if( (gi1->next_true->suppl.part.conn_id == conn_id) || stop_on_null ) { gi1->suppl.part.stop_true = 1; } retval = TRUE; } else if( gi1->next_true->suppl.part.conn_id == conn_id ) { gi1->suppl.part.stop_true = 1; } else if( (gi1->next_true != gi2) && (gi1->suppl.part.type != GI_TYPE_TFN) && (gi1->varname == NULL) ) { retval |= gen_item_connect( gi1->next_true, gi2, conn_id, TRUE ); } } PROFILE_END; return( retval ); }

gen_item* gen_item_create_bind (  const char *  name, expression *  expr )

Creates a generate item for a binding. Parameters: name  Name of signal to bind to expr  Pointer to expression to bind signal to Returns: Returns a pointer to create generate item. Create a new generate item for a namespace. { PROFILE(GEN_ITEM_CREATE_BIND); gen_item* gi; /* Create the generate item for a namespace */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.expr = expr; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_BIND; gi->varname = strdup_safe( name ); gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_bind, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_expr (  expression *  expr  )

Creates a generate item for an expression. Parameters: expr  Pointer to root expression to create (this is an expression from a FOR, IF or CASE statement) Returns: Returns a pointer to created generate item. Creates a new generate item for an expression. { PROFILE(GEN_ITEM_CREATE_EXPR); gen_item* gi; /* Create the generate item for an expression */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.expr = expr; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_EXPR; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_expr, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_inst (  funit_inst *  inst  )

Creates a generate item for an instance. Parameters: inst  Pointer to instance to create a generate item for (instantiations) Returns: Returns a pointer to create generate item. Create a new generate item for an instance. { PROFILE(GEN_ITEM_CREATE_INST); gen_item* gi; /* Create the generate item for an instance */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.inst = inst; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_INST; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_inst, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_sig (  vsignal *  sig  )

Creates a generate item for a signal. Parameters: sig  Pointer to signal to create a generate item for (wire/reg instantions) Returns: Returns a pointer to created generate item. Creates a new generate item for a signal. { PROFILE(GEN_ITEM_CREATE_SIG); gen_item* gi; /* Create the generate item for a signal */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.sig = sig; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_SIG; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_sig, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_stmt (  statement *  stmt  )

Creates a generate item for a statement. Parameters: stmt  Pointer to statement to create a generate item for (assign, always, initial blocks) Returns: Returns a pointer to create generate item. Create a new generate item for a statement. { PROFILE(GEN_ITEM_CREATE_STMT); gen_item* gi; /* Create the generate item for a statement */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.stmt = stmt; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_STMT; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_stmt, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

gen_item* gen_item_create_tfn (  funit_inst *  inst  )

Creates a generate item for a namespace. Parameters: inst  Pointer to namespace to create a generate item for (named blocks, functions or tasks) Returns: Returns a pointer to create generate item. Create a new generate item for a namespace. { PROFILE(GEN_ITEM_CREATE_TFN); gen_item* gi; /* Create the generate item for a namespace */ gi = (gen_item*)malloc_safe( sizeof( gen_item ) ); gi->elem.inst = inst; gi->suppl.all = 0; gi->suppl.part.type = GI_TYPE_TFN; gi->varname = NULL; gi->next_true = NULL; gi->next_false = NULL; #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "In gen_item_create_tfn, %s", str ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif return( gi ); }

void gen_item_db_write (  gen_item *  gi, uint32  type, FILE *  ofile )

Outputs the current generate item to the given output file if it matches the type specified. Checks the given generate item against the supplied type. If they match, outputs the given generate item to the specified output file. If they do not match, nothing is done. Parameters: gi  Pointer to current generate item to test and output type  Specifies the type of the generate item to output ofile  Output file to display generate item to { PROFILE(GEN_ITEM_DB_WRITE); /* If the types match, output based on type */ if( (gi->suppl.part.type == type) && (gi->suppl.part.removed == 0) ) { switch( type ) { case GI_TYPE_SIG : vsignal_db_write( gi->elem.sig, ofile ); break; case GI_TYPE_STMT : statement_db_write_tree( gi->elem.stmt, ofile ); break; default : /* Should never be called */ assert( (type == GI_TYPE_SIG) || (type == GI_TYPE_STMT) ); break; } } PROFILE_END; }

void gen_item_db_write_expr_tree (  gen_item *  gi, FILE *  ofile )

Outputs the entire expression tree from the given generate statement. Outputs all expressions for the statement contained in the specified generate item. Parameters: gi  Pointer to current generate item to test and output ofile  Output file to display generate item to { PROFILE(GEN_ITEM_DB_WRITE_EXPR_TREE); /* Only do this for statements */ if( (gi->suppl.part.type == GI_TYPE_STMT) && (gi->suppl.part.removed == 0) ) { statement_db_write_expr_tree( gi->elem.stmt, ofile ); } PROFILE_END; }

void gen_item_dealloc (  gen_item *  gi, bool  rm_elem )

Deallocates all associated memory for the given generate item. Recursively deallocates the gen_item structure tree. Parameters: gi  Pointer to gen_item structure to deallocate rm_elem  If set to TRUE, removes the associated element { PROFILE(GEN_ITEM_DEALLOC); if( gi != NULL ) { /* Deallocate children first */ if( gi->next_true == gi->next_false ) { if( gi->suppl.part.stop_true == 0 ) { gen_item_dealloc( gi->next_true, rm_elem ); } } else { if( gi->suppl.part.stop_false == 0 ) { gen_item_dealloc( gi->next_false, rm_elem ); } if( gi->suppl.part.stop_true == 0 ) { gen_item_dealloc( gi->next_true, rm_elem ); } } /* If we need to remove the current element, do so now */ if( rm_elem ) { switch( gi->suppl.part.type ) { case GI_TYPE_EXPR : expression_dealloc( gi->elem.expr, FALSE ); break; case GI_TYPE_SIG : vsignal_dealloc( gi->elem.sig ); break; case GI_TYPE_STMT : statement_dealloc_recursive( gi->elem.stmt, FALSE ); break; case GI_TYPE_INST : case GI_TYPE_TFN : instance_dealloc_tree( gi->elem.inst ); break; case GI_TYPE_BIND : break; default : break; } } /* Remove the varname if necessary */ free_safe( gi->varname, (strlen( gi->varname ) + 1) ); /* Now deallocate ourselves */ free_safe( gi, sizeof( gen_item ) ); } PROFILE_END; }

void gen_item_display (  gen_item *  gi  )

Displays the specified generate item to standard output. Displays the contents of the specified generate item to standard output (used for debugging purposes). Parameters: gi  Pointer to generate item to display { PROFILE(GEN_ITEM_DISPLAY); char str[4096]; /* String to store data into */ gen_item_stringify( gi, str, 4096 ); printf( " %s\n", str ); PROFILE_END; }

void gen_item_display_block (  gen_item *  root  )

Displays an entire generate block. Displays an entire generate block to standard output (used for debugging purposes). Parameters: root  Pointer to starting generate item to display { PROFILE(GEN_ITEM_DISPLAY_BLOCK); printf( "Generate block:\n" ); gen_item_display_block_helper( root ); PROFILE_END; }

void gen_item_display_block_helper (  gen_item *  root  )  [static]

Displays an entire generate block to standard output (used for debugging purposes). Parameters: root  Pointer to starting generate item to display { PROFILE(GEN_ITEM_DISPLAY_BLOCK_HELPER); if( root != NULL ) { /* Display ourselves */ gen_item_display( root ); if( root->next_true == root->next_false ) { if( root->suppl.part.stop_true == 0 ) { gen_item_display_block_helper( root->next_true ); } } else { if( root->suppl.part.stop_true == 0 ) { gen_item_display_block_helper( root->next_true ); } if( root->suppl.part.stop_false == 0 ) { gen_item_display_block_helper( root->next_false ); } } } PROFILE_END; }

gen_item* gen_item_find (  gen_item *  root, gen_item *  gi )

Searches for a generate item in the generate block of root that matches gi. Returns: Returns a pointer to the generate item that matches the given generate item in the given generate item block. Returns NULL if it was not able to find a matching item. Recursively traverses the specified generate item block searching for a generate item that matches the specified generate item. Parameters: root  Pointer to root of generate item block to search in gi  Pointer to generate item to search for { PROFILE(GEN_ITEM_FIND); gen_item* found = NULL; /* Return value for this function */ assert( gi != NULL ); if( root != NULL ) { if( gen_item_compare( root, gi ) ) { found = root; } else { /* If both true and false paths lead to same item, just traverse the true path */ if( root->next_true == root->next_false ) { if( root->suppl.part.stop_true == 0 ) { found = gen_item_find( root->next_true, gi ); } /* Otherwise, traverse both true and false paths */ } else if( (root->suppl.part.stop_true == 0) && ((found = gen_item_find( root->next_true, gi )) == NULL) ) { if( root->suppl.part.stop_false == 0 ) { found = gen_item_find( root->next_false, gi ); } } } } PROFILE_END; return( found ); }

void gen_item_get_genvar (  char *  varname, char **  pre, char **  genvar, char **  post )  [static]

Searches the given variable name for a generate variable. If one is found, pre is set to point to the string preceding the generate variable, genvar is set to point to the beginning of the generate variable, and post is set to point to the string succeeding the ']'. Parameters: varname  Variable name to search pre  Reference pointer to string preceding the generate variable genvar  Reference pointer to found generate variable name post  Reference pointer to string succeeding the generate variable { PROFILE(GEN_ITEM_GET_GENVAR); int i = 0; /* Loop iterator */ /* Initialize pointers */ *pre = varname; *genvar = NULL; *post = NULL; /* Iterate through the variable name until we either reach the end of the string or until we have found a genvar */ while( (varname[i] != '\0') && (*genvar == NULL) ) { /* Iterate through the varname until we see either a \, [ or terminating character */ while( (varname[i] != '\\') && (varname[i] != '[') && (varname[i] != '\0') ) { i++; } /* If we saw a \ character, keep going until we see whitespace */ if( varname[i] == '\\' ) { while( (varname[i] != ' ') && (varname[i] != '\n') && (varname[i] != '\t') && (varname[i] != '\r') ) { i++; } /* If we saw a [, get the genvar name, stripping all whitespace from the name */ } else if( varname[i] == '[' ) { varname[i] = '\0'; i++; while( (varname[i] == ' ') || (varname[i] == '\n') || (varname[i] == '\t') || (varname[i] == '\r') ) { i++; } *genvar = (varname + i); while( (varname[i] != ' ') && (varname[i] != '\n') && (varname[i] != '\t') && (varname[i] != '\r') && (varname[i] != ']') ) { i++; } if( varname[i] != ']' ) { varname[i] = '\0'; i++; while( varname[i] != ']' ) { i++; } } else { varname[i] = '\0'; } i++; *post = (varname + i); } } PROFILE_END; }

void gen_item_remove_if_contains_expr_calling_stmt (  gen_item *  gi, statement *  stmt )

Searches for an expression in the generate list that calls the given statement. Removes the given generate item if it contains an expressions that calls a statement. Parameters: gi  Pointer to generate item list to search stmt  Pointer to statement to search for { PROFILE(GEN_ITEM_REMOVE_IF_CONTAINS_EXPR_CALLING_STMT); if( gi != NULL ) { if( gi->suppl.part.type == GI_TYPE_STMT ) { if( statement_contains_expr_calling_stmt( gi->elem.stmt, stmt ) ) { gi->suppl.part.removed = 1; } } else { /* If both true and false paths lead to same item, just traverse the true path */ if( gi->next_true == gi->next_false ) { if( gi->suppl.part.stop_true == 0 ) { gen_item_remove_if_contains_expr_calling_stmt( gi->next_true, stmt ); } /* Otherwise, traverse both true and false paths */ } else { if( gi->suppl.part.stop_true == 0 ) { gen_item_remove_if_contains_expr_calling_stmt( gi->next_true, stmt ); } if( gi->suppl.part.stop_false == 0 ) { gen_item_remove_if_contains_expr_calling_stmt( gi->next_false, stmt ); } } } } PROFILE_END; }

void gen_item_resize_stmts_and_sigs (  gen_item *  gi, func_unit *  funit )

Resizes all statements and signals in the given generate item block. Exceptions: anonymous  vsignal_create_vec statement_size_elements gen_item_resize_stmts_and_sigs gen_item_resize_stmts_and_sigs gen_item_resize_stmts_and_sigs Recursively iterates the the specified generate item block, resizing all statements within that block. Parameters: gi  Pointer to generate item block to check funit  Pointer to functional unit that contains this generate item { PROFILE(GEN_ITEM_RESIZE_STMTS_AND_SIGS); if( gi != NULL ) { /* Resize our statement, if we are one */ if( gi->suppl.part.type == GI_TYPE_STMT ) { statement_size_elements( gi->elem.stmt, funit ); } else if( gi->suppl.part.type == GI_TYPE_SIG ) { vsignal_create_vec( gi->elem.sig ); } /* Go to the next generate item */ if( gi->next_true == gi->next_false ) { if( gi->suppl.part.stop_true == 0 ) { gen_item_resize_stmts_and_sigs( gi->next_true, funit ); } } else { if( gi->suppl.part.stop_false == 0 ) { gen_item_resize_stmts_and_sigs( gi->next_false, funit ); } if( gi->suppl.part.stop_true == 0 ) { gen_item_resize_stmts_and_sigs( gi->next_true, funit ); } } } PROFILE_END; }

void gen_item_resolve (  gen_item *  gi, funit_inst *  inst )  [static]

Exceptions: anonymous  gen_item_calc_signal_name Throw expression_resize expression_operate_recursively gen_item_resolve gen_item_resolve gen_item_resolve gen_item_resolve gen_item_resolve gen_item_resolve gen_item_resolve gen_item_resolve Recursively iterates through the entire generate block specified by gi, resolving all generate items within it. This is called by the generate_resolve function (in the middle of the binding process) and by the funit_size_elements function (just prior to outputting this instance to the CDD file). Parameters: gi  Pointer to current generate item to resolve inst  Pointer to instance to store results to { PROFILE(GEN_ITEM_RESOLVE); funit_inst* child; /* Pointer to child instance of this instance to resolve */ char* varname; /* Pointer to new, substituted name (used for BIND types) */ if( (gi != NULL) && (inst != NULL) ) { #ifdef DEBUG_MODE if( debug_mode ) { char str[USER_MSG_LENGTH]; unsigned int rv; gen_item_stringify( gi, str, USER_MSG_LENGTH ); rv = snprintf( user_msg, USER_MSG_LENGTH, "Resolving generate item, %s for inst: %s", str, obf_inst( inst->name ) ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, DEBUG, __FILE__, __LINE__ ); } #endif /* Specify that this generate item has been resolved */ gi->suppl.part.resolved = 1; switch( gi->suppl.part.type ) { case GI_TYPE_EXPR : /* Recursively resize the expression tree if we have not already done this */ if( gi->elem.expr->exec_num == 0 ) { expression_resize( gi->elem.expr, inst->funit, TRUE, FALSE ); } expression_operate_recursively( gi->elem.expr, inst->funit, FALSE ); if( ESUPPL_IS_TRUE( gi->elem.expr->suppl ) ) { gen_item_resolve( gi->next_true, inst ); } else { gen_item_resolve( gi->next_false, inst ); } break; case GI_TYPE_SIG : gitem_link_add( gen_item_create_sig( gi->elem.sig ), &(inst->gitem_head), &(inst->gitem_tail) ); gen_item_resolve( gi->next_true, inst ); break; case GI_TYPE_STMT : gitem_link_add( gen_item_create_stmt( gi->elem.stmt ), &(inst->gitem_head), &(inst->gitem_tail) ); gen_item_resolve( gi->next_true, inst ); break; case GI_TYPE_INST : { funit_inst* tinst; if( (tinst = instance_copy( gi->elem.inst, inst, gi->elem.inst->name, gi->elem.inst->range, FALSE )) != NULL ) { param_resolve( tinst ); } gen_item_resolve( gi->next_true, inst ); } break; case GI_TYPE_TFN : if( gi->varname != NULL ) { char inst_name[4096]; vsignal* genvar; func_unit* found_funit; unsigned int rv; if( !scope_find_signal( gi->varname, inst->funit, &genvar, &found_funit, 0 ) ) { rv = snprintf( user_msg, USER_MSG_LENGTH, "Unable to find variable %s in module %s", obf_sig( gi->varname ), obf_funit( inst->funit->name ) ); assert( rv < USER_MSG_LENGTH ); print_output( user_msg, FATAL, __FILE__, __LINE__ ); Throw 0; } rv = snprintf( inst_name, 4096, "%s[%d]", gi->elem.inst->name, vector_to_int( genvar->value ) ); assert( rv < 4096 ); (void)instance_parse_add( &inst, inst->funit, gi->elem.inst->funit, inst_name, NULL, FALSE, TRUE, FALSE, TRUE ); rv = snprintf( inst_name, 4096, "%s.%s[%d]", inst->name, gi->elem.inst->name, vector_to_int( genvar->value ) ); assert( rv < 4096 ); if( (child = instance_find_scope( inst, inst_name, TRUE )) != NULL ) { inst_parm_add_genvar( genvar, child ); } } else { char inst_name[4096]; unsigned int rv; (void)instance_parse_add( &inst, inst->funit, gi->elem.inst->funit, gi->elem.inst->name, NULL, FALSE, TRUE, FALSE, TRUE ); rv = snprintf( inst_name, 4096, "%s.%s", inst->name, gi->elem.inst->name ); assert( rv < 4096 ); child = instance_find_scope( inst, inst_name, TRUE ); } if( child != NULL ) { param_resolve( child ); } gen_item_resolve( gi->next_true, child ); gen_item_resolve( gi->next_false, inst ); break; case GI_TYPE_BIND : varname = gen_item_calc_signal_name( gi->varname, inst->funit, gi->elem.expr->line, FALSE ); switch( gi->elem.expr->op ) { case EXP_OP_FUNC_CALL : bind_add( FUNIT_FUNCTION, varname, gi->elem.expr, inst->funit ); break; case EXP_OP_TASK_CALL : bind_add( FUNIT_TASK, varname, gi->elem.expr, inst->funit ); break; case EXP_OP_NB_CALL : bind_add( FUNIT_NAMED_BLOCK, varname, gi->elem.expr, inst->funit ); break; case EXP_OP_DISABLE : bind_add( 1, varname, gi->elem.expr, inst->funit ); break; default : bind_add( 0, varname, gi->elem.expr, inst->funit ); break; } gitem_link_add( gen_item_create_bind( varname, gi->elem.expr ), &(inst->gitem_head), &(inst->gitem_tail) ); free_safe( varname, (strlen( varname ) + 1) ); gen_item_resolve( gi->next_true, inst ); break; default : assert( (gi->suppl.part.type == GI_TYPE_EXPR) || (gi->suppl.part.type == GI_TYPE_SIG) || (gi->suppl.part.type == GI_TYPE_STMT) || (gi->suppl.part.type == GI_TYPE_INST) || (gi->suppl.part.type == GI_TYPE_TFN) || (gi->suppl.part.type == GI_TYPE_BIND) ); break; } } PROFILE_END; }

void gen_item_stringify (  gen_item *  gi, char *  str, unsigned int  str_len )  [static]

Creates a user-readable version of the specified generate item and stores it in the specified string. Parameters: gi  Pointer to generate item to stringify str  Pointer to string to store data into str_len  Number of available characters in the str string { PROFILE(GEN_ITEM_STRINGIFY); char* tmp; /* Temporary string */ assert( str_len > 0 ); if( gi != NULL ) { unsigned int rv; /* Allocate some memory in the tmp string */ tmp = (char*)malloc_safe_nolimit( str_len ); rv = snprintf( str, str_len, "%p, suppl: %x", gi, gi->suppl.all ); assert( rv < str_len ); switch( gi->suppl.part.type ) { case GI_TYPE_EXPR : rv = snprintf( tmp, str_len, ", EXPR, %s", expression_string( gi->elem.expr ) ); assert( rv < str_len ); break; case GI_TYPE_SIG : rv = snprintf( tmp, str_len, ", SIG, name: %s", obf_sig( gi->elem.sig->name ) ); assert( rv < str_len ); break; case GI_TYPE_STMT : rv = snprintf( tmp, str_len, ", STMT, id: %d, line: %d", gi->elem.stmt->exp->id, gi->elem.stmt->exp->line ); assert( rv < str_len ); break; case GI_TYPE_INST : rv = snprintf( tmp, str_len, ", INST, name: %s", obf_inst( gi->elem.inst->name ) ); assert( rv < str_len ); break; case GI_TYPE_TFN : rv = snprintf( tmp, str_len, ", TFN, name: %s, type: %s", obf_inst( gi->elem.inst->name ), get_funit_type( gi->elem.inst->funit->type ) ); assert( rv < str_len ); break; case GI_TYPE_BIND : rv = snprintf( tmp, str_len, ", BIND, %s", expression_string( gi->elem.expr ) ); assert( rv < str_len ); break; default : strcpy( tmp, "UNKNOWN!\n" ); break; } strcat( str, tmp ); rv = snprintf( tmp, str_len, ", next_true: %p, next_false: %p", gi->next_true, gi->next_false ); assert( rv < str_len ); strcat( str, tmp ); if( gi->varname != NULL ) { rv = snprintf( tmp, str_len, ", varname: %s", obf_sig( gi->varname ) ); assert( rv < str_len ); strcat( str, tmp ); } /* Deallocate the temporary string memory */ free_safe( tmp, str_len ); } else { str[0] = '\0'; } PROFILE_END; }

bool gen_item_varname_contains_genvar (  char *  name  )

Returns TRUE if the specified variable name contains a generate variable within it. Parameters: name  Variable name to check Returns: Returns TRUE if the specified variable name contains a generate variable within it; otherwise, returns FALSE. This function is called by db_create_expression() just before it places its signal name in the binding list. If the specified signal name contains a generate variable, we need to create a generate item binding element so that we can properly substitute the generate variable name with its current value. { PROFILE(GEN_ITEM_VARNAME_CONTAINS_GENVAR); bool retval = FALSE; /* Return value for this function */ char* pre; /* String prior to the generate variable */ char* genvar; /* Generate variable */ char* post; /* String after the generate variable */ char* tmpname; /* Copy of the given name */ /* Allocate memory */ tmpname = strdup_safe( name ); /* Find the first generate variable */ gen_item_get_genvar( tmpname, &pre, &genvar, &post ); if( genvar != NULL ) { retval = TRUE; } /* Deallocate memory */ free_safe( tmpname, (strlen( name ) + 1) ); return( retval ); }

bool generate_remove_stmt (  statement *  stmt  )

Removes the given generate statement from the correct instance. Returns: Returns TRUE if we found at least one match; otherwise, returns FALSE. Iterates through the entire instance tree finding and "removing" all statement generate items that match the given statement ID. This will get called by the stmt_blk_remove() function when a statement has been found that does not exist in a functional unit. Parameters: stmt  Statement to set "remove" bit on { PROFILE(GENERATE_REMOVE_STMT); bool retval = FALSE; /* Return value for this function */ inst_link* instl; /* Pointer to current instance list to parse */ /* Search for the generate item in the instance lists */ instl = db_list[curr_db]->inst_head; while( instl != NULL ) { retval |= generate_remove_stmt_helper( instl->inst, stmt ); instl = instl->next; } PROFILE_END; return( retval ); }

bool generate_remove_stmt_helper (  funit_inst *  root, statement *  stmt )  [static]

Returns: Returns TRUE if we found at least one match; otherwise, returns FALSE. Parameters: root  Pointer to root instance to traverse stmt  Pointer to statement to find and remove { PROFILE(GENERATE_REMOVE_STMT_HELPER); bool retval = FALSE; /* Return value for this function */ funit_inst* curr_child; /* Pointer to current child to search */ gitem_link* gil; /* Pointer to generate item link */ /* Remove the generate item from the current instance if it exists there */ gil = root->gitem_head; while( gil != NULL ) { if( (gil->gi->suppl.part.type == GI_TYPE_STMT) && (statement_find_statement( gil->gi->elem.stmt, stmt->exp->id ) != NULL) ) { gil->gi->suppl.part.removed = 1; retval = TRUE; } gil = gil->next; } /* Search child instances */ curr_child = root->child_head; while( curr_child != NULL ) { retval |= generate_remove_stmt_helper( curr_child, stmt ); curr_child = curr_child->next; } PROFILE_END; return( retval ); }

void generate_resolve (  funit_inst *  root  )

Resolves all generate items in the design. Exceptions: anonymous  generate_resolve gen_item_resolve Recursively resolves all generate items in the design. This is called at a specific point in the binding process. Parameters: root  Pointer to current instance in instance tree to resolve for { PROFILE(GENERATE_RESOLVE); funit_inst* curr_child; /* Pointer to current child to resolve for */ if( root != NULL ) { /* Resolve ourself */ if( root->funit != NULL ) { gitem_link* curr_gi = root->funit->gitem_head; while( curr_gi != NULL ) { gen_item_resolve( curr_gi->gi, root ); curr_gi = curr_gi->next; } } /* Resolve children */ curr_child = root->child_head; while( curr_child != NULL ) { generate_resolve( curr_child ); curr_child = curr_child->next; } } PROFILE_END; }

int parse_static_expr (  char *  str, func_unit *  funit, int  lineno, bool  no_genvars )

---

Variable Documentation

unsigned int curr_db

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

func_unit* curr_funit

Pointer to the functional unit structure for the functional unit that is currently being parsed.

int curr_sig_id

Signal ID that is used for identification purposes (each signal will receive a unique ID).

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.

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.

---