Merge pull request #3 from verilog-to-routing/master

Pull from upstream

Author: jgoeders

.gitignore

@@ -66,6 +66,12 @@ vgcore*
 *.place
 *.route
 *.out
+*.bin
+
+#
+# FASM result files
+#
+*.fasm
 
 #
 #Odin test outputs

.readthedocs.yaml

@@ -7,14 +7,14 @@ version: 2
 
 # Build documentation in the docs/ directory with Sphinx
 sphinx:
-  builder: htmldir
+  builder: dirhtml
   configuration: doc/src/conf.py
 
 # Optionally build your docs in additional formats such as PDF and ePub
 formats: all
 
 # Optionally set the version of Python and requirements required to build your docs
 python:
-  version: 2
+  version: 3.7
   install:
     - requirements: doc/requirements.txt

ODIN_II/CMakeLists.txt

@@ -64,7 +64,9 @@ if(ODIN_COVERAGE)
     )
 
     set(ODIN_EXTRA_LINK_FLAGS
-        "-lgcov --coverage"
+        "-lgcov"
+        "--coverage"
+        ${ODIN_EXTRA_LINK_FLAGS}
     )
 
 endif()
@@ -74,13 +76,23 @@ if(ODIN_SANITIZE)
     message("*** Compiling with Odin Coverage flags")
 
     set(ODIN_EXTRA_FLAGS
-        "-g"
+        "-O1"
+        "-fno-omit-frame-pointer"
         "-fsanitize=address"
+        "-fsanitize=leak"
+        "-fsanitize=undefined"
+        "-fuse-ld=gold"
         ${ODIN_EXTRA_FLAGS}
     )
 
     set(ODIN_EXTRA_LINK_FLAGS
+        "-O1"
+        "-fno-omit-frame-pointer"
         "-fsanitize=address"
+        "-fsanitize=leak"
+        "-fsanitize=undefined"        
+        "-fuse-ld=gold"
+        ${ODIN_EXTRA_LINK_FLAGS}
     )
 
 endif()
@@ -169,10 +181,10 @@ foreach(ODIN_FLAG ${ODIN_EXTRA_FLAGS})
 endforeach()
 
 #add extra link flags for odin
-if(ODIN_EXTRA_LINK_FLAGS)
-    set_target_properties(libodin_ii PROPERTIES LINK_FLAGS ${ODIN_EXTRA_LINK_FLAGS})
-    set_target_properties(odin_II PROPERTIES LINK_FLAGS ${ODIN_EXTRA_LINK_FLAGS})
-endif()
+foreach(ODIN_LINK_FLAG ${ODIN_EXTRA_LINK_FLAGS})
+        target_link_libraries(libodin_ii ${ODIN_LINK_FLAG})
+        target_link_libraries(odin_II ${ODIN_LINK_FLAG})
+endforeach()
 
 #Supress IPO link warnings if IPO is enabled
 get_target_property(ODIN_USES_IPO odin_II INTERPROCEDURAL_OPTIMIZATION)

ODIN_II/README.md

@@ -0,0 +1,15 @@
+Odin_II
+=======
+
+Odin II is used for logic synthesis and elaboration, converting a subset of the Verilog Hardware Description Language (HDL) into a BLIF netlist.
+
+-----------------
+
+* **[Quick Start](../doc/src/odin/quickstart.md)**
+* **[User Guide](../doc/src/odin/user_guide.md)**
+* **[Verilog Support](../doc/src/odin/verilog_support.md)**
+* **Developper guide**
+  * [Contributing](../doc/src/odin/dev_guide/contributing)
+  * [Regression Tests](../doc/src/odin/dev_guide/regression_test)
+  * [Regression Tool](../doc/src/odin/dev_guide/verify_script)
+  * [Validating Tests](../doc/src/odin/dev_guide/testing)

ODIN_II/README.rst

@@ -675,7 +675,7 @@ void split_adder(nnode_t* nodeo, int a, int b, int sizea, int sizeb, int cin, in
     // don't add a dummy adder in the beginning of the chain if the first cin will be connected to a global gnd
     if ((flag == 0 || count > 1) && !configuration.adder_cin_global) {
         //connect the a[0] and b[0] of first adder node to ground
-        connect_nodes(netlist->gnd_node, 0, node[0], 0);
+        connect_nodes(netlist->vcc_node, 0, node[0], 0);
         connect_nodes(netlist->gnd_node, 0, node[0], sizea);
         //hang the first sumout
         node[0]->output_pins[1] = allocate_npin();

ODIN_II/SRC/adders.cpp

@@ -1106,10 +1106,10 @@ ast_node_t* build_hierarchy(ast_node_t* node, ast_node_t* parent, int index, sc_
                 break;
             }
         }
+    }
 
-        if (child_skip_list) {
-            child_skip_list = (short*)vtr::free(child_skip_list);
-        }
+    if (child_skip_list) {
+        child_skip_list = (short*)vtr::free(child_skip_list);
     }
 
     return node;

ODIN_II/SRC/ast_elaborate.cpp

@@ -1322,12 +1322,12 @@ void assert_constant_positionnal_args(ast_node_t* node, long arg_count) {
                       "%s node expects arguments\n", ast_node_name_based_on_ids(node));
     } else if (node->num_children < arg_count) {
         error_message(AST, node->line_number, node->file_number,
-                      "%s node expects %d positional arguments\n", ast_node_name_based_on_ids(node), arg_count);
+                      "%s node expects %ld positional arguments\n", ast_node_name_based_on_ids(node), arg_count);
     } else {
         for (long i = 0; i < arg_count; i += 1) {
             if (!node_is_constant(node->children[i])) {
                 error_message(AST, node->line_number, node->file_number,
-                              "%s node expects a constant at positional arguments [%d]\n", ast_node_name_based_on_ids(node), i);
+                              "%s node expects a constant at positional arguments [%ld]\n", ast_node_name_based_on_ids(node), i);
             }
         }
     }
@@ -1338,39 +1338,52 @@ void assert_constant_positionnal_args(ast_node_t* node, long arg_count) {
  * a simple printf would not be able to do this since escaped characters are compile time
  */
 void c_simple_print(std::string str) {
+    size_t str_size = str.size();
     size_t start = 0;
     while (start != std::string::npos) {
         size_t format_char_index = str.find_first_of('\\', start);
         size_t next_char = format_char_index;
-        printf("%s", str.substr(start, format_char_index).c_str());
+        if (start != format_char_index) {
+            printf("%s", str.substr(start, format_char_index).c_str());
+        }
         // print the string
         if (format_char_index != std::string::npos) {
-            // try and see if its an octal number
-            char buffer[4] = {
-                str[format_char_index + 1],
-                str[format_char_index + 2],
-                str[format_char_index + 3],
-                0};
-            next_char = format_char_index + 4;
-            char* endptr = NULL;
-            char octal_value = (char)strtoul(buffer, &endptr, 8);
-            if (endptr == &buffer[3]) {
-                // if it is an octal number print the octal char
-                printf("%c", octal_value);
-            } else {
-                next_char = format_char_index + 2;
-                switch (str[format_char_index + 1]) {
-                    case 'n':
-                        printf("\n");
-                        break;
-                    case 't':
-                        printf("\t");
-                        break;
-                    default:
+            next_char = format_char_index + 2;
+            switch (str[format_char_index + 1]) {
+                case 'n':
+                    printf("\n");
+                    break;
+                case 't':
+                    printf("\t");
+                    break;
+                default:
+                    // can only be octal if there is 3+ chars following
+                    if ((str_size - 3) >= format_char_index) {
+                        // try and see if its an octal number
+                        char buffer[4] = {
+                            str[format_char_index + 1],
+                            str[format_char_index + 2],
+                            str[format_char_index + 3],
+                            0};
+                        next_char = format_char_index + 4;
+                        char* endptr = NULL;
+                        char octal_value = (char)strtoul(buffer, &endptr, 8);
+                        if (endptr == &buffer[3]) {
+                            // if it is an octal number print the octal char
+                            printf("%c", octal_value);
+                        } else {
+                            // otherwise just print the character
+                            next_char = format_char_index + 2;
+                            printf("%c", str[format_char_index + 1]);
+                            break;
+                        }
+
+                    } else {
                         // otherwise just print the character
+                        next_char = format_char_index + 2;
                         printf("%c", str[format_char_index + 1]);
                         break;
-                }
+                    }
             }
         }
         start = next_char;
@@ -1401,7 +1414,7 @@ void c_display(ast_node_t* node) {
                 printf("%%");
             } else if (!argv_nodes || argc_node >= argv_nodes->num_children || argv_nodes->children[argc_node] == NULL) {
                 error_message(AST, node->children[0]->line_number, node->children[0]->file_number,
-                              "specifier character [%d] has no argument associated with it", argc_node);
+                              "specifier character [%ld] has no argument associated with it", argc_node);
             } else {
                 ast_node_t* argv = argv_nodes->children[argc_node];
                 switch (tolower(format_input[1])) {
@@ -1414,7 +1427,7 @@ void c_display(ast_node_t* node) {
                     case 'b': {
                         if (!node_is_constant(argv)) {
                             error_message(AST, argv->line_number, argv->file_number,
-                                          "specifier character [%d] is not associated with a constant, node is %s",
+                                          "specifier character [%ld] is not associated with a constant, node is %s",
                                           argc_node, ast_node_name_based_on_ids(argv));
                         }
                         printf("%s", argv->types.vnumber->to_vstring(format_input[1]).c_str());
@@ -1440,7 +1453,7 @@ void c_display(ast_node_t* node) {
                     case 't': {
                         if (!node_is_constant(argv)) {
                             error_message(AST, argv->line_number, argv->file_number,
-                                          "specifier character [%d] is not associated with a constant, node is %s",
+                                          "specifier character [%ld] is not associated with a constant, node is %s",
                                           argc_node, ast_node_name_based_on_ids(argv));
                         }
                         // TODO: for now we just print as is

ODIN_II/SRC/ast_util.cpp

@@ -22,6 +22,7 @@ const char* ast_node_name_based_on_ids(ast_node_t* node);
 char* make_signal_name(char* signal_name, int bit);
 char* make_full_ref_name(const char* previous, const char* module_name, const char* module_instance_name, const char* signal_name, long bit);
 char* make_full_name_w_o_array_ref(const char* previous, const char* module_name, const char* module_instance_name);
+bool output_vector_headers_equal(char* buffer1, char* buffer2);
 
 char* twos_complement(char* str);
 int is_string_of_radix(char* string, int radix);

ODIN_II/SRC/include/odin_util.h

@@ -212,9 +212,6 @@ netlist_t* start_odin_ii(int argc, char** argv) {
         zero_string = vtr::strdup(ZERO_GND_ZERO);
         pad_string = vtr::strdup(ZERO_PAD_ZERO);
 
-        printf("--------------------------------------------------------------------\n");
-        printf("Welcome to ODIN II version 0.1 - the better High level synthesis tools++ targetting FPGAs (mainly VPR)\n");
-        printf("Email: [email protected] and [email protected] for support issues\n\n");
     } catch (vtr::VtrError& vtr_error) {
         printf("Odin failed to initialize %s with exit code%d\n", vtr_error.what(), ERROR_INITIALIZATION);
         exit(ERROR_INITIALIZATION);

ODIN_II/SRC/odin_ii.cpp

@@ -909,6 +909,57 @@ void trim_string(char* string, const char* chars) {
     }
 }
 
+/*
+ * Tokenizes a string and returns an array where each element is a 
+ * token and a pointer (that needs to be passed through) with the 
+ * size of the array
+ */
+static char** string_to_token_array(char* string, int* size) {
+    char** arr = NULL;
+
+    char* token = strtok(string, " \n\t");
+    int i = 0;
+
+    while (token != NULL) {
+        arr = (char**)vtr::realloc(arr, sizeof(char*) * (i + 1));
+        arr[i] = token;
+        token = strtok(NULL, " \n\t");
+        i++;
+    }
+    *size = (i);
+    return arr;
+}
+
+/*
+ * Will seperate the headers from the inputs and compare them
+ * Will return value of 1 if they match and 0 if
+ * they don't match. Possible error if the vector headers match
+ * but are in different order
+ */
+bool output_vector_headers_equal(char* buffer1, char* buffer2) {
+    int size1 = 0;
+    int size2 = 0;
+    char* buffer1_copy = strdup(buffer1);
+    char* buffer2_copy = strdup(buffer2);
+
+    char** header1 = string_to_token_array(buffer1_copy, &size1);
+    char** header2 = string_to_token_array(buffer2_copy, &size2);
+
+    int i = 0;
+    bool header_matches;
+
+    header_matches = (size1 == size2);
+    for (i = 0; header_matches && i < (size1 - 1); i++) {
+        header_matches = (0 == strcmp(header1[i], header2[i]));
+    }
+
+    vtr::free(header1);
+    vtr::free(header2);
+    vtr::free(buffer1_copy);
+    vtr::free(buffer2_copy);
+    return (header_matches);
+}
+
 /**
  * verifies only one condition evaluates to true
  */

ODIN_II/SRC/odin_util.cpp

@@ -2727,7 +2727,7 @@ static int verify_output_vectors(const char* output_vector_file, int num_vectors
                 break;
             }
             // The headers differ.
-            else if ((cycle == -1) && strcmp(buffer1, buffer2)) {
+            else if ((cycle == -1) && !output_vector_headers_equal(buffer1, buffer2)) {
                 error = true;
                 warning_message(SIMULATION, 0, -1,
                                 "Vector headers do not match: \n"

ODIN_II/SRC/simulate_blif.cpp

@@ -42,6 +42,8 @@ int yywrap(){	return 1;}
 int yylex(void);
 
 %}
+/* give detailed errors */
+%define parse.error verbose
 
 %locations
 

ODIN_II/SRC/verilog_bison.y

@@ -167,20 +167,26 @@ function display() {
 	LEAK_MESSAGE=""
 
 	# check for valgrind leaks
-	LEAK_COUNT="$(cat ${LOG_FILE} | grep 'ERROR SUMMARY:' | awk '{print $4}' | grep -E '^\-?[0-9]+$')"
+	VALGRIND_LEAK_COUNT="$(cat ${LOG_FILE} | grep 'ERROR SUMMARY:' | awk '{print $4}' | grep -E '^\-?[0-9]+$')"
+	# check for LSAN leaks
+	LSAN_LEAK_COUNT="$(cat ${LOG_FILE} | grep 'SUMMARY: AddressSanitizer:' | awk '{print $7}' | grep -E '^\-?[0-9]+$')"
+
+	LEAK_COUNT=$(( VALGRIND_LEAK_COUNT + LSAN_LEAK_COUNT ))
+
 	case "_${LEAK_COUNT}" in
 		_|_0)	LEAK_MESSAGE=""
 		;;_1)	LEAK_MESSAGE="[${LEAK_COUNT}]Leak "
 		;;*)	LEAK_MESSAGE="[${LEAK_COUNT}]Leaks "
 	esac
 
 	# check for uncaught errors
-
 	ERROR_CATCH="$(cat "${LOG_FILE}" | grep 'Odin exited with code: ' | awk '{print $5}' | grep -E '^\-?[0-9]+$')"
 	[ "_${ERROR_CATCH}" != "_" ] && EXIT_CODE="${ERROR_CATCH}"
 
 	EXIT_ERROR_TYPE=$( print_exit_type "${EXIT_CODE}" )
 
+	MISMATCH_CHECK="$(cat "${LOG_FILE}" | grep "Error::OUTPUT_BLIF Vector files differ.")"
+	[ "_${MISMATCH_CHECK}" != "_" ] && EXIT_ERROR_TYPE="MISMATCH"
 
 	if [ "_${EXIT_CODE}" == "_0" ] && [ "_${LEAK_MESSAGE}" == "_" ]
 	then

ODIN_II/exec_wrapper.sh

@@ -1,9 +1,32 @@
 #include "odin_ii.h"
 #include "odin_types.h"
 #include "vtr_time.h"
+#include "vtr_version.h"
 
 int main(int argc, char** argv) {
     vtr::ScopedFinishTimer t("Odin II");
+
+    printf(
+        "=======================================================================\n"
+        " Odin II - Verilog synthesis tools targetting VPR FPGAs\n"
+        "-----------------------------------------------------------------------\n"
+        "\tVersion: %s\n"
+        "\tRevision: %s\n"
+        "\tCompiled: %s\n"
+        "\tCompiler: %s\n"
+        "\tBuild Info: %s\n"
+        "\n"
+        "University of New Brunswick\n"
+        "For documentation:\n"
+        "  https://docs.verilogtorouting.org/en/latest/odin\n"
+        "For question:\n"
+        "  [email protected]\n"
+        "\n"
+        "This is free open source code under MIT license.\n"
+        "=======================================================================\n"
+        "\n",
+        vtr::VERSION, vtr::VCS_REVISION, vtr::BUILD_TIMESTAMP, vtr::COMPILER, vtr::BUILD_INFO);
+
     netlist_t* odin_netlist = start_odin_ii(argc, argv);
     terminate_odin_ii(odin_netlist);
     return 0;