netlist_check.c File Reference

#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include "types.h"
#include "globals.h"
#include "errors.h"
#include "netlist_utils.h"
#include "odin_util.h"
#include "ast_util.h"
#include "string_cache.h"
#include "util.h"
#include "netlist_check.h"
#include "netlist_visualizer.h"

Include dependency graph for netlist_check.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	levelize_backwards (netlist_t *netlist)
void	levelize_backwards_clean_checking_for_liveness (short ast_based, netlist_t *netlist)
void	levelize_forwards (netlist_t *netlist)
void	levelize_forwards_clean_checking_for_combo_loop_and_liveness (short ast_based, netlist_t *netlist)
nnode_t *	find_node_at_top_of_combo_loop (nnode_t *start_node)
void	depth_first_traversal_check_if_forward_leveled (short marker_value, netlist_t *netlist)
void	depth_first_traverse_check_if_forward_leveled (nnode_t *node, int traverse_mark_number)
void	sequential_levelized_dfs (short marker_value, netlist_t *netlist)
void	depth_first_traverse_until_next_ff_or_output (nnode_t *node, nnode_t *calling_node, int traverse_mark_number, int seq_level, netlist_t *netlist)
void	check_netlist (netlist_t *netlist)
void	depth_traverse_check_combinational_loop (nnode_t *node, short start, STRING_CACHE *in_path)
void	levelize_and_check_for_combinational_loop_and_liveness (short ast_based, netlist_t *netlist)

---

Function Documentation

void check_netlist

(

netlist_t *

netlist

)

Definition at line 53 of file netlist_check.c.

{
        /* create a graph output of this netlist */
        if (configuration.output_netlist_graphs == 1)
        {
                /* Path is where we are */
                graphVizOutputNetlist(configuration.debug_output_path, "net", 1, netlist);
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void depth_first_traversal_check_if_forward_leveled	(	short	marker_value,
		netlist_t *	netlist
	)

Definition at line 244 of file netlist_check.c.

{
        int i;

        /* start with the primary input list */
        for (i = 0; i < netlist->num_top_input_nodes; i++)
        {
                if (netlist->top_input_nodes[i] != NULL)
                {
                        depth_first_traverse_check_if_forward_leveled(netlist->top_input_nodes[i], marker_value);
                }
        }
        /* now traverse the ground and vcc pins */
        if (netlist->gnd_node != NULL)
                depth_first_traverse_check_if_forward_leveled(netlist->gnd_node, marker_value);
        if (netlist->vcc_node != NULL)
                depth_first_traverse_check_if_forward_leveled(netlist->vcc_node, marker_value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void depth_first_traverse_check_if_forward_leveled	(	nnode_t *	node,
		int	traverse_mark_number
	)

Definition at line 266 of file netlist_check.c.

{
        int i, j;
        nnode_t *next_node;
        nnet_t *next_net;

        if (node->traverse_visited == traverse_mark_number)
        {
                return;
        }
        else
        {
                /* ELSE - this is a new node so depth visit it */

                /* mark that we have visitied this node now */
                node->traverse_visited = traverse_mark_number;
                
                for (i = 0; i < node->num_output_pins; i++)
                {
                        if (node->output_pins[i]->net == NULL)
                                continue;

                        next_net = node->output_pins[i]->net;
                        for (j = 0; j < next_net->num_fanout_pins; j++)
                        {
                                if (next_net->fanout_pins[j] == NULL)
                                        continue;

                                next_node = next_net->fanout_pins[j]->node;
                                if (next_node == NULL)
                                        continue;

                                if ((next_node->forward_level == -1) && (next_node->type != FF_NODE))
                                {
                                        graphVizOutputCombinationalNet(configuration.debug_output_path, "combo_loop", COMBO_LOOP_ERROR, /*next_node);*/ find_node_at_top_of_combo_loop(next_node));
                                        oassert(FALSE);
                                }

                                /* recursive call point */
                                depth_first_traverse_check_if_forward_leveled(next_node, traverse_mark_number);
                        }
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void depth_first_traverse_until_next_ff_or_output	(	nnode_t *	node,
		nnode_t *	calling_node,
		int	traverse_mark_number,
		int	seq_level,
		netlist_t *	netlist
	)

Definition at line 166 of file netlist_check.c.

{
        int i, j;
        nnode_t *next_node;
        nnet_t *next_net;

        /* first, check if the clalling node should be recorderd */
        if ((calling_node != NULL) && ((node->type == FF_NODE) || (node->type == OUTPUT_NODE)))
        {
                /* IF - the this node is the end of a sequential level then the node before needs to be stored */
                if (calling_node->sequential_terminator == FALSE)
                {
                        /* IF - it hasn't been stored before */
                        netlist->num_at_sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1] ++;
                        netlist->sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1] = (nnode_t**)realloc(netlist->sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1],sizeof(nnode_t*)*netlist->num_at_sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1]);
                        netlist->sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1][netlist->num_at_sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1]-1] = calling_node;
                        /* mark the node locally */
                        calling_node->sequential_terminator = TRUE;
                }
        }

        if (node->traverse_visited == traverse_mark_number)
        {
                /* if already visited then nothing to do */
                return;
        }
        else if (node->type == CLOCK_NODE)
        {
                /* since this is a node that touches all flip flops, don't analyze for sequential level */
                return;
        }
        else if (node->type == FF_NODE)
        {
                /* ELSE IF - this is a ff_node, so add it to the list for the next sequential level */
                /* mark as traversed */
                node->traverse_visited = traverse_mark_number;
                node->sequential_level = seq_level+1;

                /* add to the next sequntial list */
                netlist->num_at_sequential_level[seq_level+1]++;
                netlist->sequential_level_nodes[seq_level+1] = (nnode_t**)realloc(netlist->sequential_level_nodes[seq_level+1], sizeof(nnode_t*)*netlist->num_at_sequential_level[seq_level+1]);
                netlist->sequential_level_nodes[seq_level+1][netlist->num_at_sequential_level[seq_level+1]-1] = node;

                return;
        }
        else
        {
                /* ELSE - this is a node so depth visit it */

                /* mark that we have visitied this node now */
                node->traverse_visited = traverse_mark_number;
                node->sequential_level = seq_level;
                
                for (i = 0; i < node->num_output_pins; i++)
                {
                        if (node->output_pins[i]->net == NULL)
                                continue;

                        next_net = node->output_pins[i]->net;
                        for (j = 0; j < next_net->num_fanout_pins; j++)
                        {
                                if (next_net->fanout_pins[j] == NULL)
                                        continue;

                                next_node = next_net->fanout_pins[j]->node;
                                if (next_node == NULL)
                                        continue;

                                /* recursive call point */
                                depth_first_traverse_until_next_ff_or_output(next_node, node, traverse_mark_number, seq_level, netlist);
                        }
                }
        }
}

Here is the caller graph for this function:

void depth_traverse_check_combinational_loop	(	nnode_t *	node,
		short	start,
		STRING_CACHE *	in_path
	)

nnode_t * find_node_at_top_of_combo_loop

(

nnode_t *

start_node

)

Definition at line 795 of file netlist_check.c.

{
        int i;
        int idx_missed;
        nnode_t *next_node = start_node;
        int *fanouts_visited;
        short all_visited;

        while(TRUE)
        {
                oassert(next_node->unique_node_data_id == LEVELIZE);
                fanouts_visited = (int*)next_node->node_data;
                next_node->node_data = NULL;
        
                /* check if they've all been marked */
                all_visited = TRUE;
                for (i = 0; i < next_node->num_input_pins; i++)
                {
                        if (fanouts_visited[i] == -1)
                        {       
                                all_visited = FALSE;
                                idx_missed = i;
                                break;
                        }
                }
        
                if (all_visited == FALSE)
                {
                        if (next_node->input_pins[idx_missed]->net->driver_pin->node->backward_level < next_node->backward_level)
                                /* IF - the next node has a lower backward level than this node suggests that it is 
                                   closer to primary outputs and not in the combo loop */
                                return next_node;

                        next_node = next_node->input_pins[idx_missed]->net->driver_pin->node;
                }
                else
                {
                        return next_node;
                }
        }
}

Here is the caller graph for this function:

void levelize_and_check_for_combinational_loop_and_liveness	(	short	ast_based,
		netlist_t *	netlist
	)

Definition at line 67 of file netlist_check.c.

{
        /* go from the POs backwards and mark level */
        levelize_backwards(netlist);
        /* Since the net_data (void pointer) is used to record information, we need to clean this up so that it can be used again
           also, during this cleaning we check if nodes are live based on all the fanout pins have been visited */
        levelize_backwards_clean_checking_for_liveness(ast_based, netlist);

        /* do a forward analysis */
        levelize_forwards(netlist);

        /* checks if there are any non-forward marked nodes */
        depth_first_traversal_check_if_forward_leveled(COMBO_LOOP, netlist);
        /* finds combo loops, but usually killed by previous.  Also cleans out net_data (void pointer) for next algorithm. */
        levelize_forwards_clean_checking_for_combo_loop_and_liveness(ast_based, netlist);

        /* assign each node which sequential level it is in, and keep the primary inputs to that level */
        sequential_levelized_dfs(SEQUENTIAL_LEVELIZE, netlist);
}

Here is the call graph for this function:

Here is the caller graph for this function:

void levelize_backwards

(

netlist_t *

netlist

)

Definition at line 579 of file netlist_check.c.

{
        int i, j, k;
        int cur_back_level;
        short more_levels = TRUE;
        short all_visited = TRUE;

        /* add all the POs and FFs POs as backward level 0 */
        cur_back_level = 0;
        netlist->num_backward_levels = 1;
        netlist->num_at_backward_level = (int*)realloc(netlist->num_at_backward_level, sizeof(int)*netlist->num_backward_levels);
        netlist->backward_levels = (nnode_t***)realloc(netlist->backward_levels, sizeof(nnode_t**)*(netlist->num_backward_levels));
        netlist->backward_levels[netlist->num_backward_levels-1] = NULL;
        netlist->num_at_backward_level[netlist->num_backward_levels-1] = 0;
        for (i = 0; i < netlist->num_top_output_nodes; i++)
        {
                if (netlist->top_output_nodes[i] != NULL)
                {
                        netlist->backward_levels[cur_back_level] = (nnode_t**)realloc(netlist->backward_levels[cur_back_level], sizeof(nnode_t*)*(netlist->num_at_backward_level[cur_back_level]+1));
                        netlist->backward_levels[cur_back_level][netlist->num_at_backward_level[cur_back_level]] = netlist->top_output_nodes[i];
                        netlist->num_at_backward_level[cur_back_level]++;
                        netlist->top_output_nodes[i]->backward_level = 0;
                }
        }
        for (i = 0; i < netlist->num_ff_nodes; i++)
        {
                if (netlist->ff_nodes[i] != NULL)
                {
                        netlist->backward_levels[cur_back_level] = (nnode_t**)realloc(netlist->backward_levels[cur_back_level], sizeof(nnode_t*)*(netlist->num_at_backward_level[cur_back_level]+1));
                        netlist->backward_levels[cur_back_level][netlist->num_at_backward_level[cur_back_level]] = netlist->ff_nodes[i];
                        netlist->num_at_backward_level[cur_back_level]++;
                        netlist->ff_nodes[i]->backward_level = 0;
                }
        }

        while(more_levels)
        {
                /* another level so add space */
                netlist->num_backward_levels ++;
                netlist->num_at_backward_level = (int*)realloc(netlist->num_at_backward_level, sizeof(int)*netlist->num_backward_levels);
                netlist->backward_levels = (nnode_t***)realloc(netlist->backward_levels, sizeof(nnode_t**)*(netlist->num_backward_levels));
                netlist->backward_levels[netlist->num_backward_levels-1] = NULL;
                netlist->num_at_backward_level[netlist->num_backward_levels-1] = 0;

                /* go through each element at this level */
                for (i = 0; i < netlist->num_at_backward_level[cur_back_level]; i++)
                {
                        nnode_t *current_node = netlist->backward_levels[cur_back_level][i];
                        if (current_node == NULL)
                                continue;

                        /* at each node visit all the inputs */
                        for (j = 0; j < current_node->num_input_pins; j++)
                        {
                                int *fanouts_visited;
                                if (current_node->input_pins[j] == NULL)
                                        continue; 

                                /* visit the fanout point */
                                nnet_t *fanout_net = current_node->input_pins[j]->net;

                                if (fanout_net->net_data == NULL)
                                {
                                        int idx;
                                        /* if this fanout hasn't been visited yet this will be null */
                                        fanouts_visited = (int*)malloc(sizeof(int)*(fanout_net->num_fanout_pins));
                                        
                                        for (idx = 0; idx < fanout_net->num_fanout_pins; idx++)
                                        {
                                                fanouts_visited[idx] = -1;
                                        }
                                        
                                        fanout_net->net_data = (void*)fanouts_visited;
                                        fanout_net->unique_net_data_id = LEVELIZE;
                                }
                                else 
                                {
                                        /* ELSE - get the list */
                                        fanouts_visited = (int*)fanout_net->net_data;
                                        oassert(fanout_net->unique_net_data_id == LEVELIZE);
                                }

                                /* mark this entry as visited */
                                if(fanout_net->driver_pin != NULL)
                                {
                                        fanouts_visited[current_node->input_pins[j]->pin_net_idx] = cur_back_level;
                                }

                                /* check if they've all been marked */
                                all_visited = TRUE;
                                for (k = 0; k < fanout_net->num_fanout_pins; k++)
                                {
                                        if ((fanout_net->fanout_pins[k] != NULL) && (fanout_net->fanout_pins[k]->node != NULL) && (fanouts_visited[k] == -1))
                                        {       
                                                all_visited = FALSE;
                                                break;
                                        }
                                }

                                if ((all_visited == TRUE) && (fanout_net->driver_pin->node->type != FF_NODE))
                                {
                                        /* This one has been visited by everyone */
                                        if (fanout_net->driver_pin->node->backward_level == -1)
                                        {
                                                /* already added to a list...this means that we won't have the correct ordering */
                                                netlist->backward_levels[cur_back_level+1] = (nnode_t**)realloc(netlist->backward_levels[cur_back_level+1], sizeof(nnode_t*)*(netlist->num_at_backward_level[cur_back_level+1]+1));
                                                netlist->backward_levels[cur_back_level+1][netlist->num_at_backward_level[cur_back_level+1]] = fanout_net->driver_pin->node;
                                                netlist->num_at_backward_level[cur_back_level+1]++;
                                        }

                                        fanout_net->driver_pin->node->backward_level = cur_back_level+1;
                                }
                        }
                }

                /* check if tere are more elements to procees at the next level */
                if (netlist->num_at_backward_level[cur_back_level+1] > 0)
                {
                        /* there are elements in the next set then process */
                        cur_back_level++;
                }
                else
                {
                        /* ELSE - we've levelized backwards */
                        more_levels = FALSE;
                }
        }
}

Here is the caller graph for this function:

void levelize_backwards_clean_checking_for_liveness	(	short	ast_based,
		netlist_t *	netlist
	)

Definition at line 711 of file netlist_check.c.

{
        int i, j, k;
        int cur_back_level;
        short more_levels = TRUE;
        short all_visited = TRUE;

        cur_back_level = 0;

        while(more_levels)
        {
                /* go through each element at this level */
                for (i = 0; i < netlist->num_at_backward_level[cur_back_level]; i++)
                {
                        nnode_t *current_node = netlist->backward_levels[cur_back_level][i];
                        if (current_node == NULL)
                                continue;

                        /* at each node visit all the inputs */
                        for (j = 0; j < current_node->num_input_pins; j++)
                        {
                                int *fanouts_visited;
                                if (current_node->input_pins[j] == NULL)
                                        continue; 

                                /* visit the fanout point */
                                nnet_t *fanout_net = current_node->input_pins[j]->net;

                                if (fanout_net->net_data == NULL)
                                {
                                        /* IF - already cleaned */
                                        oassert(fanout_net->unique_net_data_id == -1);
                                }
                                else 
                                {
                                        /* ELSE - get the list */
                                        oassert(fanout_net->unique_net_data_id == LEVELIZE);
                                        fanouts_visited = (int*)fanout_net->net_data;
                                        fanout_net->net_data = NULL;

                                        /* check if they've all been marked */
                                        all_visited = TRUE;
                                        for (k = 0; k < fanout_net->num_fanout_pins; k++)
                                        {
                                                if ((fanout_net->fanout_pins[k] != NULL) && (fanout_net->fanout_pins[k]->node != NULL) && (fanouts_visited[k] == -1))
                                                {       
                                                        all_visited = FALSE;
                                                        break;
                                                }
                                        }

                                        if (all_visited == FALSE)
                                        {
                                                /* one of these nodes was not visited on the backward analysis */
                                                if (ast_based)
                                                        warning_message(NETLIST_ERROR, current_node->related_ast_node->line_number, current_node->related_ast_node->file_number, "Liveness check on backward pass.  Node %s is missing a driving pin idx %d\n", current_node->name, k);
                                                else
                                                        warning_message(NETLIST_ERROR, -1, -1, "Liveness check on backward pass.  Node %s is missing a driving pin idx %d\n", current_node->name, k);
                                        }

                                        /* free the data and reset to be used elsewhere */
                                        free(fanouts_visited);
                                        fanout_net->unique_net_data_id = -1;
                                }
                        }
                }

                /* check if tere are more elements to procees at the next level */
                if (netlist->num_at_backward_level[cur_back_level+1] > 0)
                {
                        /* there are elements in the next set then process */
                        cur_back_level++;
                }
                else
                {
                        /* ELSE - we've levelized backwards */
                        more_levels = FALSE;
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void levelize_forwards

(

netlist_t *

netlist

)

Definition at line 315 of file netlist_check.c.

{
        int i, j, k;
        int cur_for_level;
        short more_levels = TRUE;
        short all_visited = TRUE;

        /* add all the POs and FFs POs as forward level 0 */
        cur_for_level = 0;
        netlist->num_forward_levels = 1;
        netlist->num_at_forward_level = (int*)realloc(netlist->num_at_forward_level, sizeof(int)*netlist->num_forward_levels);
        netlist->forward_levels = (nnode_t***)realloc(netlist->forward_levels, sizeof(nnode_t**)*(netlist->num_forward_levels));
        netlist->forward_levels[netlist->num_forward_levels-1] = NULL;
        netlist->num_at_forward_level[netlist->num_forward_levels-1] = 0;
        for (i = 0; i < netlist->num_top_input_nodes+3; i++)
        {
                if ((i == netlist->num_top_input_nodes) && (netlist->vcc_node != NULL))
                {
                        /* vcc */
                        netlist->forward_levels[cur_for_level] = (nnode_t**)realloc(netlist->forward_levels[cur_for_level], sizeof(nnode_t*)*(netlist->num_at_forward_level[cur_for_level]+1));
                        netlist->forward_levels[cur_for_level][netlist->num_at_forward_level[cur_for_level]] = netlist->vcc_node;
                        netlist->num_at_forward_level[cur_for_level]++;
                        netlist->vcc_node->forward_level = 0;
                }
                else if ((i == netlist->num_top_input_nodes+1) && (netlist->gnd_node != NULL))
                {
                        /* gnd */
                        netlist->forward_levels[cur_for_level] = (nnode_t**)realloc(netlist->forward_levels[cur_for_level], sizeof(nnode_t*)*(netlist->num_at_forward_level[cur_for_level]+1));
                        netlist->forward_levels[cur_for_level][netlist->num_at_forward_level[cur_for_level]] = netlist->gnd_node;
                        netlist->num_at_forward_level[cur_for_level]++;
                        netlist->gnd_node->forward_level = 0;
                }
                else if ((i == netlist->num_top_input_nodes+2) && (netlist->pad_node != NULL))
                {
                        /* pad */
                        netlist->forward_levels[cur_for_level] = (nnode_t**)realloc(netlist->forward_levels[cur_for_level], sizeof(nnode_t*)*(netlist->num_at_forward_level[cur_for_level]+1));
                        netlist->forward_levels[cur_for_level][netlist->num_at_forward_level[cur_for_level]] = netlist->pad_node;
                        netlist->num_at_forward_level[cur_for_level]++;
                        netlist->pad_node->forward_level = 0;
                }
                else if (i >= netlist->num_top_input_nodes)
                {
                        continue;
                }
                else if (netlist->top_input_nodes[i] != NULL)
                {
                        netlist->forward_levels[cur_for_level] = (nnode_t**)realloc(netlist->forward_levels[cur_for_level], sizeof(nnode_t*)*(netlist->num_at_forward_level[cur_for_level]+1));
                        netlist->forward_levels[cur_for_level][netlist->num_at_forward_level[cur_for_level]] = netlist->top_input_nodes[i];
                        netlist->num_at_forward_level[cur_for_level]++;
                        netlist->top_input_nodes[i]->forward_level = 0;
                }
        }
        for (i = 0; i < netlist->num_ff_nodes; i++)
        {
                if (netlist->ff_nodes[i] != NULL)
                {
                        netlist->forward_levels[cur_for_level] = (nnode_t**)realloc(netlist->forward_levels[cur_for_level], sizeof(nnode_t*)*(netlist->num_at_forward_level[cur_for_level]+1));
                        netlist->forward_levels[cur_for_level][netlist->num_at_forward_level[cur_for_level]] = netlist->ff_nodes[i];
                        netlist->num_at_forward_level[cur_for_level]++;
                        netlist->ff_nodes[i]->forward_level = 0;
                }
        }

        while(more_levels)
        {
                /* another level so add space */
                netlist->num_forward_levels ++;
                netlist->num_at_forward_level = (int*)realloc(netlist->num_at_forward_level, sizeof(int)*netlist->num_forward_levels);
                netlist->forward_levels = (nnode_t***)realloc(netlist->forward_levels, sizeof(nnode_t**)*(netlist->num_forward_levels));
                netlist->forward_levels[netlist->num_forward_levels-1] = NULL;
                netlist->num_at_forward_level[netlist->num_forward_levels-1] = 0;

                /* go through each element at this level */
                for (i = 0; i < netlist->num_at_forward_level[cur_for_level]; i++)
                {
                        nnode_t *current_node = netlist->forward_levels[cur_for_level][i];
                        if (current_node == NULL)
                                continue;

                        /* at each node visit all the inputs */
                        for (j = 0; j < current_node->num_output_pins; j++)
                        {
                                int *fanouts_visited;
                                if (current_node->output_pins[j] == NULL)
                                        continue; 

                                for (k = 0; k < current_node->output_pins[j]->net->num_fanout_pins; k++)
                                {
                                        int idx;
                                        /* visit the fanout point */
                                        if ((current_node->output_pins[j] == NULL) || (current_node->output_pins[j]->net == NULL) || ( current_node->output_pins[j]->net->fanout_pins[k] == NULL))
                                                continue;

                                        nnode_t *output_node = current_node->output_pins[j]->net->fanout_pins[k]->node;

                                        if (output_node == NULL)
                                                continue;
        
                                        if (output_node->node_data == NULL)
                                        {
                                                /* if this fanout hasn't been visited yet this will be null */
                                                fanouts_visited = (int*)malloc(sizeof(int)*(output_node->num_input_pins));
                                                
                                                for (idx = 0; idx < output_node->num_input_pins; idx++)
                                                {
                                                        fanouts_visited[idx] = -1;
                                                }
                                                
                                                output_node->node_data = (void*)fanouts_visited;
                                                output_node->unique_node_data_id = LEVELIZE;
                                        }
                                        else 
                                        {
                                                /* ELSE - get the list */
                                                oassert(output_node->unique_node_data_id == LEVELIZE);
                                                fanouts_visited = (int*)output_node->node_data;
                                        }
        
                                        /* mark this entry as visited */
                                        fanouts_visited[current_node->output_pins[j]->net->fanout_pins[k]->pin_node_idx] = cur_for_level;
        
                                        /* check if they've all been marked */
                                        all_visited = TRUE;
                                        for (idx = 0; idx < output_node->num_input_pins; idx++)
                                        {
                                                if (fanouts_visited[idx] == -1)
                                                {       
                                                        all_visited = FALSE;
                                                        break;
                                                }
                                        }
        
                                        if ((all_visited == TRUE) && (output_node->type != FF_NODE))
                                        {
                                                /* This one has been visited by everyone */
                                                netlist->forward_levels[cur_for_level+1] = (nnode_t**)realloc(netlist->forward_levels[cur_for_level+1], sizeof(nnode_t*)*(netlist->num_at_forward_level[cur_for_level+1]+1));
                                                netlist->forward_levels[cur_for_level+1][netlist->num_at_forward_level[cur_for_level+1]] = output_node;
                                                netlist->num_at_forward_level[cur_for_level+1]++;
        
                                                output_node->forward_level = cur_for_level+1;
                                        }
                                }
                        }
                }

                /* check if tere are more elements to procees at the next level */
                if (netlist->num_at_forward_level[cur_for_level+1] > 0)
                {
                        /* there are elements in the next set then process */
                        cur_for_level++;
                }
                else
                {
                        /* ELSE - we've levelized forwards */
                        more_levels = FALSE;
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void levelize_forwards_clean_checking_for_combo_loop_and_liveness	(	short	ast_based,
		netlist_t *	netlist
	)

Definition at line 476 of file netlist_check.c.

{
        int i, j, k;
        int cur_for_level;
        short more_levels = TRUE;
        short all_visited = TRUE;

        cur_for_level = 0;

        while(more_levels)
        {
                /* go through each element at this level */
                for (i = 0; i < netlist->num_at_forward_level[cur_for_level]; i++)
                {
                        nnode_t *current_node = netlist->forward_levels[cur_for_level][i];
                        if (current_node == NULL)
                                continue;

                        /* at each node visit all the inputs */
                        for (j = 0; j < current_node->num_output_pins; j++)
                        {
                                int *fanouts_visited;
                                if (current_node->output_pins[j] == NULL)
                                        continue; 

                                for (k = 0; k < current_node->output_pins[j]->net->num_fanout_pins; k++)
                                {
                                        if ((current_node->output_pins[j] == NULL) || (current_node->output_pins[j]->net == NULL) || ( current_node->output_pins[j]->net->fanout_pins[k] == NULL))
                                                continue;

                                        /* visit the fanout point */
                                        nnode_t *output_node = current_node->output_pins[j]->net->fanout_pins[k]->node;

                                        if (output_node == NULL)
                                                continue;
        
                                        if (output_node->node_data == NULL)
                                        {
                                                oassert(output_node->unique_node_data_id == RESET);
                                        }
                                        else 
                                        {
                                                int idx;
                                                int idx_missed;
                                                /* ELSE - get the list */
                                                oassert(output_node->unique_node_data_id == LEVELIZE);
                                                fanouts_visited = (int*)output_node->node_data;
                                                output_node->node_data = NULL;

                                                /* check if they've all been marked */
                                                all_visited = TRUE;
                                                for (idx = 0; idx < output_node->num_input_pins; idx++)
                                                {
                                                        if (fanouts_visited[idx] == -1)
                                                        {       
                                                                all_visited = FALSE;
                                                                idx_missed = idx;
                                                                break;
                                                        }
                                                }
        
                                                if (all_visited == FALSE)
                                                {
                                                        /* Combo node since one of the outputs hasn'y been visisted. */
                                                        if (ast_based)
                                                                error_message(NETLIST_ERROR, output_node->related_ast_node->line_number, output_node->related_ast_node->file_number, "!!!Combinational loop on forward pass.  Node %s is missing a driven pin idx %d.  Isn't neccessarily the culprit of the combinational loop.  Odin only detects combinational loops, but currently doesn't pinpoint.\n", output_node->name, idx);
                                                        else
                                                                error_message(NETLIST_ERROR, -1, -1, "!!!Combinational loop on forward pass.  Node %s is missing a driven pin idx %d.  Isn't neccessarily the culprit of the combinational loop.  Odin only detects combinational loops, but currently doesn't pinpoint.\n", output_node->name, idx);
                                                }
                                                /* free the data and reset to be used elsewhere */
                                                free(fanouts_visited);
                                                output_node->unique_node_data_id = RESET;
                                        }

                                        if ((output_node->backward_level == -1) && (output_node->type != FF_NODE))
                                        {
                                                if (ast_based)
                                                        warning_message(NETLIST_ERROR, output_node->related_ast_node->line_number, output_node->related_ast_node->file_number, "Node does not connect to a primary output or FF...DEAD NODE!!!.  Node %s is not connected to a primary output.\n", output_node->name);
                                                else
                                                        warning_message(NETLIST_ERROR, -1, -1, "Node does not connect to a primary output or FF...DEAD NODE!!!.  Node %s is not connected to a primary output.\n", output_node->name);
                                        }
                                }
                        }
                }

                /* check if tere are more elements to procees at the next level */
                if (netlist->num_at_forward_level[cur_for_level+1] > 0)
                {
                        /* there are elements in the next set then process */
                        cur_for_level++;
                }
                else
                {
                        /* ELSE - we've levelized forwards */
                        more_levels = FALSE;
                }
        }
}

Here is the call graph for this function:

Here is the caller graph for this function:

void sequential_levelized_dfs	(	short	marker_value,
		netlist_t *	netlist
	)

Definition at line 90 of file netlist_check.c.

{
        int i;

        int sequential_level = 0;
        netlist->num_sequential_levels = 1;
        netlist->num_at_sequential_level = (int*)realloc(netlist->num_at_sequential_level, sizeof(int)*netlist->num_sequential_levels);
        netlist->sequential_level_nodes = (nnode_t***)realloc(netlist->sequential_level_nodes, sizeof(nnode_t**)*(netlist->num_sequential_levels));
        netlist->sequential_level_nodes[netlist->num_sequential_levels-1] = NULL;
        netlist->num_at_sequential_level[netlist->num_sequential_levels-1] = 0;

        /* allocate the first list.  Includes vcc and gnd */
        netlist->sequential_level_nodes[sequential_level] = (nnode_t**)realloc(netlist->sequential_level_nodes[sequential_level], sizeof(nnode_t*)*(netlist->num_top_input_nodes+2));
        
        /* add all the primary nodes to the first level */
        for (i = 0; i < netlist->num_top_input_nodes; i++)
        {
                if (netlist->top_input_nodes[i] != NULL)
                {
                        netlist->sequential_level_nodes[sequential_level][i] = netlist->top_input_nodes[i];
                        netlist->num_at_sequential_level[sequential_level]++;
                        /* record the level */
                        netlist->top_input_nodes[i]->sequential_level = sequential_level;
                }
        }

        /* now traverse the ground and vcc pins */
        if (netlist->gnd_node != NULL)
        {
                netlist->sequential_level_nodes[sequential_level][i] = netlist->gnd_node;
                netlist->num_at_sequential_level[sequential_level]++;
                /* record the level */
                netlist->gnd_node->sequential_level = sequential_level;
        }
        if (netlist->vcc_node != NULL)
        {
                netlist->sequential_level_nodes[sequential_level][i+1] = netlist->vcc_node;
                netlist->num_at_sequential_level[sequential_level]++;
                /* record the level */
                netlist->vcc_node->sequential_level = sequential_level;
        }

        while (netlist->num_at_sequential_level[sequential_level] > 0)
        {
                /* WHILE there are PIs at this level */

                /* Allocate the next level of storage since this part is a forward thing of the next flip-flops at the level */
                /* add anothersequential level.  Note, needs to be done before we depth first the current combinational level. */               
                netlist->num_sequential_levels ++;
                netlist->sequential_level_nodes = (nnode_t***)realloc(netlist->sequential_level_nodes, sizeof(nnode_t**)*(netlist->num_sequential_levels));
                netlist->num_at_sequential_level = (int*)realloc(netlist->num_at_sequential_level, sizeof(int)*netlist->num_sequential_levels);
                netlist->sequential_level_nodes[netlist->num_sequential_levels-1] = NULL;
                netlist->num_at_sequential_level[netlist->num_sequential_levels-1] = 0;

                /* deals with recording the combinational nodes that terminate this level */
                netlist->num_sequential_level_combinational_termination_nodes ++;
                netlist->sequential_level_combinational_termination_node = (nnode_t***)realloc(netlist->sequential_level_combinational_termination_node, sizeof(nnode_t**)*(netlist->num_sequential_level_combinational_termination_nodes));
                netlist->num_at_sequential_level_combinational_termination_node = (int*)realloc(netlist->num_at_sequential_level_combinational_termination_node, sizeof(int)*netlist->num_sequential_level_combinational_termination_nodes);
                netlist->sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1] = NULL;
                netlist->num_at_sequential_level_combinational_termination_node[netlist->num_sequential_level_combinational_termination_nodes-1] = 0;

                /* go through the entire list, mark with sequential level, and build the next list */
                for (i = 0; i < netlist->num_at_sequential_level[sequential_level]; i++)
                {
                        depth_first_traverse_until_next_ff_or_output(netlist->sequential_level_nodes[sequential_level][i], NULL, marker_value, sequential_level, netlist);
                }

                /* now potentially do next sequential level */
                sequential_level ++;
        }

}

Here is the call graph for this function:

Here is the caller graph for this function: