instance.h File Reference

Contains functions for handling functional unit instances. More...

#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)
	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.

---

Detailed Description

Contains functions for handling functional unit instances.

Author:

Trevor Williams (phase1geo@gmail.com)

Date:

3/11/2002

---

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

References instance_copy_helper(), PROFILE, PROFILE_END, and TRUE.

Referenced by gen_item_resolve(), and instance_parse_add().

  { 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

References funit_inst_s::child_head, funit_inst_s::child_tail, static_expr_s::exp, funit_inst_s::funit, funit_inst_s::gend_scope, funit_inst_s::gitem_head, funit_inst_s::gitem_tail, funit_inst_s::ignore, vector_width_s::left, malloc_safe, funit_inst_s::name, funit_inst_s::name_diff, funit_inst_s::next, static_expr_s::num, funit_inst_s::param_head, funit_inst_s::param_tail, funit_inst_s::parent, PROFILE, PROFILE_END, funit_inst_s::range, vector_width_s::right, funit_inst_s::stat, strdup_safe, and funit_inst_s::suppl.

Referenced by db_add_instance(), db_read(), instance_add_child(), instance_only_db_merge(), instance_only_db_read(), instance_parse_add(), instance_read_add(), and search_init().

  { 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
	)

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

References funit_inst_s::child_head, curr_expr_id, curr_sig_id, DB_TYPE_INST_ONLY, exp_link_s::exp, func_unit_s::exp_head, FALSE, funit_inst_s::funit, funit_db_write(), FUNIT_NO_SCORE, gen_item_assign_ids(), gitem_link_s::gi, funit_inst_s::gitem_head, vsignal_s::id, funit_inst_s::ignore, instance_db_write(), funit_inst_s::name, funit_inst_s::name_diff, funit_inst_s::next, gitem_link_s::next, sig_link_s::next, exp_link_s::next, PROFILE, PROFILE_END, sig_link_s::sig, func_unit_s::sig_head, funit_inst_s::suppl, TRUE, func_unit_s::type, and expression_s::ulid.

Referenced by db_write(), and instance_db_write().

  { 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, issue_ids );

    } else {

      stop_recursive = TRUE;

    }

  } else {

    /*@-formatcode@*/
    fprintf( file, "%d %s %hhu\n", DB_TYPE_INST_ONLY, scope, root->suppl.name_diff );
    /*@=formatcode@*/

  }

  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 );
      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

References funit_inst_s::child_head, funit_inst_s::child_tail, instance_dealloc_tree(), instance_find_scope(), funit_inst_s::name, funit_inst_s::next, PROFILE, PROFILE_END, scope_compare(), scope_extract_back(), and TRUE.

Referenced by inst_link_delete_list().

  { 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

References funit_inst_s::child_head, instance_dealloc_single(), instance_dealloc_tree(), funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by gen_item_dealloc(), instance_dealloc(), and instance_dealloc_tree().

  { 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

References instance_display_tree_helper(), PROFILE, and PROFILE_END.

Referenced by inst_link_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

References funit_inst_s::child_head, funit_inst_s::funit, instance_find_by_funit(), funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by inst_link_find_by_funit(), instance_find_by_funit(), instance_parse_add(), and param_expr_eval().

  { 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

References funit_inst_s::child_head, exp_link_s::exp, func_unit_s::exp_head, func_unit_s::exp_tail, funit_inst_s::funit, expression_s::id, instance_find_expression_by_exclusion_id(), funit_inst_s::next, exp_link_s::next, PROFILE, and PROFILE_END.

Referenced by exclude_find_expression(), and instance_find_expression_by_exclusion_id().

  { PROFILE(INSTANCE_FIND_EXPRESSION_BY_EXCLUSION_ID); 
    
  expression* exp = NULL;  /* Pointer to found expression */
    
  if( root != NULL ) {

    if( (root->funit != NULL) &&
        (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 != NULL );
      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.

References arc_find_arc_by_exclusion_id(), funit_inst_s::child_head, func_unit_s::fsm_head, funit_inst_s::funit, instance_find_fsm_arc_index_by_exclusion_id(), funit_inst_s::next, fsm_link_s::next, PROFILE, PROFILE_END, fsm_s::table, and fsm_link_s::table.

Referenced by exclude_find_fsm_arc(), and instance_find_fsm_arc_index_by_exclusion_id().

  { PROFILE(INSTANCE_FIND_FSM_ARC_INDEX_BY_EXCLUSION_ID);

  int arc_index = -1;  /* Index of found FSM arc */

  if( root != NULL ) {

    fsm_link* fsml;

    if( 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

References funit_inst_s::child_head, db_is_unnamed_scope(), funit_inst_s::funit, funit_is_unnamed(), instance_compare(), instance_find_scope(), funit_inst_s::name, funit_inst_s::next, PROFILE, PROFILE_END, and scope_extract_front().

Referenced by gen_item_resolve(), inst_link_find_by_scope(), instance_dealloc(), instance_find_scope(), instance_read_add(), scope_find_funit_from_scope(), scope_get_parent_funit(), and scope_get_parent_module().

  { 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

References funit_inst_s::child_head, funit_inst_s::funit, vsignal_s::id, instance_find_signal_by_exclusion_id(), funit_inst_s::next, sig_link_s::next, PROFILE, PROFILE_END, sig_link_s::sig, func_unit_s::sig_head, and func_unit_s::sig_tail.

Referenced by exclude_find_signal(), and instance_find_signal_by_exclusion_id().

  { 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 != NULL );
      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

References db_is_unnamed_scope(), instance_gen_scope(), funit_inst_s::name, funit_inst_s::parent, PROFILE, and PROFILE_END.

Referenced by instance_gen_scope(), instance_output_dumpvars(), and param_has_defparam().

  { 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

References funit_inst_s::child_head, funit_inst_s::funit, funit_inst_s::name, PROFILE, and PROFILE_END.

Referenced by db_check_for_top_module(), and instance_merge_two_trees().

  { 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

References FALSE, funit_inst_s::funit, instance_find_by_funit_name_if_one(), instance_get_leading_hierarchy(), instance_mark_lhier_diffs(), instance_merge_tree(), funit_inst_s::name, func_unit_s::name, PROFILE, PROFILE_END, and TRUE.

Referenced by db_merge_instance_trees().

  { 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( (tinst1->funit != NULL) && ((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( (tinst2->funit != NULL) && ((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

References funit_inst_s::child_head, funit_inst_s::child_tail, curr_db, FALSE, FATAL, free_safe, inst_head, inst_link_add(), inst_link_find_by_scope(), db_s::inst_tail, instance_create(), funit_inst_s::next, funit_inst_s::parent, print_output(), PROFILE, PROFILE_END, scope_extract_back(), strdup_safe, and Throw.

Referenced by db_read().

  { PROFILE(INSTANCE_ONLY_DB_MERGE);

  char scope[4096];
  int  chars_read;
  bool name_diff;

  if( sscanf( *line, "%s %d%n", scope, (int*)&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

References funit_inst_s::child_head, funit_inst_s::child_tail, curr_db, FALSE, FATAL, free_safe, inst_head, inst_link_add(), inst_link_find_by_scope(), db_s::inst_tail, instance_create(), funit_inst_s::next, funit_inst_s::parent, print_output(), PROFILE, PROFILE_END, scope_extract_back(), strdup_safe, and Throw.

Referenced by db_read().

  { PROFILE(INSTANCE_ONLY_DB_READ);

  char  scope[4096];
  int   chars_read;
  bool  name_diff;

  if( sscanf( *line, "%s %d%n", scope, (int*)&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

References funit_inst_s::child_head, FALSE, funit_inst_s::funit, funit_output_dumpvars(), instance_gen_scope(), instance_output_dumpvars(), funit_inst_s::next, PROFILE, and PROFILE_END.

Referenced by db_output_dumpvars(), and instance_output_dumpvars().

  { 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

References FALSE, func_unit_s::filename, funit_inst_s::funit, instance_add_child(), instance_copy(), instance_create(), instance_find_by_funit(), PROFILE, PROFILE_END, and TRUE.

Referenced by db_add_instance(), gen_item_resolve(), and instance_resolve_inst().

  { 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

References funit_inst_s::child_head, funit_inst_s::child_tail, FALSE, instance_create(), instance_find_scope(), funit_inst_s::next, funit_inst_s::parent, PROFILE, PROFILE_END, and TRUE.

Referenced by db_read().

  { 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

References funit_inst_s::child_head, exp_link_s::exp, statement_s::exp, mod_parm_s::exp_head, vsignal_s::exp_head, exp_link_remove(), vsignal_s::exp_tail, mod_parm_s::exp_tail, expression_find_expr(), FALSE, instance_remove_parms_with_expr(), inst_parm_s::mparm, funit_inst_s::next, inst_parm_s::next, exp_link_s::next, funit_inst_s::param_head, PROFILE, PROFILE_END, and inst_parm_s::sig.

Referenced by db_remove_statement_from_current_funit(), and instance_remove_parms_with_expr().

  { 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

References funit_inst_s::child_head, funit_inst_s::funit, funit_remove_stmt_blks_calling_stmt(), gen_item_remove_if_contains_expr_calling_stmt(), gitem_link_s::gi, funit_inst_s::gitem_head, instance_remove_stmt_blks_calling_stmt(), funit_inst_s::next, gitem_link_s::next, PROFILE, and PROFILE_END.

Referenced by db_remove_stmt_blks_calling_statement(), and instance_remove_stmt_blks_calling_stmt().

  { 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

References instance_resolve_helper(), PROFILE, and PROFILE_END.

Referenced by bind_perform().

  { PROFILE(INSTANCE_RESOLVE);

  /* Resolve all instance names */
  instance_resolve_helper( root, root );

  PROFILE_END;

}