siliconcompiler 0.28.3__py3-none-any.whl → 0.28.4__py3-none-any.whl

siliconcompiler/tools/magic/extspice.py

@@ -1,5 +1,7 @@
 from siliconcompiler.tools.magic.magic import setup as setup_tool
+from siliconcompiler.tools.magic.magic import process_file
 from siliconcompiler.tools._common import get_tool_task
+from siliconcompiler.tools._common.asic import get_mainlib, get_libraries
 
 
 def setup(chip):
@@ -17,3 +19,22 @@ def setup(chip):
     design = chip.top()
 
     chip.add('tool', tool, 'task', task, 'output', f'{design}.spice', step=step, index=index)
+
+
+def pre_process(chip):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    pdk = chip.get('option', 'pdk')
+    stackup = chip.get('option', 'stackup')
+    mainlib = get_mainlib(chip)
+    libtype = chip.get('library', mainlib, 'asic', 'libarch', step=step, index=index)
+    process_file('lef', chip, 'pdk', pdk, 'aprtech', 'magic', stackup, libtype, 'lef')
+
+    for lib in get_libraries(chip, 'logic'):
+        process_file('lef', chip, 'library', lib, 'output', stackup, 'lef')
+
+    for lib in get_libraries(chip, 'macro'):
+        if lib in chip.get('tool', tool, 'task', task, 'var', 'exclude', step=step, index=index):
+            process_file('lef', chip, 'library', lib, 'output', stackup, 'lef')

siliconcompiler/tools/magic/magic.py

@@ -9,9 +9,12 @@ Installation: https://github.com/RTimothyEdwards/magic
 Sources: https://github.com/RTimothyEdwards/magic
 '''
 
+import gzip
+import shutil
 import os
 from siliconcompiler.tools._common import input_provides, get_tool_task
 from siliconcompiler.targets import freepdk45_demo
+from siliconcompiler import utils
 
 
 ####################################################################
@@ -79,6 +82,32 @@ def parse_version(stdout):
     return stdout.strip('\n')
 
 
+def process_file(file_type, chip, *key):
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    if chip.get(*key, field='pernode') == 'never':
+        files = chip.find_files(*key)
+    else:
+        files = chip.find_files(*key, step=step, index=index)
+
+    for file in files:
+        if file.lower().endswith('.gz'):
+            new_file_name = f'inputs/sc_{utils.get_hashed_filename(file[:-3])}'
+
+            with gzip.open(file, 'rt', encoding="utf-8") as fin:
+                with open(new_file_name, 'w') as fout:
+                    fout.write(fin.read().encode("ascii", "ignore").decode("ascii"))
+        else:
+            new_file_name = f'inputs/sc_{utils.get_hashed_filename(file)}'
+            shutil.copy(file, new_file_name)
+
+        chip.add('tool', tool, 'task', task, 'file', f'read_{file_type}',
+                 os.path.join(chip.getworkdir(step=step, index=index), new_file_name),
+                 step=step, index=index)
+
+
 ##################################################
 if __name__ == "__main__":
 

siliconcompiler/tools/magic/sc_drc.tcl

@@ -23,18 +23,8 @@ set sc_design [sc_top]
 set sc_macrolibs [sc_get_asic_libraries macro]
 set sc_stackup [sc_cfg_get option stackup]
 
-if { [sc_cfg_tool_task_exists var exclude] } {
-    set sc_exclude [sc_cfg_tool_task_get var exclude]
-} else {
-    set sc_exclude [list]
-}
-
-# Ignore specific libraries by reading their LEFs (causes magic to abstract them)
-foreach lib $sc_macrolibs {
-    puts $lib
-    if { [lsearch -exact $sc_exclude $lib] >= 0 } {
-        lef read [sc_cfg_get library $lib output $sc_stackup lef]
-    }
+foreach sc_lef [sc_cfg_tool_task_get file read_lef] {
+    lef read $sc_lef
 }
 
 gds noduplicates true

siliconcompiler/tools/magic/sc_extspice.tcl

@@ -14,21 +14,9 @@ set sc_techlef [sc_cfg_get pdk $sc_pdk aprtech magic $sc_stackup $sc_libtype lef
 set sc_liblef [sc_cfg_get library $sc_mainlib output $sc_stackup lef]
 set sc_macrolibs [sc_get_asic_libraries macro]
 
-if { [sc_cfg_tool_task_exists var exclude] } {
-    set sc_exclude [sc_cfg_tool_task_get var exclude]
-} else {
-    set sc_exclude [list]
-}
-
-lef read $sc_techlef
-lef read $sc_liblef
-
-# Ignore specific libraries by reading their LEFs (causes magic to abstract them)
-foreach lib $sc_macrolibs {
-    puts $lib
-    if { [lsearch -exact $sc_exclude $lib] >= 0 } {
-        lef read [sc_cfg_get library $lib output $sc_stackup lef]
-    }
+foreach sc_lef [sc_cfg_tool_task_get file read_lef] {
+    puts "Reading LEF $sc_lef"
+    lef read $sc_lef
 }
 
 if { [file exists "inputs/$sc_design.gds"] } {

siliconcompiler/tools/openroad/openroad.py

@@ -38,7 +38,7 @@ def setup_tool(chip, exit=True, clobber=True):
 
     chip.set('tool', tool, 'exe', tool)
     chip.set('tool', tool, 'vswitch', '-version')
-    chip.set('tool', tool, 'version', '>=v2.0-13145', clobber=clobber)
+    chip.set('tool', tool, 'version', '>=v2.0-16580', clobber=clobber)
     chip.set('tool', tool, 'format', 'tcl', clobber=clobber)
 
     # exit automatically in batch mode and not breakpoint
@@ -274,7 +274,10 @@ def post_process(chip):
                  "floating_nets.rpt",
                  f"{chip.design}_antenna.rpt",
                  f"{chip.design}_antenna_post_repair.rpt"],
-        "drcs": [f"{chip.design}_drc.rpt"]
+        "drcs": [f"{chip.design}_drc.rpt",
+                 f"markers/{chip.design}.drc.rpt",
+                 f"markers/{chip.design}.drc.json",
+                 f"images/markers/{chip.design}.drc.png"]
     }
     metric_reports["leakagepower"] = metric_reports["peakpower"]
 
@@ -673,6 +676,10 @@ def _define_dpl_params(chip):
                       default_value='false',
                       schelp='true/false, disallow single site gaps in detail placement')
 
+    set_tool_task_var(chip, param_key='dpl_use_decap_fillers',
+                      default_value='true',
+                      schelp='true/false, use decap fillers along with non-decap fillers')
+
 
 def _define_cts_params(chip):
     step = chip.get('arg', 'step')
@@ -852,6 +859,41 @@ def _define_mpl_params(chip):
                       schelp='minimum number of macros to use while clustering for macro placement')
     set_tool_task_var(chip, param_key='rtlmp_max_macros',
                       schelp='maximum number of macros to use while clustering for macro placement')
+    set_tool_task_var(chip, param_key='rtlmp_max_levels',
+                      schelp='maximum depth of physical hierarchical tree')
+    set_tool_task_var(chip, param_key='rtlmp_min_aspect_ratio',
+                      schelp='Specifies the minimum aspect ratio of its width to height of a '
+                             'standard cell cluster')
+    set_tool_task_var(chip, param_key='rtlmp_fence',
+                      schelp='Defines the global fence bounding box coordinates '
+                             '(llx, lly, urx, ury)')
+    set_tool_task_var(chip, param_key='rtlmp_bus_planning',
+                      schelp='Flag to enable bus planning')
+    set_tool_task_var(chip, param_key='rtlmp_target_dead_space',
+                      schelp='Specifies the target dead space percentage, which influences '
+                             'the utilization of standard cell clusters')
+
+    set_tool_task_var(chip, param_key='rtlmp_area_weight',
+                      schelp='Weight for the area of current floorplan')
+    set_tool_task_var(chip, param_key='rtlmp_outline_weight',
+                      schelp='Weight for violating the fixed outline constraint, meaning that all '
+                             'clusters should be placed within the shape of their parent cluster')
+    set_tool_task_var(chip, param_key='rtlmp_wirelength_weight',
+                      schelp='Weight for half-perimeter wirelength')
+    set_tool_task_var(chip, param_key='rtlmp_guidance_weight',
+                      schelp='Weight for guidance cost or clusters being placed near specified '
+                             'regions if users provide such constraints')
+    set_tool_task_var(chip, param_key='rtlmp_fence_weight',
+                      schelp='Weight for fence cost, or how far the macro is from zero '
+                             'fence violation')
+    set_tool_task_var(chip, param_key='rtlmp_blockage_weight',
+                      schelp='Weight for the boundary, or how far the hard macro clusters are '
+                             'from boundaries')
+    set_tool_task_var(chip, param_key='rtlmp_notch_weight',
+                      schelp='Weight for the notch, or the existence of dead space that cannot be '
+                             'used for placement & routing')
+    set_tool_task_var(chip, param_key='rtlmp_macro_blockage_weight',
+                      schelp='Weight for macro blockage, or the overlapping instances of the macro')
 
 
 def _define_ord_params(chip):

siliconcompiler/tools/openroad/scripts/sc_apr.tcl

@@ -265,10 +265,24 @@ set openroad_mpl_macro_place_channel [dict get $openroad_task_vars macro_place_c
 set openroad_ppl_arguments [dict get $openroad_task_vars ppl_arguments]
 
 set openroad_rtlmp_enable [lindex [dict get $openroad_task_vars rtlmp_enable] 0]
+set openroad_rtlmp_max_levels [lindex [dict get $openroad_task_vars rtlmp_max_levels] 0]
 set openroad_rtlmp_min_instances [lindex [dict get $openroad_task_vars rtlmp_min_instances] 0]
 set openroad_rtlmp_max_instances [lindex [dict get $openroad_task_vars rtlmp_max_instances] 0]
 set openroad_rtlmp_min_macros [lindex [dict get $openroad_task_vars rtlmp_min_macros] 0]
 set openroad_rtlmp_max_macros [lindex [dict get $openroad_task_vars rtlmp_max_macros] 0]
+set openroad_rtlmp_min_aspect_ratio [lindex [dict get $openroad_task_vars rtlmp_min_aspect_ratio] 0]
+set openroad_rtlmp_fence [dict get $openroad_task_vars rtlmp_fence]
+set openroad_rtlmp_bus_planning [lindex [dict get $openroad_task_vars rtlmp_bus_planning] 0]
+set openroad_rtlmp_target_dead_space \
+  [lindex [dict get $openroad_task_vars rtlmp_target_dead_space] 0]
+set openroad_rtlmp_area_weight [lindex [dict get $openroad_task_vars rtlmp_area_weight] 0]
+set openroad_rtlmp_outline_weight [lindex [dict get $openroad_task_vars rtlmp_outline_weight] 0]
+set openroad_rtlmp_wirelength_weight \
+  [lindex [dict get $openroad_task_vars rtlmp_wirelength_weight] 0]
+set openroad_rtlmp_guidance_weight [lindex [dict get $openroad_task_vars rtlmp_guidance_weight] 0]
+set openroad_rtlmp_fence_weight [lindex [dict get $openroad_task_vars rtlmp_fence_weight] 0]
+set openroad_rtlmp_notch_weight [lindex [dict get $openroad_task_vars rtlmp_notch_weight] 0]
+set openroad_rtlmp_blockage_weight [lindex [dict get $openroad_task_vars rtlmp_blockage_weight] 0]
 
 set openroad_gpl_place_density [lindex [dict get $openroad_task_vars place_density] 0]
 set openroad_gpl_padding [lindex [dict get $openroad_task_vars pad_global_place] 0]
@@ -427,6 +441,7 @@ if { $sc_task != "floorplan" } {
 # Setup reports directories
 file mkdir reports/timing
 file mkdir reports/power
+file mkdir reports/markers
 
 if { $sc_task == "show" || $sc_task == "screenshot" } {
   if { $sc_task == "screenshot" } {

siliconcompiler/tools/openroad/scripts/sc_floorplan.tcl

@@ -290,12 +290,12 @@ if { $do_automatic_pins } {
 # since we get an error otherwise.
 if { [sc_design_has_unplaced_macros] } {
   if { $openroad_rtlmp_enable == "true" } {
-    set halo_max [expr {
-      max([lindex $openroad_mpl_macro_place_halo 0],
-        [lindex $openroad_mpl_macro_place_halo 1])
-    }]
+    lassign $openroad_mpl_macro_place_halo halo_x halo_y
 
     set rtlmp_args []
+    if { $openroad_rtlmp_max_levels != "" } {
+      lappend rtlmp_args -max_num_level $openroad_rtlmp_max_levels
+    }
     if { $openroad_rtlmp_min_instances != "" } {
       lappend rtlmp_args -min_num_inst $openroad_rtlmp_min_instances
     }
@@ -308,9 +308,48 @@ if { [sc_design_has_unplaced_macros] } {
     if { $openroad_rtlmp_max_macros != "" } {
       lappend rtlmp_args -max_num_macro $openroad_rtlmp_max_macros
     }
+    if { $openroad_rtlmp_min_aspect_ratio != "" } {
+      lappend rtlmp_args -min_ar $openroad_rtlmp_min_aspect_ratio
+    }
+    if { $openroad_rtlmp_fence != "" } {
+      lappend rtlmp_args -fence_lx [lindex $openroad_rtlmp_fence 0]
+      lappend rtlmp_args -fence_ly [lindex $openroad_rtlmp_fence 1]
+      lappend rtlmp_args -fence_ux [lindex $openroad_rtlmp_fence 2]
+      lappend rtlmp_args -fence_uy [lindex $openroad_rtlmp_fence 3]
+    }
+    if { $openroad_rtlmp_bus_planning == "true" } {
+      lappend rtlmp_args -bus_planning
+    }
+    if { $openroad_rtlmp_target_dead_space != "" } {
+      lappend rtlmp_args -target_dead_space $openroad_rtlmp_target_dead_space
+    }
+
+    if { $openroad_rtlmp_area_weight != "" } {
+      lappend rtlmp_args -area_weight $openroad_rtlmp_area_weight
+    }
+    if { $openroad_rtlmp_outline_weight != "" } {
+      lappend rtlmp_args -outline_weight $openroad_rtlmp_outline_weight
+    }
+    if { $openroad_rtlmp_wirelength_weight != "" } {
+      lappend rtlmp_args -wirelength_weight $openroad_rtlmp_wirelength_weight
+    }
+    if { $openroad_rtlmp_guidance_weight != "" } {
+      lappend rtlmp_args -guidance_weight $openroad_rtlmp_guidance_weight
+    }
+    if { $openroad_rtlmp_fence_weight != "" } {
+      lappend rtlmp_args -fence_weight $openroad_rtlmp_fence_weight
+    }
+    if { $openroad_rtlmp_notch_weight != "" } {
+      lappend rtlmp_args -notch_weight $openroad_rtlmp_notch_weight
+    }
+    if { $openroad_rtlmp_blockage_weight != "" } {
+      lappend rtlmp_args -blockage_weight $openroad_rtlmp_blockage_weight
+    }
 
     rtl_macro_placer -report_directory reports/rtlmp \
-      -halo_width $halo_max \
+      -halo_width $halo_x \
+      -halo_height $halo_y \
+      -target_util [sc_global_placement_density] \
       {*}$rtlmp_args
   } else {
     ###########################
@@ -352,11 +391,18 @@ global_connect
 # Tap Cells
 ###########################
 
-if { [sc_cfg_tool_task_exists {file} ifp_tapcell] } {
-  set tapcell_file [lindex [sc_cfg_tool_task_get {file} ifp_tapcell] 0]
-  puts "Sourcing tapcell file: ${tapcell_file}"
-  source $tapcell_file
+if {
+  [sc_cfg_tool_task_exists {file} ifp_tapcell] &&
+  [llength [sc_cfg_tool_task_get {file} ifp_tapcell]] > 0
+} {
+  foreach tapcell_file [sc_cfg_tool_task_get {file} ifp_tapcell] {
+    puts "Sourcing tapcell file: ${tapcell_file}"
+    source $tapcell_file
+  }
   global_connect
+} else {
+  utl::warn FLW 1 "Tapcell configuration not provided"
+  cut_rows
 }
 
 ###########################

siliconcompiler/tools/openroad/scripts/sc_metrics.tcl

@@ -158,3 +158,13 @@ if { $unconstrained_endpoints == "" } {
   set unconstrained_endpoints 0
 }
 utl::metric_int "timing__unconstrained" $unconstrained_endpoints
+
+# Write markers
+foreach markerdb [[ord::get_db_block] getMarkerCategories] {
+  if { [$markerdb getMarkerCount] == 0 } {
+    continue
+  }
+
+  $markerdb writeTR "reports/markers/${sc_design}.[$markerdb getName].rpt"
+  $markerdb writeJSON "reports/markers/${sc_design}.[$markerdb getName].json"
+}

siliconcompiler/tools/openroad/scripts/sc_procs.tcl

@@ -72,8 +72,10 @@ proc sc_global_placement { args } {
     lappend openroad_gpl_args "-skip_io"
   }
 
+  set density [sc_global_placement_density]
+
   global_placement {*}$openroad_gpl_args \
-    -density [sc_global_placement_density] \
+    -density $density \
     -pad_left $openroad_gpl_padding \
     -pad_right $openroad_gpl_padding
 }

siliconcompiler/tools/openroad/scripts/sc_route.tcl

@@ -8,8 +8,14 @@
 
 proc insert_fillers { } {
   upvar sc_filler sc_filler
-  if { $sc_filler != "" } {
-    filler_placement $sc_filler
+  global sc_mainlib
+
+  set fillers $sc_filler
+  if { [lindex [sc_cfg_tool_task_get var dpl_use_decap_fillers] 0] == "true" } {
+    lappend fillers {*}[sc_cfg_get library $sc_mainlib asic cells decap]
+  }
+  if { $fillers != "" } {
+    filler_placement $fillers
   }
 
   check_placement -verbose

siliconcompiler/tools/openroad/scripts/sc_screenshot.tcl

@@ -3,11 +3,6 @@ gui::save_display_controls
 set sc_resolution \
   [lindex [sc_cfg_tool_task_get {var} show_vertical_resolution] 0]
 
-# Show the drc markers (if any)
-if { [file exists reports/${sc_design}_drc.rpt] } {
-  gui::load_drc reports/${sc_design}_drc.rpt
-}
-
 sc_image_setup_default
 
 sc_save_image "screenshot" "outputs/${sc_design}.png" $sc_resolution

siliconcompiler/tools/openroad/scripts/sc_write_images.tcl

@@ -226,6 +226,12 @@ proc sc_image_clocks { } {
 proc sc_image_clocktree { } {
   gui::show_widget "Clock Tree Viewer"
   global sc_scenarios
+  global sc_design
+
+  sc_image_setup_default
+  gui::set_display_controls "Layers/*" visible true
+  gui::set_display_controls "Nets/*" visible false
+  gui::set_display_controls "Nets/Clock" visible true
 
   set clock_state []
   foreach clock [all_clocks] {
@@ -233,6 +239,7 @@ proc sc_image_clocktree { } {
   }
   set_propagated_clock [all_clocks]
 
+  file mkdir reports/images/clocks
   foreach clock [get_clocks *] {
     if { [llength [get_property $clock sources]] == 0 } {
       # Skip virtual clocks
@@ -243,13 +250,18 @@ proc sc_image_clocktree { } {
     set clock_name [get_name $clock]
     foreach corner $sc_scenarios {
       set path reports/images/clocktree/${clock_name}.${corner}.png
-      utl::info FLW 1 "Saving $clock_name clock tree for $corner in $path"
+      utl::info FLW 1 "Saving \"$clock_name\" clock tree for $corner to $path"
       save_clocktree_image $path \
         -clock $clock_name \
         -width 1024 \
         -height 1024 \
         -corner $corner
     }
+
+    if { [info commands gui::select_clockviewer_clock] != "" } {
+      gui::select_clockviewer_clock ${clock_name}
+      sc_save_image "clock - ${clock_name}" reports/images/clocks/${sc_design}.${clock_name}.png
+    }
   }
 
   foreach {clock state} $clock_state {
@@ -306,21 +318,39 @@ proc sc_image_optimizer { } {
   sc_save_image "optimizer" reports/images/${sc_design}.optimizer.png
 }
 
+proc sc_image_markers { } {
+  global sc_design
+  sc_image_setup_default
+
+  file mkdir reports/images/markers
+  foreach markerdb [[ord::get_db_block] getMarkerCategories] {
+    if { [$markerdb getMarkerCount] == 0 } {
+      continue
+    }
+
+    gui::select_marker_category $markerdb
+
+    sc_save_image \
+      "markers - [$markerdb getName]" \
+      reports/images/markers/${sc_design}.[$markerdb getName].png
+  }
+
+  gui::select_marker_category NULL
+}
+
 # Setup
 file mkdir reports/images
 gui::save_display_controls
 sc_image_setup_default
 
-if { [file exists reports/${sc_design}_drc.rpt] } {
-  # Show the drc markers (if any)
-  gui::load_drc reports/${sc_design}_drc.rpt
-}
-
 # General images
 sc_image_everything
 sc_image_placement
 sc_image_routing
 
+# Markers
+sc_image_markers
+
 # Heatmaps
 if { [sc_cfg_tool_task_check_in_list placement_density var reports] } {
   sc_image_placement_density

siliconcompiler/tools/surelog/__init__.py

@@ -61,24 +61,36 @@ def setup(chip):
              field='help')
     chip.set('tool', tool, 'task', task, 'var', 'enable_lowmem', 'false',
              step=step, index=index, clobber=False)
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['tool', tool, 'task', task, 'var', 'enable_lowmem']),
+             step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'disable_write_cache',
              'true/false, when true instructs Surelog to not write to its cache.',
              field='help')
     chip.set('tool', tool, 'task', task, 'var', 'disable_write_cache', 'false',
              step=step, index=index, clobber=False)
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['tool', tool, 'task', task, 'var', 'disable_write_cache']),
+             step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'disable_info',
              'true/false, when true instructs Surelog to not log infos.',
              field='help')
     chip.set('tool', tool, 'task', task, 'var', 'disable_info', 'false',
              step=step, index=index, clobber=False)
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['tool', tool, 'task', task, 'var', 'disable_info']),
+             step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'disable_note',
              'true/false, when true instructs Surelog to not log notes.',
              field='help')
     chip.set('tool', tool, 'task', task, 'var', 'disable_note', 'false',
              step=step, index=index, clobber=False)
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['tool', tool, 'task', task, 'var', 'disable_note']),
+             step=step, index=index)
 
 
 def parse_version(stdout):

siliconcompiler/tools/verilator/compile.py

@@ -34,24 +34,42 @@ def setup(chip):
     if mode not in (['cc'], ['systemc']):
         chip.error(f"Invalid mode {mode} provided to verilator/compile. Expected one of 'cc' or "
                    "'systemc'")
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['tool', tool, 'task', task, 'var', 'mode']),
+             step=step, index=index)
 
     trace_type = chip.get('tool', tool, 'task', task, 'var', 'trace_type', step=step, index=index)
     if trace_type not in (['vcd'], ['fst']):
         chip.error(f"Invalid trace type {trace_type} provided to verilator/compile. Expected "
                    "one of 'vcd' or 'fst'.")
+    chip.add('tool', tool, 'task', task, 'require',
+             ','.join(['tool', tool, 'task', task, 'var', 'trace_type']),
+             step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'cflags',
              'flags to provide to the C++ compiler invoked by Verilator',
              field='help')
+    if chip.get('tool', tool, 'task', task, 'var', 'cflags', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'var', 'cflags']),
+                 step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'ldflags',
              'flags to provide to the linker invoked by Verilator',
              field='help')
+    if chip.get('tool', tool, 'task', task, 'var', 'ldflags', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'var', 'ldflags']),
+                 step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'pins_bv',
              'controls datatypes used to represent SystemC inputs/outputs. See --pins-bv in '
              'Verilator docs for more info.',
              field='help')
+    if chip.get('tool', tool, 'task', task, 'var', 'pins_bv', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'var', 'pins_bv']),
+                 step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'mode',
              "defines compilation mode for Verilator. Valid options are 'cc' for C++, or 'systemc' "
@@ -61,10 +79,19 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'dir', 'cincludes',
              'include directories to provide to the C++ compiler invoked by Verilator',
              field='help')
+    if chip.get('tool', tool, 'task', task, 'dir', 'cincludes', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'dir', 'cincludes']),
+                 step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'trace',
              "if true, enables trace generation.",
              field='help')
+    if chip.get('tool', tool, 'task', task, 'var', 'trace', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'var', 'trace']),
+                 step=step, index=index)
+
     chip.set('tool', tool, 'task', task, 'var', 'trace_type',
              "specifies type of wave file to create when [trace] is set. Valid options are "
              "'vcd' or 'fst'. Defaults to 'vcd'.",

siliconcompiler/tools/verilator/verilator.py

@@ -71,6 +71,10 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'file', 'config',
              'Verilator configuration file',
              field='help')
+    if chip.get('tool', tool, 'task', task, 'file', 'config', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'file', 'config']),
+                 step=step, index=index)
 
     chip.set('tool', tool, 'task', task, 'var', 'enable_assert',
              'true/false, when true assertions are enabled in Verilator.',
@@ -78,6 +82,11 @@ def setup(chip):
     chip.set('tool', tool, 'task', task, 'var', 'enable_assert', 'false',
              step=step, index=index, clobber=False)
 
+    if chip.get('tool', tool, 'task', task, 'var', 'enable_assert', step=step, index=index):
+        chip.add('tool', tool, 'task', task, 'require',
+                 ','.join(['tool', tool, 'task', task, 'var', 'enable_assert']),
+                 step=step, index=index)
+
     if f'{chip.top()}.v' not in input_provides(chip, step, index):
         add_require_input(chip, 'input', 'rtl', 'verilog')
         add_require_input(chip, 'input', 'rtl', 'systemverilog')

siliconcompiler/tools/vpr/vpr.py

@@ -66,6 +66,20 @@ def setup_tool(chip, clobber=True):
         chip.add('tool', tool, 'task', task, 'require', f'fpga,{part_name},var,{resource}',
                  step=step, index=index)
 
+    add_tool_requirements(chip)
+
+
+def add_tool_requirements(chip):
+
+    step = chip.get('arg', 'step')
+    index = chip.get('arg', 'index')
+    tool, task = get_tool_task(chip, step, index)
+
+    part_name = chip.get('fpga', 'partname')
+
+    chip.add('tool', tool, 'task', task, 'require', f'fpga,{part_name},var,vpr_device_code',
+             step=step, index=index)
+
 
 def runtime_options(chip):
 
@@ -76,6 +90,10 @@ def runtime_options(chip):
 
     options = []
 
+    device_code = chip.get('fpga', part_name, 'var', 'vpr_device_code')
+
+    options.append(f"--device {device_code[0]}")
+
     options.append(f"--write_block_usage {__block_file}")
     options.append("--outfile_prefix outputs/")
 

siliconcompiler/tools/yosys/{syn_asic_fpga_shared.tcl → procs.tcl}

@@ -29,3 +29,26 @@ proc sc_map_memory { lib_file techmap_file do_rom } {
 
     return $design_mod
 }
+
+proc sc_apply_params { } {
+    global sc_design
+
+    yosys chparam -list $sc_design
+    if { [sc_cfg_exists option param] } {
+        yosys echo off
+        set module_params [yosys tee -q -s result.string chparam -list $sc_design]
+        yosys echo on
+
+        dict for {key value} [sc_cfg_get option param] {
+            if { ![string is integer $value] } {
+                set value [concat \"$value\"]
+            }
+
+            if { [string first $key $module_params] != -1 } {
+                yosys chparam -set $key $value $sc_design
+            } else {
+                puts "Warning: $key is not a defined parameter in $sc_design"
+            }
+        }
+    }
+}