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

---

Detailed Description

Contains functions for handling functional unit instances.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/11/2002

#include "defines.h"

Go to the source code of this file.

Functions
funit_inst *	instance_create (func_unit *funit, char *inst_name, bool name_diff, bool ignore, bool gend_scope, vector_width *range)
	Creates a new instance with the given information.
void	instance_display_tree (funit_inst *root)
	Displays the current state of the instance tree.
void	instance_gen_scope (char *scope, funit_inst *leaf, bool flatten)
	Builds full hierarchy from leaf node to root.
funit_inst *	instance_find_scope (funit_inst *root, char *scope, bool rm_unnamed)
	Finds specified scope in functional unit instance tree.
funit_inst *	instance_find_by_funit (funit_inst *root, const func_unit *funit, int *ignore)
	Returns instance that points to specified functional unit for each instance.
vsignal *	instance_find_signal_by_exclusion_id (funit_inst *root, int id, func_unit **found_funit)
	Returns signal that matches the given exclusion ID.
expression *	instance_find_expression_by_exclusion_id (funit_inst *root, int id, func_unit **found_funit)
	Returns expression that matches the given exclusion ID.
int	instance_find_fsm_arc_index_by_exclusion_id (funit_inst *root, int id, fsm_table **found_fsm, func_unit **found_funit)
	Returns FSM that matches the given exclusion ID.
funit_inst *	instance_copy (funit_inst *from_inst, funit_inst *to_inst, char *name, vector_width *range, bool resolve)
	Copies the given from_inst as a child of the given to_inst.
bool	instance_parse_add (funit_inst **root, func_unit *parent, func_unit *child, char *inst_name, vector_width *range, bool resolve, bool child_gend, bool ignore_child, bool gend_scope)
	Adds new instance to specified instance tree during parse.
void	instance_resolve (funit_inst *root)
	Resolves all instance arrays.
bool	instance_read_add (funit_inst **root, char *parent, func_unit *child, char *inst_name)
	Adds new instance to specified instance tree during CDD read.
void	instance_get_leading_hierarchy (funit_inst *root, char *leading_hierarchy, funit_inst **top_inst)
	Gets the leading hierarchy scope and instance for a particular instance tree.
bool	instance_merge_two_trees (funit_inst *root1, funit_inst *root2)
	Performs complex instance tree merging for two instance trees.
void	instance_db_write (funit_inst *root, FILE *file, char *scope, bool parse_mode, bool issue_ids, bool report_save)
	Displays contents of functional unit instance tree to specified file.
void	instance_only_db_read (char **line)
	Reads in and handles an instance-only line from the database.
void	instance_only_db_merge (char **line)
	Reads in and merges an instance-only line from the database.
void	instance_remove_stmt_blks_calling_stmt (funit_inst *root, statement *stmt)
	Removes all statement blocks that contain expressions that call the given statement.
void	instance_remove_parms_with_expr (funit_inst *root, statement *stmt)
	Removes expressions from instance parameters within the given instance that match the given expression.
void	instance_output_dumpvars (FILE *vfile, funit_inst *root)
	Outputs dumpvars to the given file for the given instance.
void	instance_dealloc_tree (funit_inst *root)
	Recursively deallocates all memory for the associated instance tree.
void	instance_dealloc (funit_inst *root, char *scope)
	Removes specified instance from tree.

---

Function Documentation

funit_inst* instance_copy (  funit_inst *  from_inst, funit_inst *  to_inst, char *  name, vector_width *  range, bool  resolve )

Copies the given from_inst as a child of the given to_inst. Recursively copies the instance tree of from_inst to the instance to_inst, allocating memory for the new instances and resolving parameters. Parameters: from_inst  Pointer to instance tree to copy to_inst  Pointer to instance to copy tree to name  Instance name of current instance being copied range  For arrays of instances, indicates the array range resolve  Set to TRUE if newly added instance should be immediately resolved { PROFILE(INSTANCE_COPY); funit_inst* new_inst; new_inst = instance_copy_helper( from_inst, to_inst, name, range, resolve, TRUE ); PROFILE_END; return( new_inst ); }

funit_inst* instance_create (  func_unit *  funit, char *  inst_name, bool  name_diff, bool  ignore, bool  gend_scope, vector_width *  range )

Creates a new instance with the given information. Returns: Returns pointer to newly created functional unit instance. Creates a new functional unit instance from heap, initializes its data and returns a pointer to it. Parameters: funit  Pointer to functional unit to store in this instance inst_name  Instantiated name of this instance name_diff  Specifies if the inst_name provided is not accurate due to merging ignore  Specifies that this instance is just a placeholder, not to be written to CDD gend_scope  Specifies if this instance is a generated scope range  For arrays of instances, contains range information for this array { PROFILE(INSTANCE_CREATE); funit_inst* new_inst; /* Pointer to new functional unit instance */ new_inst = (funit_inst*)malloc_safe( sizeof( funit_inst ) ); new_inst->funit = funit; new_inst->name = strdup_safe( inst_name ); new_inst->suppl.name_diff = name_diff; new_inst->suppl.ignore = ignore; new_inst->suppl.gend_scope = gend_scope; new_inst->stat = NULL; new_inst->param_head = NULL; new_inst->param_tail = NULL; new_inst->gitem_head = NULL; new_inst->gitem_tail = NULL; new_inst->parent = NULL; new_inst->child_head = NULL; new_inst->child_tail = NULL; new_inst->next = NULL; /* Create range (get a copy since this memory is managed by the parser) */ if( range == NULL ) { new_inst->range = NULL; } else { assert( range->left != NULL ); assert( range->right != NULL ); new_inst->range = (vector_width*)malloc_safe( sizeof( vector_width ) ); new_inst->range->left = (static_expr*)malloc_safe( sizeof( static_expr ) ); new_inst->range->left->num = range->left->num; new_inst->range->left->exp = range->left->exp; new_inst->range->right = (static_expr*)malloc_safe( sizeof( static_expr ) ); new_inst->range->right->num = range->right->num; new_inst->range->right->exp = range->right->exp; } PROFILE_END; return( new_inst ); }

void instance_db_write (  funit_inst *  root, FILE *  file, char *  scope, bool  parse_mode, bool  issue_ids, bool  report_save )

Displays contents of functional unit instance tree to specified file. Exceptions: anonymous  gen_item_assign_expr_ids instance_db_write funit_db_write Calls each functional unit display function in instance tree, starting with the root functional unit and ending when all of the leaf functional units are output. Note: the function that calls this function originally should set the value of scope to NULL. Parameters: root  Root of functional unit instance tree to write file  Output file to display contents to scope  Scope of this functional unit parse_mode  Specifies if we are parsing or scoring issue_ids  Specifies that we need to issue expression and signal IDs report_save  Specifies if we are saving a CDD file after modifying it with the report command { PROFILE(INSTANCE_DB_WRITE); bool stop_recursive = FALSE; assert( root != NULL ); if( root->funit != NULL ) { if( (root->funit->type != FUNIT_NO_SCORE) && !root->suppl.ignore ) { funit_inst* curr = parse_mode ? root : NULL; assert( scope != NULL ); /* If we are in parse mode, re-issue expression IDs (we use the ulid field since it is not used in parse mode) */ if( issue_ids && (root->funit != NULL) ) { exp_link* expl; sig_link* sigl; #ifndef VPI_ONLY gitem_link* gil; #endif /* First issue IDs to the expressions within the functional unit */ expl = root->funit->exp_head; while( expl != NULL ) { expl->exp->ulid = curr_expr_id; curr_expr_id++; expl = expl->next; } sigl = root->funit->sig_head; while( sigl != NULL ) { sigl->sig->id = curr_sig_id; curr_sig_id++; sigl = sigl->next; } #ifndef VPI_ONLY /* Then issue IDs to any generated expressions/signals */ gil = root->gitem_head; while( gil != NULL ) { gen_item_assign_ids( gil->gi, root->funit ); gil = gil->next; } #endif } /* Display root functional unit */ funit_db_write( root->funit, scope, root->suppl.name_diff, file, curr, report_save, issue_ids ); } else { stop_recursive = TRUE; } } else { fprintf( file, "%d %s %d\n", DB_TYPE_INST_ONLY, scope, root->suppl.name_diff ); } if( !stop_recursive ) { char tscope[4096]; /* Display children */ funit_inst* curr = root->child_head; while( curr != NULL ) { unsigned int rv = snprintf( tscope, 4096, "%s.%s", scope, curr->name ); assert( rv < 4096 ); instance_db_write( curr, file, tscope, parse_mode, issue_ids, report_save ); curr = curr->next; } } PROFILE_END; }

void instance_dealloc (  funit_inst *  root, char *  scope )

Removes specified instance from tree. Searches tree for specified functional unit. If the functional unit instance is found, the functional unit instance is removed from the tree along with all of its child functional unit instances. Parameters: root  Root of functional unit instance tree scope  Scope of functional unit to remove from tree { PROFILE(INSTANCE_DEALLOC); funit_inst* inst; /* Pointer to instance to remove */ funit_inst* curr; /* Pointer to current child instance to remove */ funit_inst* last; /* Last current child instance */ char back[256]; /* Highest level of hierarchy in hierarchical reference */ char rest[4096]; /* Rest of scope value */ assert( root != NULL ); assert( scope != NULL ); if( scope_compare( root->name, scope ) ) { /* We are the root so just remove the whole tree */ instance_dealloc_tree( root ); } else { /* Find parent instance of given scope and remove this instance from its child list. */ scope_extract_back( scope, back, rest ); assert( rest[0] != '\0' ); inst = instance_find_scope( root, rest, TRUE ); assert( inst != NULL ); curr = inst->child_head; last = NULL; while( (curr != NULL) && !scope_compare( curr->name, scope ) ) { last = curr; curr = curr->next; } if( curr != NULL ) { if( last != NULL ) { last->next = curr->next; } if( curr == inst->child_head ) { /* Move parent head pointer */ inst->child_head = curr->next; } if( curr == inst->child_tail ) { /* Move parent tail pointer */ inst->child_tail = last; } } instance_dealloc_tree( curr ); } PROFILE_END; }

void instance_dealloc_tree (  funit_inst *  root  )

Recursively deallocates all memory for the associated instance tree. Recursively traverses instance tree, deallocating heap memory used to store the the tree. Parameters: root  Pointer to root instance of functional unit instance tree to remove { PROFILE(INSTANCE_DEALLOC_TREE); funit_inst* curr; /* Pointer to current instance to evaluate */ funit_inst* tmp; /* Temporary pointer to instance */ if( root != NULL ) { /* Remove instance's children first */ curr = root->child_head; while( curr != NULL ) { tmp = curr->next; instance_dealloc_tree( curr ); curr = tmp; } /* Deallocate the instance memory */ instance_dealloc_single( root ); } PROFILE_END; }

void instance_display_tree (  funit_inst *  root  )

Displays the current state of the instance tree. Displays the given instance tree to standard output in a hierarchical format. Shows instance names as well as associated module name. Parameters: root  Pointer to root instance to display { PROFILE(INSTANCE_DISPLAY_TREE); instance_display_tree_helper( root, "" ); PROFILE_END; }

funit_inst* instance_find_by_funit (  funit_inst *  root, const func_unit *  funit, int *  ignore )

Returns instance that points to specified functional unit for each instance. Returns: Returns pointer to functional unit instance found by scope. Searches the specified functional unit instance tree for the specified functional unit. When a functional unit instance is found that points to the specified functional unit and the ignore value is 0, a pointer to that functional unit instance is passed back to the calling function; otherwise, the ignore count is decremented and the searching continues. Parameters: root  Pointer to root functional unit instance of tree funit  Pointer to functional unit to find in tree ignore  Pointer to number of matches to ignore { PROFILE(INSTANCE_FIND_BY_FUNIT); funit_inst* match_inst = NULL; /* Pointer to functional unit instance that found a match */ funit_inst* curr_child; /* Pointer to current instances child functional unit instance */ if( root != NULL ) { if( root->funit == funit ) { if( *ignore == 0 ) { match_inst = root; } else { (*ignore)--; } } else { curr_child = root->child_head; while( (curr_child != NULL) && (match_inst == NULL) ) { match_inst = instance_find_by_funit( curr_child, funit, ignore ); curr_child = curr_child->next; } } } PROFILE_END; return( match_inst ); }

expression* instance_find_expression_by_exclusion_id (  funit_inst *  root, int  id, func_unit **  found_funit )

Returns expression that matches the given exclusion ID. Returns: Returns the pointer to the expression that contains the same exclusion ID. Recursively searches the given instance tree to find the expression that has the same exclusion ID as the one specified. Parameters: root  Pointer to root instance id  Exclusion ID to search for found_funit  Pointer to functional unit containing this expression { PROFILE(INSTANCE_FIND_EXPRESSION_BY_EXCLUSION_ID); expression* exp = NULL; /* Pointer to found expression */ if( root != NULL ) { assert( root->funit != NULL ); if( (root->funit->exp_head != NULL) && (root->funit->exp_head->exp->id <= id) && (root->funit->exp_tail->exp->id >= id) ) { exp_link* expl = root->funit->exp_head; while( (expl != NULL) && (expl->exp->id != id) ) { expl = expl->next; } assert( expl->exp != NULL ); exp = expl->exp; *found_funit = root->funit; } else { funit_inst* child = root->child_head; while( (child != NULL) && ((exp = instance_find_expression_by_exclusion_id( child, id, found_funit )) == NULL) ) { child = child->next; } } } PROFILE_END; return( exp ); }

int instance_find_fsm_arc_index_by_exclusion_id (  funit_inst *  root, int  id, fsm_table **  found_fsm, func_unit **  found_funit )

Returns FSM that matches the given exclusion ID. Returns: Returns the index of the state transition in the arcs array of the found_fsm in the found_funit that matches the given exclusion ID (if one is found); otherwise, returns -1. { PROFILE(INSTANCE_FIND_FSM_ARC_INDEX_BY_EXCLUSION_ID); int arc_index = -1; /* Index of found FSM arc */ if( root != NULL ) { fsm_link* fsml; assert( root->funit != NULL ); fsml = root->funit->fsm_head; while( (fsml != NULL) && ((arc_index = arc_find_arc_by_exclusion_id( fsml->table->table, id )) == -1) ) { fsml = fsml->next; } if( arc_index != -1 ) { *found_fsm = fsml->table->table; *found_funit = root->funit; } else { funit_inst* child = root->child_head; while( (child != NULL) && ((arc_index = instance_find_fsm_arc_index_by_exclusion_id( child, id, found_fsm, found_funit )) == -1) ) { child = child->next; } } } PROFILE_END; return( arc_index ); }

funit_inst* instance_find_scope (  funit_inst *  root, char *  scope, bool  rm_unnamed )

Finds specified scope in functional unit instance tree. Returns: Returns pointer to functional unit instance found by scope. Searches the specified functional unit instance tree for the specified scope. When the functional unit instance is found, a pointer to that functional unit instance is passed back to the calling function. Parameters: root  Root of funit_inst tree to parse for scope scope  Scope to search for rm_unnamed  Set to TRUE if we need to remove unnamed scopes { PROFILE(INSTANCE_FIND_SCOPE); char front[256]; /* Front of scope value */ char rest[4096]; /* Rest of scope value */ funit_inst* inst = NULL; /* Pointer to found instance */ funit_inst* child; /* Pointer to current child instance being traversed */ assert( root != NULL ); /* First extract the front scope */ scope_extract_front( scope, front, rest ); /* Skip this instance and move onto the children if we are an unnamed scope that does not contain signals */ if( !rm_unnamed && db_is_unnamed_scope( root->name ) && !funit_is_unnamed( root->funit ) ) { child = root->child_head; while( (child != NULL) && ((inst = instance_find_scope( child, scope, rm_unnamed )) == NULL) ) { child = child->next; } /* Keep traversing if our name matches */ } else if( instance_compare( front, root ) ) { if( rest[0] == '\0' ) { inst = root; } else { child = root->child_head; while( (child != NULL) && ((inst = instance_find_scope( child, rest, rm_unnamed )) == NULL) ) { child = child->next; } } } PROFILE_END; return( inst ); }

vsignal* instance_find_signal_by_exclusion_id (  funit_inst *  root, int  id, func_unit **  found_funit )

Returns signal that matches the given exclusion ID. Returns: Returns the pointer to the signal that contains the same exclusion ID. Recursively searches the given instance tree to find the signal that has the same exclusion ID as the one specified. Parameters: root  Pointer to root instance id  Exclusion ID to search for found_funit  Pointer to functional unit containing this signal { PROFILE(INSTANCE_FIND_SIGNAL_BY_EXCLUSION_ID); vsignal* sig = NULL; /* Pointer to found signal */ if( root != NULL ) { if( (root->funit != NULL) && (root->funit->sig_head != NULL) && (root->funit->sig_head->sig->id <= id) && (root->funit->sig_tail->sig->id >= id) ) { sig_link* sigl = root->funit->sig_head; while( (sigl != NULL) && (sigl->sig->id != id) ) { sigl = sigl->next; } assert( sigl->sig != NULL ); sig = sigl->sig; *found_funit = root->funit; } else { funit_inst* child = root->child_head; while( (child != NULL) && ((sig = instance_find_signal_by_exclusion_id( child, id, found_funit )) == NULL) ) { child = child->next; } } } PROFILE_END; return( sig ); }

void instance_gen_scope (  char *  scope, funit_inst *  leaf, bool  flatten )

Builds full hierarchy from leaf node to root. Recursively travels up to the root of the instance tree, building the scope string as it goes. When the root instance is reached, the string is returned. Assumes that scope is initialized to the NULL character. Parameters: scope  String pointer to store generated scope (assumed to be allocated) leaf  Pointer to leaf instance in scope flatten  Causes all unnamed scopes to be removed from generated scope if set to TRUE { PROFILE(INSTANCE_GEN_SCOPE); if( leaf != NULL ) { /* Call parent instance first */ instance_gen_scope( scope, leaf->parent, flatten ); if( !flatten || !db_is_unnamed_scope( leaf->name ) ) { if( scope[0] != '\0' ) { strcat( scope, "." ); strcat( scope, leaf->name ); } else { strcpy( scope, leaf->name ); } } } PROFILE_END; }

void instance_get_leading_hierarchy (  funit_inst *  root, char *  leading_hierarchy, funit_inst **  top_inst )

Gets the leading hierarchy scope and instance for a particular instance tree. Retrieves the leading hierarchy string and the pointer to the top-most populated instance given the specified instance tree. Note: This function requires that the leading_hierarchy string be previously allocated and initialized to the NULL string. Parameters: root  Pointer to instance tree to get information from leading_hierarchy  Leading hierarchy to first populated instance top_inst  Pointer to first populated instance { PROFILE(INSTANCE_GET_LEADING_HIERARCHY); if( leading_hierarchy != NULL ) { strcat( leading_hierarchy, root->name ); } *top_inst = root; if( root->funit == NULL ) { do { root = root->child_head; if( leading_hierarchy != NULL ) { strcat( leading_hierarchy, "." ); strcat( leading_hierarchy, root->name ); } *top_inst = root; } while( (root != NULL) && (root->funit == NULL) ); } PROFILE_END; }

bool instance_merge_two_trees (  funit_inst *  root1, funit_inst *  root2 )

Performs complex instance tree merging for two instance trees. Returns: Returns TRUE if the second instance tree should have its link removed from the instance tree list for the current database; otherwise, returns FALSE. Performs comples merges two instance trees into one instance tree. Parameters: root1  Pointer to first instance tree to merge root2  Pointer to second instance tree to merge { PROFILE(INSTANCE_MERGE_TWO_TREES); bool retval = TRUE; char lhier1[4096]; char lhier2[4096]; funit_inst* tinst1 = NULL; funit_inst* tinst2 = NULL; lhier1[0] = '\0'; lhier2[0] = '\0'; /* Get leading hierarchy information */ instance_get_leading_hierarchy( root1, lhier1, &tinst1 ); instance_get_leading_hierarchy( root2, lhier2, &tinst2 ); /* If the top-level modules are the same, just merge them */ if( (tinst1->funit != NULL) && (tinst2->funit != NULL) && (strcmp( tinst1->funit->name, tinst2->funit->name ) == 0) ) { if( strcmp( lhier1, lhier2 ) == 0 ) { bool rv = instance_merge_tree( tinst1, tinst2 ); assert( rv ); } else if( strcmp( root1->name, root2->name ) == 0 ) { bool rv = instance_merge_tree( root1, root2 ); assert( rv ); } else { bool rv = instance_merge_tree( tinst1, tinst2 ); assert( rv ); instance_mark_lhier_diffs( tinst1, tinst2 ); } /* If the two trees share the same root name, merge them */ } else if( (strcmp( root1->name, root2->name ) == 0) && instance_merge_tree( root1, root2 ) ) { /* We've already merged so we don't have anything else to do */ /* Check to see if the module pointed to by tinst1 exists within the tree of tinst2 */ } else if( (root2 = instance_find_by_funit_name_if_one( tinst2, tinst1->funit->name )) != NULL ) { bool rv = instance_merge_tree( tinst1, root2 ); assert( rv ); instance_mark_lhier_diffs( tinst1, root2 ); /* Check to see if the module pointed to by tinst2 exists within the tree of tinst1 */ } else if( (root1 = instance_find_by_funit_name_if_one( tinst1, tinst2->funit->name )) != NULL ) { bool rv = instance_merge_tree( root1, tinst2 ); assert( rv ); instance_mark_lhier_diffs( root1, tinst2 ); /* Otherwise, we cannot merge the two CDD files so don't */ } else { retval = FALSE; } PROFILE_END; return( retval ); }

void instance_only_db_merge (  char **  line  )

Reads in and merges an instance-only line from the database. Merges instance-only constructs from two CDD files. Parameters: line  Pointer to line being read from database file { PROFILE(INSTANCE_ONLY_DB_MERGE); char scope[4096]; int chars_read; bool name_diff; if( sscanf( *line, "%s %d%n", scope, &name_diff, &chars_read ) == 2 ) { char* back = strdup_safe( scope ); char* rest = strdup_safe( scope ); funit_inst* child; *line += chars_read; scope_extract_back( scope, back, rest ); /* Create "placeholder" instance */ child = instance_create( NULL, back, name_diff, FALSE, FALSE, NULL ); /* If we are the top-most instance, just add ourselves to the instance link list */ if( rest[0] == '\0' ) { /* Add a new instance link if was not able to be found in the instance linked list */ if( inst_link_find_by_scope( scope, db_list[curr_db]->inst_head ) == NULL ) { (void)inst_link_add( child, &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) ); } /* Otherwise, find our parent instance and attach the new instance to it */ } else { funit_inst* parent; if( (parent = inst_link_find_by_scope( rest, db_list[curr_db]->inst_head )) != NULL ) { if( parent->child_head == NULL ) { parent->child_head = parent->child_tail = child; } else { parent->child_tail->next = child; parent->child_tail = child; } child->parent = parent; } else { print_output( "Unable to find parent instance of instance-only line in database file.", FATAL, __FILE__, __LINE__ ); Throw 0; } } /* Deallocate memory */ free_safe( back, (strlen( scope ) + 1) ); free_safe( rest, (strlen( scope ) + 1) ); } else { print_output( "Unable to merge instance-only line in database file.", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void instance_only_db_read (  char **  line  )

Reads in and handles an instance-only line from the database. Parses an instance-only database line and adds a "placeholder" instance in the instance tree. Parameters: line  Pointer to line being read from database file { PROFILE(INSTANCE_ONLY_DB_READ); char scope[4096]; int chars_read; bool name_diff; if( sscanf( *line, "%s %d%n", scope, &name_diff, &chars_read ) == 2 ) { char* back = strdup_safe( scope ); char* rest = strdup_safe( scope ); funit_inst* child; *line += chars_read; scope_extract_back( scope, back, rest ); /* Create "placeholder" instance */ child = instance_create( NULL, back, name_diff, FALSE, FALSE, NULL ); /* If we are the top-most instance, just add ourselves to the instance link list */ if( rest[0] == '\0' ) { (void)inst_link_add( child, &(db_list[curr_db]->inst_head), &(db_list[curr_db]->inst_tail) ); /* Otherwise, find our parent instance and attach the new instance to it */ } else { funit_inst* parent; if( (parent = inst_link_find_by_scope( rest, db_list[curr_db]->inst_tail )) != NULL ) { if( parent->child_head == NULL ) { parent->child_head = parent->child_tail = child; } else { parent->child_tail->next = child; parent->child_tail = child; } child->parent = parent; } else { print_output( "Unable to find parent instance of instance-only line in database file.", FATAL, __FILE__, __LINE__ ); Throw 0; } } /* Deallocate memory */ free_safe( back, (strlen( scope ) + 1) ); free_safe( rest, (strlen( scope ) + 1) ); } else { print_output( "Unable to read instance-only line in database file.", FATAL, __FILE__, __LINE__ ); Throw 0; } PROFILE_END; }

void instance_output_dumpvars (  FILE *  vfile, funit_inst *  root )

Outputs dumpvars to the given file for the given instance. Outputs dumpvars to the specified file. Parameters: vfile  Pointer to file to output dumpvars to root  Pointer to current instance { PROFILE(INSTANCE_OUTPUT_DUMPVARS); funit_inst* child = root->child_head; char scope[4096]; /* Generate instance scope */ scope[0] = '\0'; instance_gen_scope( scope, root, FALSE ); /* Outputs dumpvars for the given functional unit */ funit_output_dumpvars( vfile, root->funit, scope ); /* Outputs all children instances */ while( child != NULL ) { instance_output_dumpvars( vfile, child ); child = child->next; } PROFILE_END; }

bool instance_parse_add (  funit_inst **  root, func_unit *  parent, func_unit *  child, char *  inst_name, vector_width *  range, bool  resolve, bool  child_gend, bool  ignore_child, bool  gend_scope )

Adds new instance to specified instance tree during parse. Returns: Returns TRUE if specified instance was successfully added to the specified instance tree; otherwise, returns FALSE. Adds the child functional unit to the child functional unit pointer list located in the functional unit specified by the scope of parent in the functional unit instance tree pointed to by root. This function is used by the db_add_instance function during the parsing stage. Parameters: root  Root funit_inst pointer of functional unit instance tree parent  Pointer to parent functional unit of specified child child  Pointer to child functional unit to add inst_name  Name of new functional unit instance range  For array of instances, specifies the name range resolve  If set to TRUE, resolve any added instance child_gend  If set to TRUE, specifies that child is a generated instance and should only be added once ignore_child  If set to TRUE, causes the child instance to be ignored when writing to CDD file gend_scope  If set to TRUE, the child instance is a generated scope { PROFILE(INSTANCE_PARSE_ADD); bool retval = TRUE; /* Return value for this function */ funit_inst* inst; /* Temporary pointer to functional unit instance to add to */ funit_inst* cinst; /* Pointer to instance of child functional unit */ int i; /* Loop iterator */ int ignore; /* Number of matched instances to ignore */ if( *root == NULL ) { *root = instance_create( child, inst_name, FALSE, ignore_child, gend_scope, range ); } else { assert( parent != NULL ); i = 0; ignore = 0; /* Check to see if the child functional unit has already been parsed and, if so, find one of its instances for copying the instance tree below it. */ cinst = instance_find_by_funit( *root, child, &ignore); /* Filename will be set to a value if the functional unit has been parsed */ if( (cinst != NULL) && (cinst->funit->filename != NULL) ) { ignore = 0; while( (ignore >= 0) && ((inst = instance_find_by_funit( *root, parent, &ignore )) != NULL) ) { (void)instance_copy( cinst, inst, inst_name, range, resolve ); i++; ignore = child_gend ? -1 : i; } } else { ignore = 0; while( (ignore >= 0) && ((inst = instance_find_by_funit( *root, parent, &ignore )) != NULL) ) { cinst = instance_add_child( inst, child, inst_name, range, resolve, ignore_child, gend_scope ); i++; ignore = (child_gend && (cinst != NULL)) ? -1 : i; } } /* Everything went well with the add if we found at least one parent instance */ retval = (i > 0); } PROFILE_END; return( retval ); }

bool instance_read_add (  funit_inst **  root, char *  parent, func_unit *  child, char *  inst_name )

Adds new instance to specified instance tree during CDD read. Returns: Returns TRUE if instance was added to the specified functional unit instance tree; otherwise, returns FALSE (indicates that the instance is from a different hierarchy). Adds the child functional unit to the child functional unit pointer list located in the functional unit specified by the scope of parent in the functional unit instance tree pointed to by root. This function is used by the db_read function during the CDD reading stage. Parameters: root  Pointer to root instance of functional unit instance tree parent  String scope of parent instance child  Pointer to child functional unit to add to specified parent's child list inst_name  Instance name of this child functional unit instance { PROFILE(INSTANCE_READ_ADD); bool retval = TRUE; /* Return value for this function */ funit_inst* inst; /* Temporary pointer to functional unit instance to add to */ funit_inst* new_inst; /* Pointer to new functional unit instance to add */ if( *root == NULL ) { *root = instance_create( child, inst_name, FALSE, FALSE, FALSE, NULL ); } else { assert( parent != NULL ); if( (inst = instance_find_scope( *root, parent, TRUE )) != NULL ) { /* Create new instance */ new_inst = instance_create( child, inst_name, FALSE, FALSE, FALSE, NULL ); if( inst->child_head == NULL ) { inst->child_head = new_inst; inst->child_tail = new_inst; } else { inst->child_tail->next = new_inst; inst->child_tail = new_inst; } /* Set parent pointer of new instance */ new_inst->parent = inst; } else { /* Unable to find parent of this child, needs to be added to a different instance tree */ retval = FALSE; } } PROFILE_END; return( retval ); }

void instance_remove_parms_with_expr (  funit_inst *  root, statement *  stmt )

Removes expressions from instance parameters within the given instance that match the given expression. Recursively traverses the given instance tree, removing the given statement. Parameters: root  Pointer to functional unit instance to remove expression from stmt  Pointer to statement to remove from list { PROFILE(INSTANCE_REMOVE_PARMS_WITH_EXPR); funit_inst* curr_child; /* Pointer to current child instance to traverse */ inst_parm* iparm; /* Pointer to current instance parameter */ exp_link* expl; /* Pointer to current expression link */ exp_link* texpl; /* Temporary pointer to current expression link */ /* Search for the given expression within the given instance parameter */ iparm = root->param_head; while( iparm != NULL ) { if( iparm->sig != NULL ) { expl = iparm->sig->exp_head; while( expl != NULL ) { texpl = expl; expl = expl->next; if( expression_find_expr( stmt->exp, texpl->exp ) ) { if( iparm->mparm != NULL ) { exp_link_remove( texpl->exp, &(iparm->mparm->exp_head), &(iparm->mparm->exp_tail), FALSE ); } exp_link_remove( texpl->exp, &(iparm->sig->exp_head), &(iparm->sig->exp_tail), FALSE ); } } } iparm = iparm->next; } /* Traverse children */ curr_child = root->child_head; while( curr_child != NULL ) { instance_remove_parms_with_expr( curr_child, stmt ); curr_child = curr_child->next; } PROFILE_END; }

void instance_remove_stmt_blks_calling_stmt (  funit_inst *  root, statement *  stmt )

Removes all statement blocks that contain expressions that call the given statement. Removes all statement blocks in the design that call that specified statement. Parameters: root  Pointer to root instance to remove statements from stmt  Pointer to statement to match { PROFILE(INSTANCE_REMOVE_STMT_BLKS_CALLING_STMT); funit_inst* curr_child; /* Pointer to current child instance to parse */ #ifndef VPI_ONLY gitem_link* gil; /* Pointer to current generate item link */ #endif if( root != NULL ) { /* First, handle the current functional unit */ funit_remove_stmt_blks_calling_stmt( root->funit, stmt ); #ifndef VPI_ONLY /* Second, handle all generate items in this instance */ gil = root->gitem_head; while( gil != NULL ) { gen_item_remove_if_contains_expr_calling_stmt( gil->gi, stmt ); gil = gil->next; } #endif /* Parse children */ curr_child = root->child_head; while( curr_child != NULL ) { instance_remove_stmt_blks_calling_stmt( curr_child, stmt ); curr_child = curr_child->next; } } PROFILE_END; }

void instance_resolve (  funit_inst *  root  )

Resolves all instance arrays. Recursively iterates through entire instance tree, resolving any instance arrays that are found. Parameters: root  Pointer to current functional unit instance to resolve { PROFILE(INSTANCE_RESOLVE); /* Resolve all instance names */ instance_resolve_helper( root, root ); PROFILE_END; }

---