Merge remote-tracking branch 'origin/master' into secure-reduce-escape-slash-reg

Signed-off-by: Jaehyun Kim <jhkim@precisioninno.com>

Author: jhkim-pii

.github/workflows/github-actions-clang-tidy-bazel-post.yml

@@ -125,6 +125,40 @@ jobs:
         with:
           reviewdog_version: latest
 
+      - name: Dump reviewdog-visible env and event payload
+        # Gated on debug re-runs. Reviewdog emits "this is not PullRequest
+        # build" and posts nothing for fork PRs even though the synthesized
+        # pull_request payload is well-formed (verified locally against
+        # reviewdog v0.21.0). Suspect: step-level `env:` cannot override
+        # runner-protected GITHUB_EVENT_PATH / GITHUB_EVENT_NAME, so reviewdog
+        # reads the runner's workflow_run event payload instead of our synth.
+        # This step proves what reviewdog actually sees on the next debug
+        # re-run.
+        if: runner.debug == '1'
+        env:
+          GITHUB_EVENT_NAME: pull_request
+          GITHUB_EVENT_PATH: ${{ steps.event.outputs.event_path }}
+          GITHUB_SHA: ${{ steps.meta.outputs.head_sha }}
+          GITHUB_REPOSITORY: ${{ steps.meta.outputs.base_repo }}
+        run: |
+          echo "::group::GITHUB_* env visible to next step"
+          env | grep -E '^(GITHUB_|RUNNER_|REVIEWDOG_)' | sort
+          echo "::endgroup::"
+          echo "::group::Synth event file location and content"
+          echo "steps.event.outputs.event_path = ${{ steps.event.outputs.event_path }}"
+          echo "Effective GITHUB_EVENT_PATH    = ${GITHUB_EVENT_PATH}"
+          if [ -f "${GITHUB_EVENT_PATH}" ]; then
+            echo "--- file exists, content: ---"
+            cat "${GITHUB_EVENT_PATH}"
+          else
+            echo "::warning::GITHUB_EVENT_PATH file does not exist"
+          fi
+          echo "::endgroup::"
+          echo "::group::Synth file at literal path (should match above)"
+          SYNTH="${{ steps.event.outputs.event_path }}"
+          [ -f "${SYNTH}" ] && cat "${SYNTH}" || echo "missing"
+          echo "::endgroup::"
+
       - name: Run reviewdog
         env:
           REVIEWDOG_GITHUB_API_TOKEN: ${{ secrets.GITHUB_TOKEN }}
@@ -133,7 +167,14 @@ jobs:
           GITHUB_SHA: ${{ steps.meta.outputs.head_sha }}
           GITHUB_REPOSITORY: ${{ steps.meta.outputs.base_repo }}
         run: |
+          # On debug re-runs add reviewdog's own -log-level=debug so the
+          # cienv detection trace is visible alongside the env dump above.
+          LOG_FLAGS=()
+          if [ "${RUNNER_DEBUG}" = "1" ]; then
+            LOG_FLAGS+=(-log-level=debug)
+          fi
           reviewdog \
+            "${LOG_FLAGS[@]}" \
             -efm="%E%f:%l:%c: error: %m" \
             -efm="%W%f:%l:%c: warning: %m" \
             -name="clang-tidy" \

src/dbSta/include/db_sta/dbSta.hh

@@ -206,6 +206,10 @@ class dbSta : public Sta, public odb::dbDatabaseObserver
                                  bool exclude_buffers,
                                  bool exclude_inverters) const;
 
+  // Get the levels of logic for all endpoints.
+  std::vector<int> levelsOfLogic(bool exclude_buffers,
+                                 bool exclude_inverters) const;
+
   utl::Logger* getLogger() { return logger_; }
 
   // Sanity checkers

src/dbSta/src/dbSta.cc

@@ -817,12 +817,11 @@ void dbSta::reportTimingHistogram(int num_bins,
   histogram.report(/*precision=*/3);
 }
 
-void dbSta::reportLogicDepthHistogram(int num_bins,
-                                      bool exclude_buffers,
+std::vector<int> dbSta::levelsOfLogic(bool exclude_buffers,
                                       bool exclude_inverters) const
 {
-  utl::Histogram<int> histogram(logger_);
-
+  std::vector<int> depths;
+  depths.reserve(sta_->endpoints().size());
   sta_->worstSlack(MinMax::max());  // Update timing.
   for (sta::Vertex* vertex : sta_->endpoints()) {
     int path_length = 0;
@@ -843,9 +842,19 @@ void dbSta::reportLogicDepthHistogram(int num_bins,
       }
       path = path->prevPath();
     }
-    histogram.addData(path_length);
+    depths.push_back(path_length);
   }
+  return depths;
+}
 
+void dbSta::reportLogicDepthHistogram(int num_bins,
+                                      bool exclude_buffers,
+                                      bool exclude_inverters) const
+{
+  utl::Histogram<int> histogram(logger_);
+  for (int depth : levelsOfLogic(exclude_buffers, exclude_inverters)) {
+    histogram.addData(depth);
+  }
   histogram.generateBins(num_bins);
   histogram.report();
 }

src/est/src/EstimateParasitics.cpp

@@ -1017,31 +1017,49 @@ void EstimateParasitics::insertViaResistances(odb::dbTechLayer* pin_layer,
       if (cut_layer->getType() != odb::dbTechLayerType::CUT) {
         continue;
       }
-      sta::ParasiticNode* mid_node = parasitics->ensureParasiticNode(
-          parasitic, net, ++max_node_index, network_);
-
       const double cut_res
           = std::max(layer_res_[layer_idx][corner->index()], 1.0e-3);
 
+      // Resolve from/to endpoints first, so we only allocate a new mid_node
+      // when this iteration actually needs one. On the terminal iteration the
+      // resistor connects directly to the pin or tree anchor; if we had
+      // pre-allocated a mid_node here it would never be wired up and would
+      // become a floating ParasiticNode (singular row in the conductance
+      // matrix for Prima/CCS).
       sta::ParasiticNode* from_node = prev_node;
-      sta::ParasiticNode* to_node = mid_node;
+      sta::ParasiticNode* to_node = nullptr;
+      bool need_new_mid = true;
       if (pin_is_below) {
         if (layer_idx - 1 == pin_layer_idx) {
           from_node = pin_node;
-        } else if (layer_idx + 1 == tree_layer_idx) {
+        }
+        if (layer_idx + 1 == tree_layer_idx) {
           to_node = node;
+          need_new_mid = false;
         }
       } else {
         if (layer_idx - 1 == tree_layer_idx) {
           from_node = node;
-        } else if (layer_idx + 1 == pin_layer_idx) {
+        }
+        if (layer_idx + 1 == pin_layer_idx) {
           to_node = pin_node;
+          need_new_mid = false;
         }
       }
 
+      sta::ParasiticNode* mid_node = nullptr;
+      if (need_new_mid) {
+        mid_node = parasitics->ensureParasiticNode(
+            parasitic, net, ++max_node_index, network_);
+        to_node = mid_node;
+      }
+
       parasitics->makeResistor(
           parasitic, resistor_id++, cut_res, from_node, to_node);
 
+      // On the terminal iteration mid_node is nullptr and prev_node is unused
+      // by the next iteration (there is none); on every other iteration we
+      // chain through the freshly allocated mid_node.
       prev_node = mid_node;
     }
   }

src/est/src/MakeWireParasitics.cpp

@@ -3,9 +3,13 @@
 
 #include "MakeWireParasitics.h"
 
+#include <algorithm>
 #include <cmath>
 #include <cstddef>
+#include <iterator>
+#include <map>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "db_sta/SpefWriter.hh"
@@ -242,6 +246,67 @@ void MakeWireParasitics::makeRouteParasitics(sta::Parasitics* parasitics,
     parasitics->makeResistor(parasitic, resistor_id_++, res, n1, n2);
     parasitics->incrCap(n2, cap / 2.0);
   }
+
+  // Workaround: implicit-via post-pass.
+  //
+  // GRT does not always emit an explicit isVia=true segment at every
+  // layer transition along a route; coincident endpoints on adjacent
+  // routing levels are treated as implicitly connected. EST has historically
+  // taken GRoute literally, so any layer transition without an explicit via
+  // segment ends up as two distinct ParasiticNodes at the same (x, y) with
+  // no resistor between them -- a disconnected island in the parasitic
+  // network. That goes unnoticed by pi-Elmore-based delay calculators but
+  // produces a singular conductance matrix in Prima/CCS.
+  //
+  // Close the contract gap here: scan node_map for coincident endpoints on
+  // adjacent routing levels and, when no resistor already bridges them,
+  // insert one with the appropriate cut-layer resistance.
+  std::vector<std::pair<sta::ParasiticNode*, sta::ParasiticNode*>>
+      connected_pairs;
+  for (sta::ParasiticResistor* r : parasitics->resistors(parasitic)) {
+    sta::ParasiticNode* a = parasitics->node1(r);
+    sta::ParasiticNode* b = parasitics->node2(r);
+    connected_pairs.emplace_back(std::minmax(a, b));
+  }
+  std::ranges::sort(connected_pairs);
+
+  if (!node_map.empty()) {
+    auto prev_it = node_map.begin();
+    for (auto it = std::next(prev_it); it != node_map.end();
+         prev_it = it, ++it) {
+      const auto& prev_pt = prev_it->first;
+      const auto& curr_pt = it->first;
+      if (prev_pt.x() != curr_pt.x() || prev_pt.y() != curr_pt.y()) {
+        continue;
+      }
+      if (curr_pt.layer() != prev_pt.layer() + 1) {
+        // Not adjacent routing levels -- skipping signals that an
+        // intermediate routing-level node is missing entirely, which is a
+        // different bug worth surfacing rather than silently bridging.
+        continue;
+      }
+      sta::ParasiticNode* lo_node = prev_it->second;
+      sta::ParasiticNode* hi_node = it->second;
+      const std::pair<sta::ParasiticNode*, sta::ParasiticNode*> pair
+          = std::minmax(lo_node, hi_node);
+      auto bound_it = std::ranges::lower_bound(connected_pairs, pair);
+      if (bound_it != connected_pairs.end() && *bound_it == pair) {
+        continue;
+      }
+      odb::dbTechLayer* lower_routing
+          = tech_->findRoutingLayer(prev_pt.layer());
+      odb::dbTechLayer* cut_layer
+          = lower_routing ? lower_routing->getUpperLayer() : nullptr;
+      if (cut_layer == nullptr) {
+        // Top of stack or unresolved -- do not silently invent a resistor.
+        continue;
+      }
+      const float via_R = getCutLayerRes(cut_layer, corner);
+      parasitics->makeResistor(
+          parasitic, resistor_id_++, via_R, lo_node, hi_node);
+      connected_pairs.insert(bound_it, pair);
+    }
+  }
 }
 
 void MakeWireParasitics::makeParasiticsToPins(