siliconcompiler 0.34.2__py3-none-any.whl → 0.34.3__py3-none-any.whl

siliconcompiler/tools/bambu/__init__.py

@@ -16,6 +16,47 @@ Installation: https://panda.dei.polimi.it/?page_id=88
 
 from siliconcompiler.tools.bambu import convert
 
+from siliconcompiler import StdCellLibrarySchema
+
+
+class BambuStdCellLibrary(StdCellLibrarySchema):
+    """
+    Schema for a standard cell library specifically for the Bambu tool.
+
+    This class extends the base StdCellLibrarySchema to define and manage
+    tool-specific parameters required by Bambu, such as the device name
+    and a clock multiplier factor.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+        self.define_tool_parameter("bambu", "device", "str",
+                                   "name of the target device for bambu.")
+        self.define_tool_parameter("bambu", "clock_multiplier", "float",
+                                   "scalar facto to convert from library units to ns.")
+
+    def set_bambu_device_name(self, name):
+        """
+        Sets the name of the device to be used with the Bambu tool.
+
+        Args:
+            name (str): The name of the device.
+        """
+        self.set("tool", "bambu", "device", name)
+
+    def set_bambu_clock_multiplier(self, factor):
+        """
+        Sets the clock multiplier factor for the Bambu tool.
+
+        This factor is used to convert timing values from the standard
+        cell library's units to nanoseconds.
+
+        Args:
+            factor (float): The scalar factor for the clock conversion.
+        """
+        self.set("tool", "bambu", "clock_multiplier", factor)
+
 
 ####################################################################
 # Make Docs

siliconcompiler/tools/builtin/concatenate.py

@@ -3,7 +3,7 @@ import os
 from siliconcompiler import sc_open, SiliconCompilerError
 from siliconcompiler import utils
 from siliconcompiler.tools._common import input_provides, input_file_node_name, get_tool_task
-from siliconcompiler.scheduler.schedulernode import SchedulerNode
+from siliconcompiler.scheduler import SchedulerNode
 
 
 def make_docs(chip):
@@ -66,7 +66,7 @@ def _gather_outputs(chip, step, index):
     for in_step, in_index in in_nodes:
         in_tool, in_task = get_tool_task(chip, in_step, in_index, flow=flow)
         task_class = chip.get("tool", in_tool, "task", in_task, field="schema")
-        with task_class.runtime(chip, step=in_step, index=in_index) as task:
+        with task_class.runtime(SchedulerNode(chip, in_step, in_index)) as task:
             in_task_outputs.append(task.get_output_files())
 
     if len(in_task_outputs) > 0:

siliconcompiler/tools/builtin/minimum.py

@@ -1,6 +1,7 @@
 from siliconcompiler.tools.builtin import _common
 from siliconcompiler.tools.builtin.builtin import set_io_files
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.scheduler import SchedulerNode
 
 
 def setup(chip):
@@ -45,7 +46,7 @@ def _gather_outputs(chip, step, index):
     for in_step, in_index in in_nodes:
         in_tool, in_task = get_tool_task(chip, in_step, in_index, flow=flow)
         task_class = chip.get("tool", in_tool, "task", in_task, field="schema")
-        with task_class.runtime(chip, step=in_step, index=in_index) as task:
+        with task_class.runtime(SchedulerNode(chip, in_step, in_index)) as task:
             in_task_outputs.append(task.get_output_files())
 
     if len(in_task_outputs) > 0:

siliconcompiler/tools/builtin/mux.py

@@ -3,6 +3,7 @@ import re
 from siliconcompiler.tools.builtin.builtin import set_io_files
 from siliconcompiler import SiliconCompilerError
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.scheduler import SchedulerNode
 
 
 def setup(chip):
@@ -59,7 +60,7 @@ def _gather_outputs(chip, step, index):
     for in_step, in_index in in_nodes:
         in_tool, in_task = get_tool_task(chip, in_step, in_index, flow=flow)
         task_class = chip.get("tool", in_tool, "task", in_task, field="schema")
-        with task_class.runtime(chip, step=in_step, index=in_index) as task:
+        with task_class.runtime(SchedulerNode(chip, in_step, in_index)) as task:
             in_task_outputs.append(task.get_output_files())
 
     if len(in_task_outputs) > 0:

siliconcompiler/tools/builtin/nop.py

@@ -1,6 +1,7 @@
 from siliconcompiler.tools.builtin import _common
 from siliconcompiler.tools.builtin.builtin import set_io_files
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.scheduler import SchedulerNode
 
 
 def setup(chip):
@@ -26,7 +27,7 @@ def _gather_outputs(chip, step, index):
     for in_step, in_index in in_nodes:
         in_tool, in_task = get_tool_task(chip, in_step, in_index, flow=flow)
         task_class = chip.get("tool", in_tool, "task", in_task, field="schema")
-        with task_class.runtime(chip, step=in_step, index=in_index) as task:
+        with task_class.runtime(SchedulerNode(chip, in_step, in_index)) as task:
             in_task_outputs.append(task.get_output_files())
 
     if len(in_task_outputs) > 0:

siliconcompiler/tools/builtin/verify.py

@@ -3,6 +3,7 @@ from siliconcompiler.schema.parametertype import NodeType
 from siliconcompiler.tools.builtin.builtin import set_io_files
 from siliconcompiler import utils, SiliconCompilerError
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.scheduler import SchedulerNode
 
 import re
 
@@ -71,7 +72,7 @@ def _gather_outputs(chip, step, index):
     for in_step, in_index in in_nodes:
         in_tool, in_task = get_tool_task(chip, in_step, in_index, flow=flow)
         task_class = chip.get("tool", in_tool, "task", in_task, field="schema")
-        with task_class.runtime(chip, step=in_step, index=in_index) as task:
+        with task_class.runtime(SchedulerNode(chip, in_step, in_index)) as task:
             in_task_outputs.append(task.get_output_files())
 
     if len(in_task_outputs) > 0:

siliconcompiler/tools/klayout/__init__.py

@@ -0,0 +1,95 @@
+from typing import List, Union
+
+from siliconcompiler import StdCellLibrarySchema
+from siliconcompiler import PDKSchema
+
+
+class KLayoutPDK(PDKSchema):
+    """
+    Schema for defining technology-specific parameters for the KLayout tool.
+
+    This class extends the base PDKSchema to manage settings related to
+    KLayout, such as stream units and which layers to hide on initial display.
+    """
+    def __init__(self):
+        super().__init__()
+
+        self.define_tool_parameter("klayout", "units", "float",
+                                   "The stream units for KLayout.")
+        self.define_tool_parameter("klayout", "hide_layers", "{str}",
+                                   "A list of layer names to initially hide when "
+                                   "displaying a layout.")
+        self.define_tool_parameter("klayout", "drc_params", "{(str,str)}",
+                                   "Set of parameters to include for a particular drc deck, in the "
+                                   "form (deck name, parameter).")
+
+    def set_klayout_units(self, units: float):
+        """
+        Sets the stream units for KLayout.
+
+        Args:
+            units (float): The stream unit value.
+        """
+        self.set("tool", "klayout", "units", units)
+
+    def add_klayout_hidelayers(self, layer: Union[str, List[str]], clobber: bool = False):
+        """
+        Adds one or more layers to the list of layers to be hidden.
+
+        Args:
+            layer (Union[str, List[str]]): The layer name or a list of layer names.
+            clobber (bool, optional): If True, overwrites the existing list of hidden layers.
+                                      If False, appends to the list. Defaults to False.
+        """
+        if clobber:
+            self.set("tool", "klayout", "hide_layers", layer)
+        else:
+            self.add("tool", "klayout", "hide_layers", layer)
+
+    def add_klayout_drcparam(self, deck: str, param: Union[str, List[str]], clobber: bool = False):
+        """
+        Adds one or more parameter to the DRC deck definition.
+
+        Args:
+            deck (str): name of the DRC deck.
+            param (Union[str, List[str]]): Parameters for a the specified deck.
+            clobber (bool, optional): If True, overwrites the existing list of parameters.
+                                      If False, appends to the list. Defaults to False.
+        """
+        if isinstance(param, str):
+            param = [param]
+        if clobber:
+            self.unset("tool", "klayout", "drc_params")
+
+        for p in param:
+            self.add("tool", "klayout", "drc_params", (deck, p))
+
+
+class KLayoutLibrary(StdCellLibrarySchema):
+    """
+    Schema for defining standard cell library parameters for the KLayout tool.
+
+    This class extends the base StdCellLibrarySchema to manage settings for
+    KLayout, such as defining cells that are allowed to be missing from the
+    final stream file without generating an error.
+    """
+    def __init__(self):
+        super().__init__()
+
+        self.define_tool_parameter("klayout", "allow_missing_cell", "{str}",
+                                   "A list of cells that are allowed to be empty "
+                                   "in the final stream file.")
+
+    def add_klayout_allowmissingcell(self, cell: Union[str, List[str]], clobber: bool = False):
+        """
+        Adds one or more cell names to the list of cells allowed to be missing.
+
+        Args:
+            cell (Union[str, List[str]]): The cell name or a list of cell names.
+            clobber (bool, optional): If True, overwrites the existing list.
+                                      If False, appends to the list. Defaults to False.
+        """
+        if clobber:
+            self.set("tool", "klayout", "allow_missing_cell", cell)
+        else:
+            self.add("tool", "klayout", "allow_missing_cell", cell)

siliconcompiler/tools/openroad/__init__.py

@@ -12,6 +12,295 @@ Installation: https://github.com/The-OpenROAD-Project/OpenROAD
 '''
 from siliconcompiler.tools._common import get_tool_task
 
+from typing import List, Union
+
+from siliconcompiler.library import StdCellLibrarySchema
+from siliconcompiler.pdk import PDKSchema
+
+
+class OpenROADPDK(PDKSchema):
+    """
+    Schema for defining technology-specific parameters for the OpenROAD tool.
+
+    This class extends the base PDKSchema to manage various settings related
+    to physical design, such as routing layers, pin layers, and global
+    routing derating factors, specifically for the OpenROAD tool.
+    """
+    def __init__(self):
+        super().__init__()
+
+        self.define_tool_parameter("openroad", "rclayer_signal", "str",
+                                   "The name of the signal layer to be used for RC extraction.")
+        self.define_tool_parameter("openroad", "rclayer_clock", "str",
+                                   "The name of the clock layer to be used for RC extraction.")
+
+        self.define_tool_parameter("openroad", "pin_layer_horizontal", "[str]",
+                                   "A list of layers designated for horizontal pins.")
+        self.define_tool_parameter("openroad", "pin_layer_vertical", "[str]",
+                                   "A list of layers designated for vertical pins.")
+
+        self.define_tool_parameter("openroad", "globalroutingderating", "{(str,float)}",
+                                   "A set of layer-specific derating factors for global routing.")
+
+        self.define_tool_parameter("openroad", "rcx_maxlayer", "str",
+                                   "Max layer to generate an OpenRCX extraction bench for.")
+
+    def set_openroad_rclayers(self, signal: str = None, clock: str = None):
+        """
+        Sets the signal and/or clock layers for RC extraction.
+
+        Args:
+            signal (str, optional): The name of the signal layer. Defaults to None.
+            clock (str, optional): The name of the clock layer. Defaults to None.
+        """
+        if signal:
+            self.set("tool", "openroad", "rclayer_signal", signal)
+        if clock:
+            self.set("tool", "openroad", "rclayer_clock", clock)
+
+    def unset_openroad_globalroutingderating(self):
+        """
+        Unsets the global routing derating parameter.
+        """
+        self.unset("tool", "openroad", "globalroutingderating")
+
+    def set_openroad_globalroutingderating(self, layer: str, derating: float,
+                                           clobber: bool = False):
+        """
+        Sets a global routing derating factor for a specific layer.
+
+        Args:
+            layer (str): The name of the layer.
+            derating (float): The derating factor to apply.
+            clobber (bool, optional): If True, overwrites the existing derating factor for the
+                                      layer.
+                                      If False, adds a new derating factor. Defaults to False.
+        """
+        if clobber:
+            return self.set("tool", "openroad", "globalroutingderating", (layer, derating))
+        else:
+            return self.add("tool", "openroad", "globalroutingderating", (layer, derating))
+
+    def add_openroad_pinlayers(self,
+                               horizontal: Union[str, List[str]] = None,
+                               vertical: Union[str, List[str]] = None,
+                               clobber: bool = False):
+        """
+        Adds horizontal and/or vertical pin layers.
+
+        Args:
+            horizontal (Union[str, List[str]], optional): The horizontal pin layer(s) to add.
+                    Defaults to None.
+            vertical (Union[str, List[str]], optional): The vertical pin layer(s) to add.
+                Defaults to None.
+            clobber (bool, optional): If True, overwrites the existing lists. Defaults to False.
+        """
+        if clobber:
+            if horizontal:
+                self.set("tool", "openroad", "pin_layer_horizontal", horizontal)
+            if vertical:
+                self.set("tool", "openroad", "pin_layer_vertical", vertical)
+        else:
+            if horizontal:
+                self.add("tool", "openroad", "pin_layer_horizontal", horizontal)
+            if vertical:
+                self.add("tool", "openroad", "pin_layer_vertical", vertical)
+
+    def set_openroad_rcxmaxlayer(self, layer: str):
+        """
+        Sets the maximum layer for OpenRCX extraction bench generation.
+
+        This parameter defines the highest routing layer to be considered during
+        RC extraction.
+
+        Args:
+            layer (str): The name of the top-most layer to be used for RC extraction.
+        """
+        self.set("tool", "openroad", "rcx_maxlayer", layer)
+
+
+class OpenROADStdCellLibrary(StdCellLibrarySchema):
+    """
+    Schema for defining standard cell library parameters for the OpenROAD tool.
+
+    This class extends the base StdCellLibrarySchema to manage various settings
+    related to physical design, such as tie cells, placement settings, routing,
+    and power grid configuration, specifically for the OpenROAD tool.
+    """
+    def __init__(self):
+        super().__init__()
+
+        self.define_tool_parameter("openroad", "tiehigh_cell", "(str,str)",
+                                   "A tuple specifying the tie-high cell name and its output port.")
+        self.define_tool_parameter("openroad", "tielow_cell", "(str,str)",
+                                   "A tuple specifying the tie-low cell name and its output port.")
+
+        self.define_tool_parameter("openroad", "place_density", "float",
+                                   "The target placement density for the design.")
+
+        self.define_tool_parameter("openroad", "global_cell_padding", "int",
+                                   "Padding to be applied to cells during global placement.",
+                                   defvalue=0)
+        self.define_tool_parameter("openroad", "detailed_cell_padding", "int",
+                                   "Padding to be applied to cells during detailed placement.",
+                                   defvalue=0)
+
+        self.define_tool_parameter("openroad", "macro_placement_halo", "(float,float)",
+                                   "A tuple for the X and Y dimensions of the halo around macros "
+                                   "during placement.")
+
+        self.define_tool_parameter("openroad", "tracks", "file",
+                                   "The file containing track definitions for routing.")
+        self.define_tool_parameter("openroad", "tapcells", "file",
+                                   "The file containing tap cell definitions.")
+        self.define_tool_parameter("openroad", "global_connect", "[file]",
+                                   "A list of global connect files.")
+        self.define_tool_parameter("openroad", "power_grid", "[file]",
+                                   "A list of power grid files.")
+
+        self.define_tool_parameter("openroad", "scan_chain_cells", "[str]",
+                                   "A list of cells used for scan chain insertion.")
+        self.define_tool_parameter("openroad", "multibit_ff_cells", "[str]",
+                                   "A list of multibit flip-flop cells.")
+
+    def set_openroad_tiehigh_cell(self, cell: str, output_port: str):
+        """
+        Sets the tie-high cell and its output port.
+
+        Args:
+            cell (str): The name of the tie-high cell.
+            output_port (str): The name of the output port.
+        """
+        self.set("tool", "openroad", "tiehigh_cell", (cell, output_port))
+
+    def set_openroad_tielow_cell(self, cell: str, output_port: str):
+        """
+        Sets the tie-low cell and its output port.
+
+        Args:
+            cell (str): The name of the tie-low cell.
+            output_port (str): The name of the output port.
+        """
+        self.set("tool", "openroad", "tielow_cell", (cell, output_port))
+
+    def set_openroad_placement_density(self, density: float):
+        """
+        Sets the target placement density.
+
+        Args:
+            density (float): The target placement density, a value between 0.0 and 1.0.
+        """
+        self.set("tool", "openroad", "place_density", density)
+
+    def set_openroad_cell_padding(self, global_place: int, detailed_place: int):
+        """
+        Sets the cell padding for both global and detailed placement.
+
+        Args:
+            global_place (int): Padding for global placement.
+            detailed_place (int): Padding for detailed placement.
+        """
+        self.set("tool", "openroad", "global_cell_padding", global_place)
+        self.set("tool", "openroad", "detailed_cell_padding", detailed_place)
+
+    def set_openroad_macro_placement_halo(self, x: float, y: float):
+        """
+        Sets the halo dimensions for macro placement.
+
+        Args:
+            x (float): The halo dimension in the x-direction.
+            y (float): The halo dimension in the y-direction.
+        """
+        self.set("tool", "openroad", "macro_placement_halo", (x, y))
+
+    def set_openroad_tracks_file(self, file: str, dataroot: str = None):
+        """
+        Sets the file for track definitions.
+
+        Args:
+            file (str): The path to the tracks file.
+            dataroot (str, optional): The data root directory. Defaults to the active package.
+        """
+        if not dataroot:
+            dataroot = self._get_active("package")
+        with self.active_dataroot(dataroot):
+            self.set("tool", "openroad", "tracks", file)
+
+    def set_openroad_tapcells_file(self, file: str, dataroot: str = None):
+        """
+        Sets the file for tap cell definitions.
+
+        Args:
+            file (str): The path to the tap cells file.
+            dataroot (str, optional): The data root directory. Defaults to the active package.
+        """
+        if not dataroot:
+            dataroot = self._get_active("package")
+        with self.active_dataroot(dataroot):
+            self.set("tool", "openroad", "tapcells", file)
+
+    def add_openroad_global_connect_file(self, file: Union[str, List[str]], dataroot: str = None,
+                                         clobber: bool = False):
+        """
+        Adds a global connect file to the list.
+
+        Args:
+            file (Union[str, List[str]]): The path to the global connect file or a list of paths.
+            dataroot (str, optional): The data root directory. Defaults to the active package.
+            clobber (bool, optional): If True, overwrites existing values. Defaults to False.
+        """
+        if not dataroot:
+            dataroot = self._get_active("package")
+        with self.active_dataroot(dataroot):
+            if clobber:
+                self.set("tool", "openroad", "global_connect", file)
+            else:
+                self.add("tool", "openroad", "global_connect", file)
+
+    def add_openroad_power_grid_file(self, file: Union[str, List[str]], dataroot: str = None,
+                                     clobber: bool = False):
+        """
+        Adds a power grid file to the list.
+
+        Args:
+            file (Union[str, List[str]]): The path to the power grid file or a list of paths.
+            dataroot (str, optional): The data root directory. Defaults to the active package.
+            clobber (bool, optional): If True, overwrites existing values. Defaults to False.
+        """
+        if not dataroot:
+            dataroot = self._get_active("package")
+        with self.active_dataroot(dataroot):
+            if clobber:
+                self.set("tool", "openroad", "power_grid", file)
+            else:
+                self.add("tool", "openroad", "power_grid", file)
+
+    def add_openroad_scan_chain_cells(self, cells: Union[str, List[str]], clobber: bool = False):
+        """
+        Adds scan chain cells to the list.
+
+        Args:
+            cells (Union[str, List[str]]): A cell name or a list of cell names.
+            clobber (bool, optional): If True, overwrites existing values. Defaults to False.
+        """
+        if clobber:
+            self.set("tool", "openroad", "scan_chain_cells", cells)
+        else:
+            self.add("tool", "openroad", "scan_chain_cells", cells)
+
+    def add_openroad_multibit_flipflops(self, cells: Union[str, List[str]], clobber: bool = False):
+        """
+        Adds multibit flip-flop cells to the list.
+
+        Args:
+            cells (Union[str, List[str]]): A cell name or a list of cell names.
+            clobber (bool, optional): If True, overwrites existing values. Defaults to False.
+        """
+        if clobber:
+            self.set("tool", "openroad", "multibit_ff_cells", cells)
+        else:
+            self.add("tool", "openroad", "multibit_ff_cells", cells)
+
 
 ####################################################################
 # Make Docs

siliconcompiler/tools/openroad/scripts/apr/preamble.tcl

@@ -100,3 +100,6 @@ if { [llength $openroad_dont_touch] > 0 } {
 tee -quiet -file reports/dont_touch.start.rpt {report_dont_touch}
 tee -quiet -file reports/dont_use.start.rpt {report_dont_use}
 tee -file reports/global_connections.start.rpt {report_global_connect}
+if { [sc_check_version 23264] } {
+    tee -file reports/report_buffers.rpt {report_buffers -filtered}
+}

siliconcompiler/tools/openroad/scripts/apr/sc_detailed_route.tcl

@@ -53,13 +53,18 @@ set sc_minmetal [sc_get_layer_name $sc_minmetal]
 set sc_maxmetal [sc_cfg_get pdk $sc_pdk maxlayer $sc_stackup]
 set sc_maxmetal [sc_get_layer_name $sc_maxmetal]
 
+if { [sc_check_version 23235] } {
+    set_routing_layers -signal "${sc_minmetal}-${sc_maxmetal}"
+} else {
+    lappend drt_arguments -bottom_routing_layer $sc_minmetal
+    lappend drt_arguments -top_routing_layer $sc_maxmetal
+}
+
 sc_report_args -command detailed_route -args $drt_arguments
 detailed_route \
     -save_guide_updates \
     -output_drc "reports/${sc_design}_drc.rpt" \
     -output_maze "reports/${sc_design}_maze.log" \
-    -bottom_routing_layer $sc_minmetal \
-    -top_routing_layer $sc_maxmetal \
     -verbose 1 \
     {*}$drt_arguments
 

siliconcompiler/tools/openroad/scripts/apr/sc_global_route.tcl

@@ -24,16 +24,20 @@ if { [lindex [sc_cfg_tool_task_get {var} grt_use_pin_access] 0] == "true" } {
     set sc_maxmetal [sc_get_layer_name $sc_maxmetal]
 
     set pin_access_args []
+    if { [sc_check_version 23235] } {
+        # use value from preamble
+    } else {
+        lappend pin_access_args -bottom_routing_layer $sc_minmetal
+        lappend pin_access_args -top_routing_layer $sc_maxmetal
+    }
+
     if { [lindex [sc_cfg_tool_task_get {var} drt_process_node] 0] != "false" } {
         lappend pin_access_args "-db_process_node" \
             [lindex [sc_cfg_tool_task_get {var} drt_process_node] 0]
     }
 
     sc_report_args -command pin_access -args $pin_access_args
-    pin_access \
-        -bottom_routing_layer $sc_minmetal \
-        -top_routing_layer $sc_maxmetal \
-        {*}$pin_access_args
+    pin_access {*}$pin_access_args
 }
 
 ###############################

siliconcompiler/tools/openroad/scripts/apr/sc_init_floorplan.tcl

@@ -301,12 +301,16 @@ if { [sc_cfg_exists constraint component] } {
     sc_print_macro_information
 }
 
-if { $do_automatic_pins } {
-    ###############################
-    # Automatic Random Pin Placement
-    ###############################
+if { [sc_check_version 23008] } {
+    # Dont do random placement
+} else {
+    if { $do_automatic_pins } {
+        ###############################
+        # Automatic Random Pin Placement
+        ###############################
 
-    sc_pin_placement -random
+        sc_pin_placement -random
+    }
 }
 
 ###############################

siliconcompiler/tools/openroad/scripts/common/write_images.tcl

@@ -311,7 +311,11 @@ proc sc_image_clocktree { } {
         }
 
         if { [info commands gui::select_clockviewer_clock] != "" } {
-            gui::select_clockviewer_clock ${clock_name}
+            set select_clk_args []
+            if { [sc_check_version 23008] } {
+                lappend select_clk_args 2
+            }
+            gui::select_clockviewer_clock ${clock_name} {*}$select_clk_args
             sc_save_image \
                 "clock - ${clock_name}" \
                 reports/images/clocks/${sc_design}.${clock_name}.png

siliconcompiler/tools/slang/__init__.py

@@ -32,7 +32,7 @@ def test_version():
         return "pyslang is not installed"
 
     version = pyslang.VersionInfo
-    if version.getMajor() >= 7 and version.getMinor() >= 0:
+    if version.getMajor() >= 9 and version.getMinor() >= 0:
         return None
 
     ver = f"{version.getMajor()}.{version.getMinor()}.{version.getPatch()}"

siliconcompiler/tools/slang/elaborate.py

@@ -119,7 +119,8 @@ def run(chip):
             writer.setIncludeSkipped(False)
             writer.setIncludeDirectives(False)
 
-            writer.setIncludePreprocessed(True)
+            writer.setExpandMacros(True)
+            writer.setExpandIncludes(True)
             writer.setIncludeTrivia(True)
             writer.setIncludeComments(True)
             writer.setSquashNewlines(True)

siliconcompiler/tools/vivado/scripts/sc_run.tcl

@@ -2,7 +2,7 @@
 # Reading SC Schema
 ###############################
 
-source ./sc_manifest.tcl
+source ./sc_manifest.tcl > /dev/null
 
 ##############################
 # Schema Adapter

siliconcompiler/tools/vivado/scripts/sc_syn_fpga.tcl

@@ -21,5 +21,12 @@ if { $sc_constraint != "" } {
 }
 
 # run synthesis
-synth_design -top $sc_design
+set synth_args []
+lappend synth_args -directive [lindex [sc_cfg_tool_task_get var synth_directive] 0]
+set synth_mode [lindex [sc_cfg_tool_task_get var synth_mode] 0]
+if { $synth_mode != "none" } {
+    lappend synth_args -mode $synth_mode
+}
+synth_design -top $sc_design {*}$synth_args
+
 opt_design