WIP client for handling SDC commands through libsdcparse (hack)

Signed-off-by: Krzysztof Boronski <[email protected]>

Author: kboronski-ant

vpr/src/base/xdc_constraints.cpp

@@ -4,6 +4,7 @@
 #include <fstream>
 #include <utility>
 #include <functional>
+#include <unordered_set>
 #include <tcl/tcl.h>
 
 #include "globals.h"
@@ -13,6 +14,8 @@
 #include "tclcpp.h"
 #include "xdc_constraints.h"
 
+#include "sdcparse.hpp"
+
 enum class e_XDCProperty {
     XDC_PROP_PACKAGE_PIN,
     XDC_PROP_IOSTANDARD,
@@ -107,7 +110,7 @@ class TclPhysicalConstraintsClient : public TclClient {
         if (pin_name == nullptr)
             return this->_ret_error("set_property: pin_name of PACKAGE_PIN should be a string.");
 
-        auto port_list = tcl_obj_getlist<AtomPortId>(static_cast<TclClient*>(this), tcl_ports);
+        auto port_list = tcl_obj_getlist<AtomPortId>(this, tcl_ports);
         size_t port_count = port_list.size();
         if (port_count != 1)
             return this->_ret_error("set_property PACKAGE_PIN: Expected 1 port, got " + std::to_string(port_count) + ".");
@@ -161,7 +164,7 @@ class TclPhysicalConstraintsClient : public TclClient {
     int _set_property_iostandard(Tcl_Obj* tcl_io_standard, Tcl_Obj* tcl_ports) {
         const char* io_standard = Tcl_GetString(tcl_io_standard);
 
-        auto ports = tcl_obj_getlist<AtomPortId>(static_cast<TclClient*>(this), tcl_ports);
+        auto ports = tcl_obj_getlist<AtomPortId>(this, tcl_ports);
 
         return this->_do_set_property_iostandard(io_standard, ports);
     }
@@ -190,7 +193,7 @@ class TclPhysicalConstraintsClient : public TclClient {
         }
 
         auto port_list = this->_list<AtomPortId, decltype(port_ids)>(this, std::move(port_ids));
-        this->_ret_list<AtomPortId>(reinterpret_cast<void*>(this), port_list);
+        return this->_ret_list<AtomPortId>(reinterpret_cast<void*>(this), port_list);
     }
 
     int _do_get_port(const char* pin_name, AtomPortId* port_) {
@@ -234,6 +237,53 @@ class TclPhysicalConstraintsClient : public TclClient {
     }
 };
 
+class TclSDCLegacyClient : public TclClient {
+  public:
+    TclSDCLegacyClient() {
+        static const std::unordered_set<std::string> sdc_commands({
+            "create_clock",
+            "set_input_delay",
+            "set_output_delay",
+            "set_clock_groups",
+            "set_false_path",
+            "set_max_delay ",
+            "set_min_delay ",
+            "set_multicycle_path",
+            "set_clock_uncertainty",
+            "set_clock_latency ",
+            "set_disable_timing",
+            "set_timing_derate "
+        });
+
+        this->_recognized_sdc_commands = &sdc_commands;
+    }
+
+    template<typename F>
+    void register_methods(F register_method) {
+        register_method("try_sdcparse", &TclSDCLegacyClient::try_sdcparse);
+    }
+
+    int try_sdcparse(int objc, Tcl_Obj* const objvp[]) {
+        if (objc != 2)
+            this->_ret_error("try_sdcparse: wrong number of arguments (" + std::to_string(objc) +"). Expected 2.");
+        
+        Tcl_Obj* cmd_args_obj = objvp[1];
+        
+        TclDynList cmd_args = tcl_obj_getdynlist(this, objvp[1]);
+        if (cmd_args.size() < 2)
+            this->_ret_error("try_sdcparse: command contains no arguments.");
+
+        const char* cmd = Tcl_GetString(cmd_args[1]);
+        if (this->_recognized_sdc_commands->count(std::string(cmd)))
+            this->_ret_error(std::string(cmd) + ": SDC compatibility layer is not implemented yet.");
+        else
+            this->_ret_error("Unrecognized comand " + std::string(cmd) + ".");
+    }
+
+  protected:
+    const std::unordered_set<std::string>* _recognized_sdc_commands;
+};
+
 REGISTER_TCL_TYPE_W_STR_UPDATE(AtomPortId)
 (Tcl_Obj* obj) {
     const auto* port = tcl_obj_getptr<AtomPortId>(obj);
@@ -246,28 +296,40 @@ END_REGISTER_TCL_TYPE;
 VprConstraints read_xdc_constraints_to_vpr(std::vector<XDCStream>&& xdc_streams, const t_arch& arch, AtomNetlist& netlist) {
     VprConstraints constraints;
     TclPhysicalConstraintsClient pc_client(constraints, arch, netlist);
+    TclSDCLegacyClient sdc_client;
 
     TclCtx::with_ctx<void>([&](TclCtx& ctx) {
         /*
          * Tcl by default will interpret bus indices as calls to commands
          * (eg. in[0] gets interpreted as call to command `i` with argument being a
          * result of calling `0`). This overrides this behaviour.
+         * 
+         * Additionally it attempts to call `try_sdcparse` if the command is unknown.
+         * This is used as a workaround for passing sdc_commands to libsdcparse.
          */
-        std::istringstream fix_port_indexing(
+        std::istringstream tcl_setup(
             "rename unknown _original_unknown\n"
             "proc unknown args {\n"
             "  set result [scan [lindex $args 0] \"%d\" value]\n"
             "  if { $result == 1 && [llength $args] == 1 } {\n"
             "    return \\[$value\\]\n"
             "  } else {\n"
-            "    uplevel 1 [list _original_unknown {*}$args]\n"
+            "    set cmd [list _original_unknown {*}$args]\n"
+            "    set was_sdc [try_sdcparse $cmd]\n"
+            "    if { $was_sdc == 1 } {\n"
+            "      return\n"
+            "    } else {\n"
+            "      uplevel 1 $cmd\n"
+            "    }\n"
             "  }\n"
             "}");
-        ctx.read_tcl(fix_port_indexing);
+        ctx.read_tcl(tcl_setup);
 
         /* Add types and commands to handle XDC files */
         ctx.add_tcl_type<AtomPortId>();
         ctx.add_tcl_client<TclPhysicalConstraintsClient>(pc_client);
+        /* Handle unknown commands through TclSDCLegacyClient */
+        ctx.add_tcl_client<TclSDCLegacyClient>(sdc_client);
 
         /* Read and interpret XDCs */
         for (auto& stream : xdc_streams) {