Merge branch 'master' into fix_parse_runtime

Author: jgoeders

ODIN_II/SRC/ast_elaborate.cpp

@@ -1167,9 +1167,6 @@ ast_node_t* finalize_ast(ast_node_t* node, ast_node_t* parent, sc_hierarchy* loc
                                       "%s", "Cannot mix port connections by name and port connections by ordered list\n");
                     }
                 }
-
-                skip_children = true;
-
                 break;
             }
             case TASK: {
@@ -1198,9 +1195,6 @@ ast_node_t* finalize_ast(ast_node_t* node, ast_node_t* parent, sc_hierarchy* loc
                                       "%s", "Cannot mix port connections by name and port connections by ordered list\n");
                     }
                 }
-
-                skip_children = true;
-
                 break;
             }
             case MODULE_ITEMS: {

ODIN_II/SRC/ast_util.cpp

@@ -625,6 +625,9 @@ char* get_name_of_pin_at_bit(ast_node_t* var_node, int bit, char* instance_name_
                 var_node = free_whole_tree(var_node);
             }
         }
+    } else if (var_node->type == BINARY_OPERATION || var_node->type == UNARY_OPERATION || var_node->type == TERNARY_OPERATION) {
+        if (!var_node->net_node)
+            error_message(AST, var_node->loc, "Expression is not allowed for outputs in instance port connections. var_node->type = %s\n", ast_node_name_based_on_ids(var_node));
     } else {
         return_string = NULL;
 

ODIN_II/SRC/include/netlist_utils.h

@@ -35,7 +35,9 @@ void add_output_port_information(nnode_t* node, int port_width);
 void add_input_port_information(nnode_t* node, int port_width);
 
 void combine_nets(nnet_t* output_net, nnet_t* input_net, netlist_t* netlist);
+void combine_nets_with_spot_copy(nnet_t* output_net, nnet_t* input_net, long sc_spot_output, netlist_t* netlist);
 void join_nets(nnet_t* net, nnet_t* input_net);
+void integrate_nets(char* alias_name, char* full_name, nnet_t* input_signal_net);
 
 void remap_pin_to_new_net(npin_t* pin, nnet_t* new_net);
 void remap_pin_to_new_node(npin_t* pin, nnode_t* new_node, int pin_idx);

ODIN_II/SRC/memories.cpp

@@ -1711,6 +1711,7 @@ signal_list_t* create_decoder(nnode_t* node, short mark, signal_list_t* input_li
         npin_t* not_output = allocate_npin();
         add_output_pin_to_node(not_g, not_output, 0);
         nnet_t* net = allocate_nnet();
+        net->name = make_full_ref_name(NULL, NULL, NULL, not_g->name, 0);
         add_driver_pin_to_net(net, not_output);
         not_output = allocate_npin();
         add_fanout_pin_to_net(net, not_output);
@@ -1750,6 +1751,7 @@ signal_list_t* create_decoder(nnode_t* node, short mark, signal_list_t* input_li
         npin_t* output = allocate_npin();
         nnet_t* net = allocate_nnet();
         add_output_pin_to_node(and_g, output, 0);
+        net->name = make_full_ref_name(NULL, NULL, NULL, and_g->name, 0);
         add_driver_pin_to_net(net, output);
         output = allocate_npin();
         add_fanout_pin_to_net(net, output);

ODIN_II/SRC/netlist_create_from_ast.cpp

@@ -442,6 +442,44 @@ void combine_nets(nnet_t* output_net, nnet_t* input_net, netlist_t* netlist) {
     free_nnet(output_net);
 }
 
+/*---------------------------------------------------------------------------------------------
+ * (function: combine_nets_with_spot_copy)
+ * // output net is a net with a driver
+ * // input net is a net with all the fanouts
+ * In addition to combining two nets, it will change the value of 
+ * all input nets driven by the output_net previously.
+ *-------------------------------------------------------------------------------------------*/
+void combine_nets_with_spot_copy(nnet_t* output_net, nnet_t* input_net, long sc_spot_output, netlist_t* netlist) {
+    long in_net_idx;
+    long idx_array_size = 0;
+    long* idx_array = NULL;
+
+    // check to see if any matching input_net exist, then save its index
+    for (in_net_idx = 0; in_net_idx < input_nets_sc->size; in_net_idx++) {
+        if (input_nets_sc->data[in_net_idx] == output_net) {
+            idx_array = (long*)vtr::realloc(idx_array, sizeof(long*) * (idx_array_size + 1));
+            idx_array[idx_array_size] = in_net_idx;
+            idx_array_size += 1;
+        }
+    }
+
+    combine_nets(output_net, input_net, netlist);
+    output_net = NULL;
+    /* since the driver net is deleted, copy the spot of the input_net over */
+    output_nets_sc->data[sc_spot_output] = (void*)input_net;
+
+    // copy the spot of input_nets for other inputs driven by the output_net
+    for (in_net_idx = 0; in_net_idx < idx_array_size; in_net_idx++) {
+        char* net_name = input_nets_sc->string[idx_array[in_net_idx]];
+        input_nets_sc->data[idx_array[in_net_idx]] = (void*)input_net;
+        // check to see if there is any matching output net too.
+        if ((sc_spot_output = sc_lookup_string(output_nets_sc, net_name)) != -1)
+            output_nets_sc->data[sc_spot_output] = (void*)input_net;
+    }
+
+    vtr::free(idx_array);
+}
+
 /*---------------------------------------------------------------------------------------------
  * (function: join_nets)
  * 	Copies the fanouts from input net into net
@@ -480,6 +518,71 @@ void join_nets(nnet_t* join_to_net, nnet_t* other_net) {
     }
 }
 
+/*---------------------------------------------------------------------------------------------
+ * (function: integrate_nets)
+ * processing the integration of the input net, named with the 
+ * full_name string (if not exist in input_nets_sc then use driver_net), 
+ * with the alias net (a related module/function/task instance connection).
+ *-------------------------------------------------------------------------------------------*/
+void integrate_nets(char* alias_name, char* full_name, nnet_t* driver_net) {
+    long sc_spot_output;
+    long sc_spot_input_old;
+    long sc_spot_input_new;
+
+    sc_spot_input_old = sc_lookup_string(input_nets_sc, alias_name);
+    oassert(sc_spot_input_old != -1);
+
+    /* CMM - Check if this pin should be driven by the top level VCC or GND drivers	*/
+    if (strstr(full_name, ONE_VCC_CNS)) {
+        join_nets(verilog_netlist->one_net, (nnet_t*)input_nets_sc->data[sc_spot_input_old]);
+        free_nnet((nnet_t*)input_nets_sc->data[sc_spot_input_old]);
+        input_nets_sc->data[sc_spot_input_old] = (void*)verilog_netlist->one_net;
+    } else if (strstr(full_name, ZERO_GND_ZERO)) {
+        join_nets(verilog_netlist->zero_net, (nnet_t*)input_nets_sc->data[sc_spot_input_old]);
+        free_nnet((nnet_t*)input_nets_sc->data[sc_spot_input_old]);
+        input_nets_sc->data[sc_spot_input_old] = (void*)verilog_netlist->zero_net;
+    }
+    /* check if the instantiation pin exists. */
+    else if ((sc_spot_output = sc_lookup_string(output_nets_sc, full_name)) == -1) {
+        /* IF - no driver, then assume that it needs to be aliased to move up as an input */
+        if ((sc_spot_input_new = sc_lookup_string(input_nets_sc, full_name)) == -1) {
+            /* if this input is not yet used in this module then we'll add it */
+            sc_spot_input_new = sc_add_string(input_nets_sc, full_name);
+
+            if (driver_net == NULL) {
+                /* copy the pin to the old spot */
+                input_nets_sc->data[sc_spot_input_new] = input_nets_sc->data[sc_spot_input_old];
+            } else {
+                /* copy the pin to the old spot */
+                input_nets_sc->data[sc_spot_input_new] = (void*)driver_net;
+                nnet_t* old_in_net = (nnet_t*)input_nets_sc->data[sc_spot_input_old];
+                join_nets((nnet_t*)input_nets_sc->data[sc_spot_input_new], old_in_net);
+                //net = NULL;
+                old_in_net = free_nnet(old_in_net);
+                input_nets_sc->data[sc_spot_input_old] = (void*)driver_net;
+            }
+        } else {
+            /* already exists so we'll join the nets */
+            combine_nets((nnet_t*)input_nets_sc->data[sc_spot_input_old], (nnet_t*)input_nets_sc->data[sc_spot_input_new], verilog_netlist);
+            input_nets_sc->data[sc_spot_input_old] = NULL;
+        }
+    } else {
+        /* ELSE - we've found a matching net, so add this pin to the net */
+        nnet_t* out_net = (nnet_t*)output_nets_sc->data[sc_spot_output];
+        nnet_t* in_net = (nnet_t*)input_nets_sc->data[sc_spot_input_old];
+
+        if ((out_net != in_net) && (out_net->combined == true)) {
+            /* if they haven't been combined already, then join the inputs and output */
+            join_nets(out_net, in_net);
+            in_net = free_nnet(in_net);
+            /* since the driver net is deleted, copy the spot of the in_net over */
+            input_nets_sc->data[sc_spot_input_old] = (void*)out_net;
+        } else if ((out_net != in_net) && (out_net->combined == false)) {
+            // merge the out_net into the in_net and alter related string cache data for all nets driven by the out_net
+            combine_nets_with_spot_copy(out_net, in_net, sc_spot_output, verilog_netlist);
+        }
+    }
+}
 /*---------------------------------------------------------------------------------------------
  * (function: remap_pin_to_new_net)
  *-------------------------------------------------------------------------------------------*/

ODIN_II/SRC/netlist_utils.cpp

@@ -1013,7 +1013,7 @@ void instantiate_shift(nnode_t* node, operation_list type, short mark, netlist_t
                 npin_t* new_pin1 = allocate_npin();
                 npin_t* new_pin2 = allocate_npin();
                 nnet_t* new_net = allocate_nnet();
-                new_net->name = vtr::strdup(muxes[i][j]->name);
+                new_net->name = make_full_ref_name(NULL, NULL, NULL, muxes[i][j]->name, j);
                 /* hook the output pin into the node */
                 add_output_pin_to_node(muxes[i][j], new_pin1, 0);
                 /* hook up new pin 1 into the new net */