Added support for multiple driver pins

Author: djns1

ODIN_II/SRC/adders.cpp

@@ -318,7 +318,8 @@ void define_add_function(nnode_t* node, FILE* out) {
 
     /* Write the input pins*/
     for (i = 0; i < node->num_input_pins; i++) {
-        npin_t* driver_pin = node->input_pins[i]->net->driver_pin;
+        oassert(node->input_pins[i]->net->num_driver_pins == 1);
+        npin_t* driver_pin = node->input_pins[i]->net->driver_pins[0];
 
         if (i < node->input_port_sizes[0]) {
             if (!driver_pin->name)
@@ -1121,27 +1122,24 @@ void free_op_nodes(nnode_t* node) {
  * (function: match_pins)
  *-------------------------------------------------------------------------*/
 int match_pins(nnode_t* node, nnode_t* next_node) {
-    int flag = 0;
-    int i, j;
-    long id;
-    for (i = 0; i < node->num_input_pins; i++) {
-        flag = 0;
-        id = node->input_pins[i]->net->driver_pin->unique_id;
-        for (j = 0; j < next_node->num_input_pins; j++) {
-            if (id == next_node->input_pins[j]->net->driver_pin->unique_id) {
-                flag = 1;
-                break;
-            }
-            if (j == next_node->num_input_pins - 1) {
-                flag = -1;
-                break;
+    for (int i = 0; i < node->num_input_pins; i++) {
+        for (int j = 0; j < node->input_pins[i]->net->num_driver_pins; j++) {
+            bool found = false;
+            long id = node->input_pins[i]->net->driver_pins[i]->unique_id;
+            for (int k = 0; k < next_node->num_input_pins && !found; k++) {
+                for (int l = 0; l < next_node->input_pins[i]->net->num_driver_pins; l++) {
+                    if (id == next_node->input_pins[k]->net->driver_pins[l]->unique_id) {
+                        found = true;
+                        break;
+                    }
+                }
             }
+            if (!found)
+                return -1;
         }
-        if (flag == -1)
-            break;
     }
 
-    return flag;
+    return 1;
 }
 
 /*---------------------------------------------------------------------------------------------
@@ -1196,10 +1194,11 @@ static nnode_t* make_adder(operation_list funct, nnode_t* current_adder, nnode_t
         //connect input a
         if (current_pin < width[1]) {
             npin_t* temp_pin = node->input_pins[current_pin];
-            if (temp_pin->net->driver_pin == NULL || temp_pin->net->driver_pin->node->type == GND_NODE) {
+            oassert(temp_pin->net->num_driver_pins <= 1);
+            if (!temp_pin->net->num_driver_pins || temp_pin->net->driver_pins[0]->node->type == GND_NODE) {
                 connect_nodes(netlist->gnd_node, 0, new_funct, 0 + is_three_port_gate);
                 remove_fanout_pins_from_net(temp_pin->net, temp_pin, temp_pin->pin_net_idx);
-            } else if (temp_pin->net->driver_pin->node->type == VCC_NODE) {
+            } else if (temp_pin->net->driver_pins[0]->node->type == VCC_NODE) {
                 connect_nodes(netlist->vcc_node, 0, new_funct, 0 + is_three_port_gate);
                 remove_fanout_pins_from_net(temp_pin->net, temp_pin, temp_pin->pin_net_idx);
             } else {
@@ -1213,11 +1212,12 @@ static nnode_t* make_adder(operation_list funct, nnode_t* current_adder, nnode_t
         if (current_pin < width[2]) {
             //pin a is neighbor to pin b
             npin_t* temp_pin = node->input_pins[current_pin + width[1]];
-            if (temp_pin->net->driver_pin == NULL || temp_pin->net->driver_pin->node->type == GND_NODE) {
+            oassert(temp_pin->net->num_driver_pins <= 1);
+            if (temp_pin->net->num_driver_pins == 0 || temp_pin->net->driver_pins[0]->node->type == GND_NODE) {
                 nnode_t* attach_to = (subtraction) ? netlist->vcc_node : netlist->gnd_node;
                 connect_nodes(attach_to, 0, new_funct, 1 + is_three_port_gate);
                 remove_fanout_pins_from_net(temp_pin->net, temp_pin, temp_pin->pin_net_idx);
-            } else if (temp_pin->net->driver_pin->node->type == VCC_NODE) {
+            } else if (temp_pin->net->driver_pins[0]->node->type == VCC_NODE) {
                 nnode_t* attach_to = (subtraction) ? netlist->gnd_node : netlist->vcc_node;
                 connect_nodes(attach_to, 0, new_funct, 1 + is_three_port_gate);
                 remove_fanout_pins_from_net(temp_pin->net, temp_pin, temp_pin->pin_net_idx);

ODIN_II/SRC/hard_blocks.cpp

@@ -144,21 +144,23 @@ void define_hard_block(nnode_t* node, FILE* out) {
     port = index = 0;
     for (i = 0; i < node->num_input_pins; i++) {
         /* Check that the input pin is driven */
-        if (node->input_pins[i]->net->driver_pin == NULL
+        if (node->input_pins[i]->net->num_driver_pins == 0
             && node->input_pins[i]->net != verilog_netlist->zero_net
             && node->input_pins[i]->net != verilog_netlist->one_net
             && node->input_pins[i]->net != verilog_netlist->pad_net) {
             warning_message(NETLIST, -1, -1, "Signal %s is not driven. padding with ground\n", node->input_pins[i]->name);
             add_fanout_pin_to_net(verilog_netlist->zero_net, node->input_pins[i]);
+        } else if (node->input_pins[i]->net->num_driver_pins > 1) {
+            error_message(NETLIST, -1, -1, "Multiple (%d) driver pins not supported in hard block definition\n", node->input_pins[i]->net->num_driver_pins);
         }
 
         if (node->input_port_sizes[port] == 1)
-            j = odin_sprintf(buffer, " %s=%s", node->input_pins[i]->mapping, node->input_pins[i]->net->driver_pin->node->name);
+            j = odin_sprintf(buffer, " %s=%s", node->input_pins[i]->mapping, node->input_pins[i]->net->driver_pins[0]->name);
         else {
-            if (node->input_pins[i]->net->driver_pin->name != NULL)
-                j = odin_sprintf(buffer, " %s[%d]=%s", node->input_pins[i]->mapping, index, node->input_pins[i]->net->driver_pin->name);
+            if (node->input_pins[i]->net->driver_pins[0]->name != NULL)
+                j = odin_sprintf(buffer, " %s[%d]=%s", node->input_pins[i]->mapping, index, node->input_pins[i]->net->driver_pins[0]->name);
             else
-                j = odin_sprintf(buffer, " %s[%d]=%s", node->input_pins[i]->mapping, index, node->input_pins[i]->net->driver_pin->node->name);
+                j = odin_sprintf(buffer, " %s[%d]=%s", node->input_pins[i]->mapping, index, node->input_pins[i]->net->driver_pins[0]->node->name);
         }
 
         if (count + j > 79) {

ODIN_II/SRC/include/node_creation_library.h

@@ -19,6 +19,7 @@ npin_t* get_zero_pin();
 npin_t* get_one_pin();
 
 char* node_name(nnode_t* node, char* instance_prefix_name);
+char* op_node_name(operation_list op, char* instance_prefix_name);
 char* hard_node_name(nnode_t* node, char* instance_name_prefix, char* hb_name, char* hb_inst);
 nnode_t* make_mult_block(nnode_t* node, short mark);
 

ODIN_II/SRC/include/odin_types.h

@@ -513,7 +513,8 @@ struct nnet_t {
     char* name; // name for the net
     short combined;
 
-    npin_t* driver_pin; // the pin that drives the net
+    int num_driver_pins;
+    npin_t** driver_pins; // the pin that drives the net
 
     npin_t** fanout_pins; // the pins pointed to by the net
     int num_fanout_pins;  // the list size of pins

ODIN_II/SRC/memories.cpp

@@ -1431,7 +1431,7 @@ void instantiate_soft_single_port_ram(nnode_t* node, short mark, netlist_t* netl
         npin_t* address_pin = decoder->pins[i];
         /* Check that the input pin is driven */
         oassert(
-            address_pin->net->driver_pin != NULL
+            address_pin->net->num_driver_pins
             || address_pin->net == verilog_netlist->zero_net
             || address_pin->net == verilog_netlist->one_net
             || address_pin->net == verilog_netlist->pad_net);
@@ -1459,7 +1459,7 @@ void instantiate_soft_single_port_ram(nnode_t* node, short mark, netlist_t* netl
             npin_t* address_pin = decoder->pins[j];
             /* Check that the input pin is driven */
             oassert(
-                address_pin->net->driver_pin != NULL
+                address_pin->net->num_driver_pins
                 || address_pin->net == verilog_netlist->zero_net
                 || address_pin->net == verilog_netlist->one_net
                 || address_pin->net == verilog_netlist->pad_net);
@@ -1544,12 +1544,12 @@ void instantiate_soft_dual_port_ram(nnode_t* node, short mark, netlist_t* netlis
         npin_t* addr2_pin = decoder2->pins[i];
 
         oassert(
-            addr1_pin->net->driver_pin != NULL
+            addr1_pin->net->num_driver_pins
             || addr1_pin->net == verilog_netlist->zero_net
             || addr1_pin->net == verilog_netlist->one_net
             || addr1_pin->net == verilog_netlist->pad_net);
         oassert(
-            addr2_pin->net->driver_pin != NULL
+            addr2_pin->net->num_driver_pins
             || addr2_pin->net == verilog_netlist->zero_net
             || addr2_pin->net == verilog_netlist->one_net
             || addr2_pin->net == verilog_netlist->pad_net);
@@ -1597,12 +1597,12 @@ void instantiate_soft_dual_port_ram(nnode_t* node, short mark, netlist_t* netlis
             npin_t* addr2_pin = decoder2->pins[j];
 
             oassert(
-                addr1_pin->net->driver_pin != NULL
+                addr1_pin->net->num_driver_pins
                 || addr1_pin->net == verilog_netlist->zero_net
                 || addr1_pin->net == verilog_netlist->one_net
                 || addr1_pin->net == verilog_netlist->pad_net);
             oassert(
-                addr2_pin->net->driver_pin != NULL
+                addr2_pin->net->num_driver_pins
                 || addr2_pin->net == verilog_netlist->zero_net
                 || addr2_pin->net == verilog_netlist->one_net
                 || addr2_pin->net == verilog_netlist->pad_net);
@@ -1698,7 +1698,7 @@ signal_list_t* create_decoder(nnode_t* node, short mark, signal_list_t* input_li
     // Create NOT gates for all inputs and put the outputs in their own signal list.
     signal_list_t* not_gates = init_signal_list();
     for (long i = 0; i < num_inputs; i++) {
-        if (input_list->pins[i]->net->driver_pin == NULL
+        if (!input_list->pins[i]->net->num_driver_pins
             && input_list->pins[i]->net != verilog_netlist->zero_net
             && input_list->pins[i]->net != verilog_netlist->one_net
             && input_list->pins[i]->net != verilog_netlist->pad_net) {

ODIN_II/SRC/multipliers.cpp

@@ -491,18 +491,20 @@ void define_mult_function(nnode_t* node, FILE* out) {
 
     for (i = 0; i < node->num_input_pins; i++) {
         if (i < node->input_port_sizes[flip ? 1 : 0]) {
-            npin_t* driver_pin = flip
-                                     ? node->input_pins[i + node->input_port_sizes[0]]->net->driver_pin
-                                     : node->input_pins[i]->net->driver_pin;
+            int input_index = flip ? i + node->input_port_sizes[0] : i;
+            nnet_t* net = node->input_pins[input_index]->net;
+            oassert(net->num_driver_pins == 1);
+            npin_t* driver_pin = net->driver_pins[0];
 
             if (!driver_pin->name)
                 j = odin_sprintf(buffer, " %s[%ld]=%s", hard_multipliers->inputs->next->name, i, driver_pin->node->name);
             else
                 j = odin_sprintf(buffer, " %s[%ld]=%s", hard_multipliers->inputs->next->name, i, driver_pin->name);
         } else {
-            npin_t* driver_pin = flip
-                                     ? node->input_pins[i - node->input_port_sizes[1]]->net->driver_pin
-                                     : node->input_pins[i]->net->driver_pin;
+            int input_index = flip ? i - node->input_port_sizes[1] : i;
+            nnet_t* net = node->input_pins[input_index]->net;
+            oassert(net->num_driver_pins == 1);
+            npin_t* driver_pin = net->driver_pins[0];
 
             long index = flip
                              ? i - node->input_port_sizes[1]

ODIN_II/SRC/netlist_check.cpp

@@ -566,7 +566,7 @@ void levelize_backwards(netlist_t* netlist) {
                             }
 
                             /* mark this entry as visited */
-                            if (fanout_net->driver_pin != NULL) {
+                            if (fanout_net->num_driver_pins != 0) {
                                 fanouts_visited[current_node->input_pins[j]->pin_net_idx] = cur_back_level;
                             }
 
@@ -579,19 +579,20 @@ void levelize_backwards(netlist_t* netlist) {
                                     && fanouts_visited[k] == -1));
                             }
 
-                            if (all_visited
-                                && fanout_net->driver_pin
-                                && fanout_net->driver_pin->node
-                                && 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**)vtr::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]++;
+                            if (all_visited) {
+                                for (k = 0; k < fanout_net->num_driver_pins; k++) {
+                                    if (!fanout_net->driver_pins[k]->node || fanout_net->driver_pins[k]->node->type == FF_NODE)
+                                        continue;
+                                    /* This one has been visited by everyone */
+                                    if (fanout_net->driver_pins[k]->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**)vtr::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_pins[k]->node;
+                                        netlist->num_at_backward_level[cur_back_level + 1]++;
+                                    }
+
+                                    fanout_net->driver_pins[k]->node->backward_level = cur_back_level + 1;
                                 }
-
-                                fanout_net->driver_pin->node->backward_level = cur_back_level + 1;
                             }
                         }
                     }
@@ -685,35 +686,43 @@ void levelize_backwards_clean_checking_for_liveness(short ast_based, netlist_t*
  * (function: find_node_at_top_of_combo_loop)
  *-------------------------------------------------------------------------------------------*/
 nnode_t* find_node_at_top_of_combo_loop(nnode_t* start_node) {
-    int i;
-    int idx_missed;
-    nnode_t* next_node = start_node;
-    int* fanouts_visited;
-    short all_visited;
+    int stack_size = 1;
+    nnode_t** stack = (nnode_t**)vtr::calloc(stack_size, sizeof(nnode_t*));
+    stack[0] = start_node;
 
     while (true) {
+        nnode_t* next_node = stack[--stack_size];
         oassert(next_node->unique_node_data_id == LEVELIZE);
-        fanouts_visited = (int*)next_node->node_data;
+        int* 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++) {
+        bool all_visited = true;
+        int idx_missed = -1;
+        for (int 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;
+        if (!all_visited) {
+            for (int i = 0; i < next_node->input_pins[idx_missed]->net->num_driver_pins; i++) {
+                if (next_node->input_pins[idx_missed]->net->driver_pins[i]->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 */
+                    vtr::free(stack);
+                    return next_node;
+                }
 
-            next_node = next_node->input_pins[idx_missed]->net->driver_pin->node;
+                stack_size++;
+                stack = (nnode_t**)vtr::realloc(stack, sizeof(nnode_t*) * stack_size);
+                stack[stack_size - 1] = next_node->input_pins[idx_missed]->net->driver_pins[i]->node;
+                stack_size++;
+            }
         } else {
+            vtr::free(stack);
             return next_node;
         }
     }

ODIN_II/SRC/netlist_cleanup.cpp

@@ -71,8 +71,8 @@ void traverse_backward(nnode_t* node) {
     node->node_data = VISITED_BACKWARD;              // Mark as visited
     int i;
     for (i = 0; i < node->num_input_pins; i++) {
-        if (node->input_pins[i]->net->driver_pin) {                        // ensure this net has a driver (i.e. skip undriven outputs)
-            traverse_backward(node->input_pins[i]->net->driver_pin->node); // Visit the drivers of this node
+        for (int j = 0; j < node->input_pins[i]->net->num_driver_pins; j++) {  // ensure this net has a driver (i.e. skip undriven outputs)
+            traverse_backward(node->input_pins[i]->net->driver_pins[j]->node); // Visit the drivers of this node
         }
     }
 }
@@ -109,8 +109,9 @@ void traverse_forward(nnode_t* node, int toplevel, int remove_me) {
             else
                 ADDER_START_NODE = VCC_NODE;
         }
+        oassert(node->input_pins[node->num_input_pins - 1]->net->num_driver_pins == 1);
         /* Check if we've found the head of an adder or subtractor chain */
-        if (node->input_pins[node->num_input_pins - 1]->net->driver_pin->node->type == ADDER_START_NODE) {
+        if (node->input_pins[node->num_input_pins - 1]->net->driver_pins[0]->node->type == ADDER_START_NODE) {
             addsub_list_next = insert_node_list(addsub_list_next, node);
         }
     }