fixed wrong mallocs preventing proper function

Author: jeanlego

ODIN_II/SRC/ace.c

@@ -26,6 +26,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "cudd.h"
 #include "ace.h"
 #include "st.h"
+#include "allocation_def.h"
 
 #define ACE_P0TO1(P1,PS)		((P1)==0.0)?0.0:(((P1)==1.0)?1.0:0.5*PS/(1.0-(P1)))
 #define ACE_P1TO0(P1,PS)		((P1)==0.0)?1.0:(((P1)==0.0)?0.0:0.5*PS/(P1))
@@ -59,7 +60,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 
 typedef unsigned int *pset;
 
-#define ALLOC(type, num)	((type *) malloc(sizeof(type) * (num)))
+#define ALLOC(type, num)	ALLOCATE_ME(num,type)
 
 #define set_remove(set, e)      (set[WHICH_WORD(e)] &= ~ (1 << WHICH_BIT(e)))
 #define set_insert(set, e)      (set[WHICH_WORD(e)] |= 1 << WHICH_BIT(e))
@@ -465,7 +466,7 @@ ace_cube_t * ace_cube_dup(ace_cube_t * cube) {
     int i;
     ace_cube_t * cube_copy;
 
-    cube_copy = (ace_cube_t * ) malloc(sizeof(ace_cube_t));
+    cube_copy = (ace_cube_t * ) calloc(1,sizeof(ace_cube_t));
     cube_copy->static_prob = cube->static_prob;
     cube_copy->num_literals = cube->num_literals;
     cube_copy->cube = set_new (2 * cube->num_literals);
@@ -499,7 +500,7 @@ ace_cube_t * ace_cube_new_dc(int num_literals) {
     int i;
     ace_cube_t * new_cube;
 
-    new_cube = (ace_cube_t * ) malloc(sizeof(ace_cube_t));
+    new_cube = (ace_cube_t * ) calloc(1,sizeof(ace_cube_t));
     new_cube->num_literals = num_literals;
     new_cube->static_prob = 1.0;
     new_cube->cube = set_new (2 * num_literals);
@@ -616,7 +617,7 @@ double calc_cube_switch_prob_recur(DdManager * mgr, DdNode * bdd, ace_cube_t * c
 
     i = Cudd_Regular(bdd)->index;
 
-    current_prob = ( double * ) malloc(sizeof(double));
+    current_prob = ( double * ) calloc(1,sizeof(double));
 
     if (Cudd_IsComplement(bdd)) {
 	bdd_if1 = Cudd_E(bdd);

ODIN_II/SRC/activity_estimation.c

@@ -32,6 +32,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "ast_util.h"
 #include "activity_estimation.h"
 #include "netlist_check.h"
+#include "allocation_def.h"
 
 #define DEFAULT_STATIC_PROBABILITY .5
 #define DEFAULT_TRANSITION_DENSITY .5
@@ -102,7 +103,7 @@ void calc_transition_density(netlist_t *netlist)
 			if (current_node->type == BLIF_FUNCTION)
 			{
 				/* only one output */
-				act_data->transition_density = (double*)malloc(sizeof(double)); // only one output
+				act_data->transition_density = (double*)calloc(1,sizeof(double)); // only one output
 
 				if (current_node->num_input_pins == 1)
 				{
@@ -155,7 +156,7 @@ void calc_transition_density(netlist_t *netlist)
 				oassert(input_node->unique_node_data_id == ACTIVATION);
 
 				/* just store since allocated in the initialization */
-				act_data->transition_density = (double*)malloc(sizeof(double));
+				act_data->transition_density = (double*)calloc(1,sizeof(double));
 				act_data->transition_density[0] = 2 * (input_data->static_probability[input_node_pin] * (1-input_data->static_probability[input_node_pin])); 
 			}
 			else if (current_node->type == OUTPUT_NODE)
@@ -166,7 +167,7 @@ void calc_transition_density(netlist_t *netlist)
 				oassert(input_node->unique_node_data_id == ACTIVATION);
 
 				/* allocate and stre through */
-				act_data->transition_density = (double*)malloc(sizeof(double));
+				act_data->transition_density = (double*)calloc(1,sizeof(double));
 				act_data->transition_density[0] = input_data->static_probability[input_node_pin];
 			}
 			else if ((current_node->type == INPUT_NODE) || (current_node->type == VCC_NODE) || (current_node->type == GND_NODE))
@@ -198,7 +199,7 @@ void initialize_probabilities(char *input_file, netlist_t *netlist)
 			oassert(current_node->unique_node_data_id == RESET);
 
 			current_node->unique_node_data_id = ACTIVATION;
-			act_data = (activation_t*)malloc(sizeof(activation_t));
+			act_data = (activation_t*)calloc(1,sizeof(activation_t));
 			current_node->node_data = (void*)act_data;
 
 			if (current_node->type == INPUT_NODE)
@@ -218,9 +219,9 @@ void initialize_probabilities(char *input_file, netlist_t *netlist)
 				else
 				{
 					/* initialize all the initial probabilities */
-					act_data->static_probability = (double*)malloc(sizeof(double));
-					act_data->transition_probability = (double*)malloc(sizeof(double));
-					act_data->transition_density = (double*)malloc(sizeof(double));
+					act_data->static_probability = (double*)calloc(1,sizeof(double));
+					act_data->transition_probability = (double*)calloc(1,sizeof(double));
+					act_data->transition_density = (double*)calloc(1,sizeof(double));
 
 					act_data->static_probability[0] = DEFAULT_STATIC_PROBABILITY;
 					act_data->transition_probability[0] = -1;
@@ -230,9 +231,9 @@ void initialize_probabilities(char *input_file, netlist_t *netlist)
 			else if (current_node->type == GND_NODE)
 			{
 				/* initialize all the initial probabilities */
-				act_data->static_probability = (double*)malloc(sizeof(double));
-				act_data->transition_probability = (double*)malloc(sizeof(double));
-				act_data->transition_density = (double*)malloc(sizeof(double));
+				act_data->static_probability = (double*)calloc(1,sizeof(double));
+				act_data->transition_probability = (double*)calloc(1,sizeof(double));
+				act_data->transition_density = (double*)calloc(1,sizeof(double));
 
 				act_data->static_probability[0] = 0.0;
 				act_data->transition_probability[0] = -1;
@@ -242,9 +243,9 @@ void initialize_probabilities(char *input_file, netlist_t *netlist)
 			else if (current_node->type == VCC_NODE)
 			{
 				/* initialize all the initial probabilities */
-				act_data->static_probability = (double*)malloc(sizeof(double));
-				act_data->transition_probability = (double*)malloc(sizeof(double));
-				act_data->transition_density = (double*)malloc(sizeof(double));
+				act_data->static_probability = (double*)calloc(1,sizeof(double));
+				act_data->transition_probability = (double*)calloc(1,sizeof(double));
+				act_data->transition_density = (double*)calloc(1,sizeof(double));
 
 				act_data->static_probability[0] = 1.0;
 				act_data->transition_probability[0] = -1;
@@ -254,9 +255,9 @@ void initialize_probabilities(char *input_file, netlist_t *netlist)
 			else if (current_node->type == FF_NODE)
 			{
 				/* initialize all the initial probabilities */
-				act_data->static_probability = (double*)malloc(sizeof(double));
-				act_data->transition_probability = (double*)malloc(sizeof(double));
-				act_data->transition_density = (double*)malloc(sizeof(double));
+				act_data->static_probability = (double*)calloc(1,sizeof(double));
+				act_data->transition_probability = (double*)calloc(1,sizeof(double));
+				act_data->transition_density = (double*)calloc(1,sizeof(double));
 
 				act_data->static_probability[0] = DEFAULT_STATIC_PROBABILITY;
 				act_data->transition_probability[0] = -1;
@@ -296,7 +297,7 @@ void calc_probabilities_and_init_act_data(netlist_t *netlist)
 					if (rep == 0)
 					{
 						/* only one output */
-						act_data->static_probability = (double*)malloc(sizeof(double));
+						act_data->static_probability = (double*)calloc(1,sizeof(double));
 					}
 
 					for (k = 0; k < function_size; k++)
@@ -356,7 +357,7 @@ void calc_probabilities_and_init_act_data(netlist_t *netlist)
 					if (rep == 0)
 					{
 						/* only one output */
-						act_data->static_probability = (double*)malloc(sizeof(double));
+						act_data->static_probability = (double*)calloc(1,sizeof(double));
 					}
 
 					act_data->static_probability[0] = input_data->static_probability[input_node_pin];
@@ -374,7 +375,7 @@ void calc_probabilities_and_init_act_data(netlist_t *netlist)
 				if (rep == 0)
 				{
 					/* calculate transition probability */
-					act_data->transition_probability = (double*)malloc(sizeof(double)*current_node->num_output_pins);
+					act_data->transition_probability = (double*)calloc(current_node->num_output_pins,sizeof(double));
 				}
 
 				for (k = 0; k < current_node->num_output_pins; k++)
@@ -404,7 +405,7 @@ short *boolean_difference(nnode_t *node, int variable_spot)
 	/* calculate the size of the boolean difference */
 	function_size = pow2(node->num_input_pins-1);
 
-	return_function = (short*)calloc(sizeof(short), function_size);
+	return_function = (short*)calloc(function_size,sizeof(short));
 
 	for (i = 0; i < function_size; i++)
 	{
@@ -529,9 +530,9 @@ double calc_density(nnode_t *node, int variable_spot, short *boolean_difference)
  *-------------------------------------------------------------------------------------------*/
 void output_activation_file_ace_and_function_file(char *output_filename, int lut_size, netlist_t *LUT_netlist, netlist_t *CLUSTER_netlist)
 {
-	char *ace_file_name = (char*)malloc(sizeof(char)*(strlen(output_filename)+4+1));
-	char *ac2_file_name = (char*)malloc(sizeof(char)*(strlen(output_filename)+4+1));
-	char *function_file_name = (char*)malloc(sizeof(char)*(strlen(output_filename)+4+1));
+	char *ace_file_name = (char*)calloc((strlen(output_filename)+4+1),sizeof(char));
+	char *ac2_file_name = (char*)calloc((strlen(output_filename)+4+1),sizeof(char));
+	char *function_file_name = (char*)calloc((strlen(output_filename)+4+1),sizeof(char));
 	int i, j, k, l;
 	FILE *ace_out;
 	FILE *ac2_out;
@@ -658,7 +659,7 @@ void output_activation_file_ace_and_function_file(char *output_filename, int lut
 		for (k = 0; k < internal_subblocks->num_internal_nodes; k++)
 		{
 			nnode_t *current_subblock = internal_subblocks->internal_nodes[k];
-			char *output_search_name = (char*)malloc(sizeof(char)*(strlen(current_subblock->name)+1+4));
+			char *output_search_name = (char*)calloc((strlen(current_subblock->name)+1+4),sizeof(char));
 			sprintf(output_search_name, "out:%s", current_subblock->name);
 
 			if ((sc_spot = sc_lookup_string(internal_subblocks->nodes_sc, output_search_name)) != -1)

ODIN_II/SRC/adders.c

@@ -35,7 +35,7 @@ OTHER DEALINGS IN THE SOFTWARE.
 #include "errors.h"
 #include "subtractions.h"
 #include "print_tags.h"
-
+#include "allocation_def.h"
 #include "vtr_list.h"
 
 using vtr::t_linked_vptr;
@@ -65,7 +65,7 @@ void init_add_distribution()
 	int i, j;
 	oassert(hard_adders != NULL);
 	j = hard_adders->inputs->size + hard_adders->inputs->next->size;
-	adder = (int *)malloc(sizeof(int) * (j + 1));
+	adder = (int *)calloc((j + 1),sizeof(int));
 	for (i = 0; i <= j; i++)
 		adder[i] = 0;
 	return;
@@ -173,7 +173,7 @@ void declare_hard_adder(nnode_t *node)
 	}
 
 	/* Does not exist - must create an instance */
-	tmp = (t_adder *)malloc(sizeof(t_adder));
+	tmp = (t_adder *)calloc(1,sizeof(t_adder));
 	tmp->next = (t_adder *)hard_adders->instances;
 	hard_adders->instances = tmp;
 	tmp->size_a = width_a;
@@ -195,26 +195,24 @@ void instantiate_hard_adder(nnode_t *node, short mark, netlist_t * /*netlist*/)
 	declare_hard_adder(node);
 
 	/* Need to give node proper name */
-	len = strlen(node->name);
-	len = len + 20; /* 20 chars should hold mul specs */
-	new_name = (char*)malloc(len);
+	/* 20 chars should hold mul specs */
+	new_name = (char*)calloc(strlen(node->name)+20,sizeof(char));
 
 	/* wide input first :) */
 	if (node->input_port_sizes[0] > node->input_port_sizes[1])
 		sanity = sprintf(new_name, "%s", node->name);
 	else
 		sanity = sprintf(new_name, "%s", node->name);
 
-	if (len <= sanity) /* buffer not large enough */
+	if (strlen(node->name)+20 <= sanity) /* buffer not large enough */
 		oassert(FALSE);
 
 	/* Give names to the output pins */
 	for (i = 0; i < node->num_output_pins;  i++)
 	{
 		if (node->output_pins[i]->name == NULL)
 		{
-			len = strlen(node->name) + 20; /* 6 chars for pin idx */
-			new_name = (char*)malloc(len);
+			new_name = (char*)calloc(strlen(node->name) + 20,sizeof(char));
 			sprintf(new_name, "%s[%d]", node->name, node->output_pins[i]->pin_node_idx);
 			node->output_pins[i]->name = new_name;
 		}
@@ -472,12 +470,12 @@ void init_split_adder(nnode_t *node, nnode_t *ptr, int a, int sizea, int b, int
 
 	/* Set new port sizes and parameters */
 	ptr->num_input_port_sizes = 3;
-	ptr->input_port_sizes = (int *)malloc(3 * sizeof(int));
+	ptr->input_port_sizes = (int *)calloc(3,sizeof(int));
 	ptr->input_port_sizes[0] = current_sizea;
 	ptr->input_port_sizes[1] = current_sizeb;
 	ptr->input_port_sizes[2] = cin;
 	ptr->num_output_port_sizes = 2;
-	ptr->output_port_sizes = (int *)malloc(2 * sizeof(int));
+	ptr->output_port_sizes = (int *)calloc(2,sizeof(int));
 	ptr->output_port_sizes[0] = cout;
 
 	/* The size of output port sumout equals the maxim size of sizea and sizeb  */
@@ -488,7 +486,7 @@ void init_split_adder(nnode_t *node, nnode_t *ptr, int a, int sizea, int b, int
 
 	/* Set the number of pins and re-locate previous pin entries */
 	ptr->num_input_pins = current_sizea + current_sizeb + cin;
-	ptr->input_pins = (npin_t**)malloc(sizeof(void *) * (current_sizea + current_sizeb + cin));
+	ptr->input_pins = (npin_t**)calloc((current_sizea + current_sizeb + cin),sizeof(npin_t *));
 	//if flaga or flagb = 1, the input pins should be empty.
 	if(flaga == 1)
 	{
@@ -684,7 +682,7 @@ void init_split_adder(nnode_t *node, nnode_t *ptr, int a, int sizea, int b, int
 		output = current_sizeb + cout;
 
 	ptr->num_output_pins = output;
-	ptr->output_pins = (npin_t**)malloc(sizeof(void *) * output);
+	ptr->output_pins = (npin_t**)calloc(output,sizeof(npin_t *));
 	for (i = 0; i < output; i++)
 		ptr->output_pins[i] = NULL;
 
@@ -716,12 +714,12 @@ void split_adder(nnode_t *nodeo, int a, int b, int sizea, int sizeb, int cin, in
 	oassert(nodeo->input_port_sizes[0] == a);
 	oassert(nodeo->input_port_sizes[1] == b);
 
-	node  = (nnode_t**)malloc(sizeof(nnode_t*)*(count));
+	node  = (nnode_t**)calloc((count),sizeof(nnode_t*));
 
 	for(i = 0; i < count; i++)
 	{
 		node[i] = allocate_nnode();
-		node[i]->name = (char *)malloc(strlen(nodeo->name) + 20);
+		node[i]->name = (char *)calloc(strlen(nodeo->name) + 20,sizeof(char));
 		sprintf(node[i]->name, "%s-%d", nodeo->name, i);
 		if(i == count - 1)
 		{

ODIN_II/SRC/allocation_def.h

@@ -0,0 +1,4 @@
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#define ALLOCATE_ME(num, type)	((type *) calloc((num),sizeof(type)))