Merge pull request #491 from SymbiFlow/new-master-wip

New master wip

Author: litghost

ODIN_II/Makefile

@@ -112,16 +112,30 @@ test:
 	./verify_odin.sh -j $(NB_OF_PROCESS) \
 		-t regression_test/benchmark/suite/heavy_suite
 
-qor:
+generate_expectation:
 # rebuild with sanitize flags on to run the same test as travis
-	$(MAKE) sanitize
+	$(MAKE) sanitize 
 	./verify_odin.sh -j $(NB_OF_PROCESS) \
-		--regenerate_qor \
+		--generate_expectation\
 		-t regression_test/benchmark/suite/light_suite \
 		-t vtr_reg_basic \
-		-t vtr_reg_strong
-# larger test should run with regular flags to speed up the process
+		-t vtr_reg_strong || true
+ # larger test should run with regular flags to speed up the process
+	$(MAKE) build
+	./verify_odin.sh -j $(NB_OF_PROCESS) \
+		--generate_expectation \
+		-t regression_test/benchmark/suite/heavy_suite
+
+regenerate_expectation:
+# rebuild with sanitize flags on to run the same test as travis
+	$(MAKE) sanitize 
+	./verify_odin.sh -j $(NB_OF_PROCESS) \
+		--regenerate_expectation\
+		-t regression_test/benchmark/suite/light_suite \
+		-t vtr_reg_basic \
+		-t vtr_reg_strong || true
+ # larger test should run with regular flags to speed up the process
 	$(MAKE) build
 	./verify_odin.sh -j $(NB_OF_PROCESS) \
-		--regenerate_qor \
+		--regenerate_expectation \
 		-t regression_test/benchmark/suite/heavy_suite

ODIN_II/SRC/adders.cpp

@@ -146,7 +146,7 @@ void declare_hard_adder(nnode_t* node) {
 
     /* See if this size instance of adder exists? */
     if (hard_adders == NULL)
-        warning_message(NETLIST_ERROR, node->related_ast_node->line_number, node->related_ast_node->file_number, "%s\n", "Instantiating adder where adders do not exist");
+        warning_message(NETLIST, node->related_ast_node->line_number, node->related_ast_node->file_number, "%s\n", "Instantiating adder where adders do not exist");
 
     tmp = (t_adder*)hard_adders->instances;
     width_a = node->input_port_sizes[0];

ODIN_II/SRC/ast_elaborate.cpp

@@ -129,25 +129,25 @@ ast_node_t* resolve_for(ast_node_t* node) {
 
     ast_node_t* value = 0;
     if (resolve_pre_condition(pre, &value)) {
-        error_message(PARSE_ERROR, pre->line_number, pre->file_number, "%s", "Unsupported pre-condition node in for loop");
+        error_message(AST, pre->line_number, pre->file_number, "%s", "Unsupported pre-condition node in for loop");
     }
 
     int error_code = 0;
     condition_function cond_func = resolve_condition(cond, pre->children[0], &error_code);
     if (error_code) {
-        error_message(PARSE_ERROR, cond->line_number, cond->file_number, "%s", "Unsupported condition node in for loop");
+        error_message(AST, cond->line_number, cond->file_number, "%s", "Unsupported condition node in for loop");
     }
 
     post_condition_function post_func = resolve_post_condition(post, pre->children[0], &error_code);
     if (error_code) {
-        error_message(PARSE_ERROR, post->line_number, post->file_number, "%s", "Unsupported post-condition node in for loop");
+        error_message(AST, post->line_number, post->file_number, "%s", "Unsupported post-condition node in for loop");
     }
 
     bool dup_body = cond_func(value->types.vnumber->get_value());
     while (dup_body) {
         ast_node_t* new_body = dup_and_fill_body(body, pre, &value, &error_code);
         if (error_code) {
-            error_message(PARSE_ERROR, pre->line_number, pre->file_number, "%s", "Unsupported pre-condition node in for loop");
+            error_message(AST, pre->line_number, pre->file_number, "%s", "Unsupported pre-condition node in for loop");
         }
 
         VNumber* temp_vnum = value->types.vnumber;

ODIN_II/SRC/ast_loop_unroll.cpp

@@ -396,7 +396,7 @@ void make_concat_into_list_of_strings(ast_node_t* concat_top, char* instance_nam
             char* temp_string = make_full_ref_name(NULL, NULL, NULL, concat_top->children[i]->types.identifier, -1);
             ast_node_t* var_declare = resolve_hierarchical_name_reference(local_ref, temp_string);
             if (var_declare == NULL) {
-                error_message(NETLIST_ERROR, concat_top->line_number, concat_top->file_number, "Missing declaration of this symbol %s\n", temp_string);
+                error_message(AST, concat_top->line_number, concat_top->file_number, "Missing declaration of this symbol %s\n", temp_string);
             } else {
                 if (var_declare->children[1] == NULL) {
                     concat_top->types.concat.num_bit_strings++;
@@ -445,7 +445,7 @@ void make_concat_into_list_of_strings(ast_node_t* concat_top, char* instance_nam
                     concat_top->types.concat.bit_strings[concat_top->types.concat.num_bit_strings - 1] = get_name_of_pin_at_bit(concat_top->children[i], j, instance_name_prefix, local_ref);
                 }
             } else {
-                error_message(NETLIST_ERROR, concat_top->line_number, concat_top->file_number, "%s", "Unsized constants cannot be concatenated.\n");
+                error_message(AST, concat_top->line_number, concat_top->file_number, "%s", "Unsized constants cannot be concatenated.\n");
             }
         } else if (concat_top->children[i]->type == CONCATENATE) {
             /* forward through list since we build concatenate list in idx order of MSB at index 0 and LSB at index list_size */
@@ -455,7 +455,7 @@ void make_concat_into_list_of_strings(ast_node_t* concat_top, char* instance_nam
                 concat_top->types.concat.bit_strings[concat_top->types.concat.num_bit_strings - 1] = get_name_of_pin_at_bit(concat_top->children[i], j, instance_name_prefix, local_ref);
             }
         } else {
-            error_message(NETLIST_ERROR, concat_top->line_number, concat_top->file_number, "%s", "Unsupported operation within a concatenation.\n");
+            error_message(AST, concat_top->line_number, concat_top->file_number, "%s", "Unsupported operation within a concatenation.\n");
         }
     }
 }
@@ -555,7 +555,7 @@ char* get_name_of_pin_at_bit(ast_node_t* var_node, int bit, char* instance_name_
         int pin_index = 0;
 
         if ((symbol_node = resolve_hierarchical_name_reference(local_ref, var_node->types.identifier)) == NULL) {
-            error_message(NETLIST_ERROR, var_node->line_number, var_node->file_number, "Missing declaration of this symbol %s\n", var_node->types.identifier);
+            error_message(AST, var_node->line_number, var_node->file_number, "Missing declaration of this symbol %s\n", var_node->types.identifier);
         }
 
         if (symbol_node->children[1] == NULL) {
@@ -590,7 +590,7 @@ char* get_name_of_pin_at_bit(ast_node_t* var_node, int bit, char* instance_name_
     } else {
         return_string = NULL;
 
-        error_message(NETLIST_ERROR, var_node->line_number, var_node->file_number, "Unsupported variable type. var_node->type = %s\n", ast_node_name_based_on_ids(var_node));
+        error_message(AST, var_node->line_number, var_node->file_number, "Unsupported variable type. var_node->type = %s\n", ast_node_name_based_on_ids(var_node));
     }
 
     return return_string;
@@ -630,7 +630,7 @@ char* get_name_of_pin_number(ast_node_t* var_node, int bit) {
             return_string = vtr::strdup(ZERO_PAD_ZERO);
             break;
         default:
-            error_message(NETLIST_ERROR, var_node->line_number, var_node->file_number, "Unrecognised character %c in binary string \"%s\"!\n", c, var_node->types.vnumber->to_bit_string().c_str());
+            error_message(AST, var_node->line_number, var_node->file_number, "Unrecognised character %c in binary string \"%s\"!\n", c, var_node->types.vnumber->to_bit_string().c_str());
             break;
     }
 
@@ -680,7 +680,7 @@ char_list_t* get_name_of_pins(ast_node_t* var_node, char* instance_name_prefix,
         ast_node_t* sym_node = resolve_hierarchical_name_reference(local_ref, temp_string);
 
         if (sym_node == NULL) {
-            error_message(NETLIST_ERROR, var_node->line_number, var_node->file_number, "Missing declaration of this symbol %s\n", temp_string);
+            error_message(AST, var_node->line_number, var_node->file_number, "Missing declaration of this symbol %s\n", temp_string);
         }
 
         vtr::free(temp_string);
@@ -780,7 +780,7 @@ long get_size_of_variable(ast_node_t* node, sc_hierarchy* local_ref) {
                 if (node_is_constant(var_declare)) {
                     assignment_size = var_declare->types.vnumber->size();
                 } else {
-                    error_message(NETLIST_ERROR, node->line_number, node->file_number, "Parameter %s is not a constant expression\n", node->types.identifier);
+                    error_message(AST, node->line_number, node->file_number, "Parameter %s is not a constant expression\n", node->types.identifier);
                 }
 
                 free_whole_tree(var_declare);
@@ -793,7 +793,7 @@ long get_size_of_variable(ast_node_t* node, sc_hierarchy* local_ref) {
                 break;
             }
 
-            error_message(NETLIST_ERROR, node->line_number, node->file_number, "Missing declaration of this symbol %s\n", node->types.identifier);
+            error_message(AST, node->line_number, node->file_number, "Missing declaration of this symbol %s\n", node->types.identifier);
         } break;
 
         case ARRAY_REF: {
@@ -803,7 +803,7 @@ long get_size_of_variable(ast_node_t* node, sc_hierarchy* local_ref) {
                 break;
             }
 
-            error_message(NETLIST_ERROR, node->children[0]->line_number, node->children[0]->file_number, "Missing declaration of this symbol %s\n", node->children[0]->types.identifier);
+            error_message(AST, node->children[0]->line_number, node->children[0]->file_number, "Missing declaration of this symbol %s\n", node->children[0]->types.identifier);
         } break;
 
         case RANGE_REF: {
@@ -982,13 +982,13 @@ static void check_binary_operation(ast_node_t** node) {
                 break;
             case DIVIDE:
                 if (!node_is_constant((*node)->children[1]))
-                    error_message(NETLIST_ERROR, (*node)->line_number, (*node)->file_number, "%s", "Odin only supports constant expressions as divisors\n");
+                    error_message(AST, (*node)->line_number, (*node)->file_number, "%s", "Odin only supports constant expressions as divisors\n");
                 if ((*node)->children[0]->type == IDENTIFIERS && (*node)->children[1]->type == NUMBERS)
                     check_node_number((*node), (*node)->children[1], 3); // 3 means divide
                 break;
             case POWER:
                 if (!node_is_constant((*node)->children[1]))
-                    error_message(NETLIST_ERROR, (*node)->line_number, (*node)->file_number, "%s", "Odin only supports constant expressions as exponents\n");
+                    error_message(AST, (*node)->line_number, (*node)->file_number, "%s", "Odin only supports constant expressions as exponents\n");
                 expand_power(node);
                 break;
             default:
@@ -1068,7 +1068,7 @@ ast_node_t* fold_unary(ast_node_t** node) {
 
             case CLOG2:
                 if (voperand_0.size() > ODIN_STD_BITWIDTH)
-                    warning_message(PARSE_ERROR, (*node)->line_number, (*node)->file_number, "argument is %ld-bits but ODIN limit is %lu-bits \n", voperand_0.size(), ODIN_STD_BITWIDTH);
+                    warning_message(AST, (*node)->line_number, (*node)->file_number, "argument is %ld-bits but ODIN limit is %lu-bits \n", voperand_0.size(), ODIN_STD_BITWIDTH);
 
                 vresult = VNumber(clog2(voperand_0.get_value(), voperand_0.size()));
                 success = true;
@@ -1094,7 +1094,7 @@ ast_node_t* fold_unary(ast_node_t** node) {
         }
     } else if (op_id == CLOG2) {
         /* $clog2() argument must be a constant expression */
-        error_message(PARSE_ERROR, (*node)->line_number, current_parse_file, "%s", "Argument must be constant\n");
+        error_message(AST, (*node)->line_number, current_parse_file, "%s", "Argument must be constant\n");
     }
 
     return NULL;
@@ -1350,13 +1350,13 @@ long resolve_concat_sizes(ast_node_t* node_top, sc_hierarchy* local_ref) {
             case NUMBERS: {
                 /* verify that the number that this represents is sized */
                 if (!(node_top->types.vnumber->is_defined_size())) {
-                    error_message(NETLIST_ERROR, node_top->line_number, node_top->file_number, "%s", "Unsized constants cannot be concatenated.\n");
+                    error_message(AST, node_top->line_number, node_top->file_number, "%s", "Unsized constants cannot be concatenated.\n");
                 }
                 concatenation_size += node_top->types.vnumber->size();
             } break;
 
             default: {
-                error_message(NETLIST_ERROR, node_top->line_number, node_top->file_number, "%s", "Unsupported operation within a concatenation.\n");
+                error_message(AST, node_top->line_number, node_top->file_number, "%s", "Unsupported operation within a concatenation.\n");
             }
         }
     }

ODIN_II/SRC/ast_util.cpp

@@ -148,7 +148,7 @@ void define_hard_block(nnode_t* node, FILE* out) {
             && 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_ERROR, -1, -1, "Signal %s is not driven. padding with ground\n", node->input_pins[i]->name);
+            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]);
         }
 

ODIN_II/SRC/hard_blocks.cpp

@@ -115,7 +115,7 @@ implicit_memory* create_implicit_memory_block(int data_width, long memory_depth,
 
     //verify if it is a power of two (only one bit set)
     if ((memory_depth != real_memory_depth)) {
-        warning_message(NETLIST_ERROR, -1, -1, "Rounding memory <%s> of size <%ld> to closest power of two: %ld.", name, memory_depth, real_memory_depth);
+        warning_message(NETLIST, -1, -1, "Rounding memory <%s> of size <%ld> to closest power of two: %ld.", name, memory_depth, real_memory_depth);
         memory_depth = real_memory_depth;
     }
 
@@ -183,7 +183,7 @@ void register_implicit_memory_input(char* name, implicit_memory* memory) {
     if (!lookup_implicit_memory_input(name))
         implicit_memory_inputs.insert({std::string(name), memory});
     else
-        error_message(NETLIST_ERROR, -1, -1, "Attempted to re-register implicit memory output %s.", name);
+        error_message(NETLIST, -1, -1, "Attempted to re-register implicit memory output %s.", name);
 }
 
 /*
@@ -288,7 +288,7 @@ void finalize_implicit_memory(implicit_memory* memory) {
 
     if (!has_clk) {
         add_dummy_input_port_to_implicit_memory(memory, 1, "clk");
-        warning_message(NETLIST_ERROR, -1, -1, "Implicit memory %s is not clocked. Padding clock pin.", memory->name);
+        warning_message(NETLIST, -1, -1, "Implicit memory %s is not clocked. Padding clock pin.", memory->name);
     }
 
     char has_port1 = has_addr1 || has_data1 || has_we1 || has_out1;
@@ -312,7 +312,7 @@ void finalize_implicit_memory(implicit_memory* memory) {
         collapse_implicit_memory_to_single_port_ram(memory);
 
     if (!has_port1 && !has_port2) {
-        warning_message(NETLIST_ERROR, -1, -1, "Implicit memory %s has no ports...", memory->name);
+        warning_message(NETLIST, -1, -1, "Implicit memory %s has no ports...", memory->name);
     } else {
         /*
          *  If this hard block is supported, register it globally and mark

ODIN_II/SRC/implicit_memory.cpp

@@ -8,22 +8,20 @@
 
 enum odin_error {
     NO_ERROR,
-    /* for error during odin bootup */
-    ARG_ERROR,
-    /* for parsing and AST creation errors */
-    PARSE_ERROR,
-    /* for netlist creation oerrors */
-    NETLIST_ERROR,
-    /* for blif read errors */
-    BLIF_ERROR,
-    /* for errors in netlist (clustered after tvpack) errors */
-    NETLIST_FILE_ERROR,
-    /* for errors in activation estimateion creation */
-    ACTIVATION_ERROR,
+    /* for error in utility functions*/
+    UTIL,
+    /* for error during initialization */
+    PARSE_ARGS,
+    /* for parser errors */
+    PARSER,
+    /* for AST related errors */
+    AST,
+    /* for Netlist related errors */
+    NETLIST,
+    /* for blif parser errors */
+    PARSE_BLIF,
     /* for errors in the netlist simulation */
-    SIMULATION_ERROR,
-    /* for error in ACE */
-    ACE,
+    SIMULATION,
 };
 
 extern const char* odin_error_STR[];
@@ -44,20 +42,20 @@ static inline void _verbose_assert(bool condition, const char* condition_str, co
 void _log_message(odin_error error_type, long column, long line_number, long file, bool soft_error, const char* function_file_name, long function_line, const char* function_name, const char* message, ...);
 
 #define error_message(error_type, line_number, file, message, ...) \
-    _log_message(error_type, -1, line_number, file, false, __FILE__, __LINE__, __func__, message, __VA_ARGS__)
+    _log_message(error_type, -1, line_number, file, true, __FILE__, __LINE__, __func__, message, __VA_ARGS__)
 
 #define warning_message(error_type, line_number, file, message, ...) \
-    _log_message(error_type, -1, line_number, file, true, __FILE__, __LINE__, __func__, message, __VA_ARGS__)
+    _log_message(error_type, -1, line_number, file, false, __FILE__, __LINE__, __func__, message, __VA_ARGS__)
 
 #define possible_error_message(error_type, line_number, file, message, ...) \
-    _log_message(error_type, -1, line_number, file, global_args.permissive.value(), __FILE__, __LINE__, __func__, message, __VA_ARGS__)
+    _log_message(error_type, -1, line_number, file, !global_args.permissive.value(), __FILE__, __LINE__, __func__, message, __VA_ARGS__)
 
-#define delayed_error_message(error_type, column, line_number, file, message, ...)                                     \
-    {                                                                                                                  \
-        _log_message(error_type, column, line_number, file, true, __FILE__, __LINE__, __func__, message, __VA_ARGS__); \
-        delayed_errors += 1;                                                                                           \
+#define delayed_error_message(error_type, column, line_number, file, message, ...)                                      \
+    {                                                                                                                   \
+        _log_message(error_type, column, line_number, file, false, __FILE__, __LINE__, __func__, message, __VA_ARGS__); \
+        delayed_errors += 1;                                                                                            \
     }
 
-void verify_delayed_error();
+void verify_delayed_error(odin_error error_type);
 
 #endif