Add backward routing for RapidWright.

src/com/xilinx/rapidwright/rwroute/Connection.java

@@ -269,6 +269,10 @@ public RouteNode getSourceRnode() {
         return sourceRnode;
     }
 
+    public RouteNode getSourceRnode(boolean backwardRouting) {
+        return backwardRouting ? sinkRnode : sourceRnode;
+    }
+
     public void setSourceRnode(RouteNode sourceNode) {
         sourceRnode = sourceNode;
     }
@@ -277,6 +281,10 @@ public RouteNode getSinkRnode() {
         return sinkRnode;
     }
 
+    public RouteNode getSinkRnode(boolean backwardRouting) {
+        return backwardRouting ? sourceRnode : sinkRnode;
+    }
+
     public void setSinkRnode(RouteNode sinkRnode) {
         this.sinkRnode = sinkRnode;
 
@@ -483,9 +491,10 @@ public String toString() {
         return s.toString();
     }
 
-    public void setAllTargets(RWRoute.ConnectionState state) {
-        sinkRnode.markTarget(state);
+    public void setAllTargets(RWRoute.ConnectionState state, boolean backwardRouting) {
+        getSinkRnode(backwardRouting).markTarget(state);
         if (altSinkRnodes != null) {
+            assert(!backwardRouting); // TODO
             for (RouteNode rnode : altSinkRnodes) {
                 assert(rnode.countConnectionsOfUser(netWrapper) == 0);
                 assert(!rnode.getType().isAnyExclusiveSink());

src/com/xilinx/rapidwright/rwroute/PartialRouter.java

@@ -834,6 +834,37 @@ public static Design routeDesignPartialTimingDriven(Design design, Collection<Si
                 pinsToRoute, softPreserve);
     }
 
+    /**
+     * Routes a design in the partial non-timing-driven backward routing mode.
+     * @param design The {@link Design} instance to be routed.
+     * @param pinsToRoute Collection of {@link SitePinInst}-s to be routed. If null, route all unrouted pins in the design.
+     * @param softPreserve Allow routed nets to be unrouted and subsequently rerouted in order to improve routability.
+     */
+    public static Design routeDesignPartialNonTimingDrivenBackward(Design design, Collection<SitePinInst> pinsToRoute, boolean softPreserve) {
+        return routeDesignWithUserDefinedArguments(design, new String[] {
+                "--fixBoundingBox",
+                "--useUTurnNodes",
+                "--nonTimingDriven",
+                "--backwardRouting",
+                "--verbose"},
+                pinsToRoute, softPreserve);
+    }
+
+    /**
+     * Routes a design in the partial timing-driven backward routing mode.
+     * @param design The {@link Design} instance to be routed.
+     * @param pinsToRoute Collection of {@link SitePinInst}-s to be routed. If null, route all unrouted pins in the design.
+     * @param softPreserve Allow routed nets to be unrouted and subsequently rerouted in order to improve routability.
+     */
+    public static Design routeDesignPartialTimingDrivenBackward(Design design, Collection<SitePinInst> pinsToRoute, boolean softPreserve) {
+        return routeDesignWithUserDefinedArguments(design, new String[] {
+                "--fixBoundingBox",
+                "--useUTurnNodes",
+                "--backwardRouting",
+                "--verbose"},
+                pinsToRoute, softPreserve);
+    }
+
     /**
      * The main interface of {@link PartialRouter} that reads in a {@link Design} checkpoint,
      * and parses the arguments for the {@link RWRouteConfig} object of the router.

src/com/xilinx/rapidwright/rwroute/RWRouteConfig.java

@@ -106,6 +106,9 @@ public class RWRouteConfig {
     private float husActivateThreshold;
     /* PBlock within which RWRoute must stay within */
     private String pblock;
+
+    /* true to route backward (Sink ->...->Source) */
+    private boolean backwardRouting;
 
     /** Constructs a Configuration Object */
     public RWRouteConfig(String[] arguments) {
@@ -247,6 +250,9 @@ private void parseArguments(String[] arguments) {
             case "--lutRoutethru":
                 setLutRoutethru(true);
                 break;
+            case "--backwardRouting":
+                setBackwardRouting(true);
+                break;
             case "--noInvertGndToVccForLutInputs":
                 setInvertGndToVccForLutInputs(false);
                 break;
@@ -1081,4 +1087,20 @@ public String toString() {
 
         return s.toString();
     }
+
+    /**
+     * Checks if backward routing is enabled.
+     * @return true if backward routing is enabled, false otherwise.
+     */
+    public boolean isBackwardRouting() {
+        return backwardRouting;
+    }
+
+    /**
+     * Sets the backward routing flag.
+     * @param backwardRouting true to enable backward routing, false otherwise.
+     */
+    public void setBackwardRouting(boolean backwardRouting) {
+        this.backwardRouting = backwardRouting;
+    }
 }

src/com/xilinx/rapidwright/rwroute/RouteNode.java

@@ -173,6 +173,10 @@ private void setBaseCost(RouteNodeGraph routingGraph) {
                     case NODE_LAGUNA_DATA:   // LAG_LAG.UBUMP* super long lines for u-turns at the boundary of the device (US+)
                     case NODE_SLL_INPUT:     // Versal only
                     case NODE_SLL_OUTPUT:    // Versal only
+                    case NODE_GLOBAL_LEAF:
+                    case NODE_INT_INTERFACE:
+                    case NODE_DEDICATED:
+                    case NODE_OPTDELAY:
                     case INTENT_DEFAULT:     // INT.VCC_WIRE
                         assert(length == 0);
                         break;
@@ -495,7 +499,7 @@ public float getBaseCost() {
     public RouteNode[] getChildren(RouteNodeGraph routingGraph) {
         if (children == null) {
             long start = RuntimeTracker.now();
-            List<Node> allDownHillNodes = getAllDownhillNodes();
+            List<Node> allDownHillNodes = routingGraph.backwardRouting ? getAllUphillNodes() : getAllDownhillNodes();
             List<RouteNode> childrenList = new ArrayList<>(allDownHillNodes.size());
             for (Node downhill : allDownHillNodes) {
                 if (isExcluded(routingGraph, downhill)) {

src/com/xilinx/rapidwright/rwroute/RouteNodeGraph.java

@@ -143,10 +143,13 @@ protected static int getTileCount(Design design) {
     /** Flag to enable really comprehensive (but performance-impacting) assertions */
     protected final static boolean enableComprehensiveAssertions = false;
 
+    protected final boolean backwardRouting;
+
     public RouteNodeGraph(Design design, RWRouteConfig config) {
         this.design = design;
         lutRoutethru = config.isLutRoutethru();
         lutPinSwapping = config.isLutPinSwapping();
+        backwardRouting = config.isBackwardRouting();
 
         this.nodesMap = new RouteNode[getTileCount(design)][];
         nodesMapSize = new AtomicInteger();
@@ -1171,6 +1174,11 @@ public boolean isAccessible(RouteNode childRnode, RouteNode parentRnode, Connect
     protected boolean allowRoutethru(RouteNode head, Node tail) {
         final boolean isCLB = Utils.isCLB(tail.getTile().getTileTypeEnum());
 
+        if (backwardRouting) {
+            // FIXME: Need a better way to identify LUT routethrus than INT -> CLB edge
+            return true;
+        }
+
         if (isVersal) {
             if (tail.getIntentCode() == IntentCode.NODE_CLE_OUTPUT &&
                     head.getIntentCode() == IntentCode.NODE_PINFEED &&

test/src/com/xilinx/rapidwright/rwroute/TestRWRoute.java

@@ -382,6 +382,15 @@ Design testSingleConnectionHelper(String partName,
                                     String srcSiteName, String srcPinName,
                                     String dstSiteName, String dstPinName,
                                     long nodesPoppedLimit) {
+        boolean backwardRouting = false;
+        return testSingleConnectionHelper(partName, srcSiteName, srcPinName, dstSiteName, dstPinName, nodesPoppedLimit, backwardRouting);
+    }
+
+    Design testSingleConnectionHelper(String partName,
+                                      String srcSiteName, String srcPinName,
+                                      String dstSiteName, String dstPinName,
+                                      long nodesPoppedLimit,
+                                      boolean backwardRouting) {
         Design design = new Design("top", partName);
 
         Net net = design.createNet("net");
@@ -394,10 +403,16 @@ Design testSingleConnectionHelper(String partName,
         List<SitePinInst> pinsToRoute = new ArrayList<>();
         pinsToRoute.add(dstSpi);
         boolean softPreserve = false;
-        PartialRouter.routeDesignPartialNonTimingDriven(design, pinsToRoute, softPreserve);
+
+        if (backwardRouting) {
+            PartialRouter.routeDesignPartialNonTimingDrivenBackward(design, pinsToRoute, softPreserve);
+        } else {
+            PartialRouter.routeDesignPartialNonTimingDriven(design, pinsToRoute, softPreserve);
+        }
 
         Assertions.assertTrue(srcSpi.isRouted());
         Assertions.assertTrue(dstSpi.isRouted());
+
         long nodesPopped = Long.parseLong(System.getProperty("rapidwright.rwroute.nodesPopped"));
         Assertions.assertTrue(nodesPopped >= (nodesPoppedLimit - 100) && nodesPopped <= nodesPoppedLimit);
 
@@ -559,6 +574,21 @@ public void testSingleConnection(String partName,
                 nodesPoppedLimit);
     }
 
+    @ParameterizedTest
+    @CsvSource({
+            "xcau10p,SLICE_X0Y0,A_O,SLICE_X0Y1,A1,400"
+    })
+    public void testSingleConnectionBackward(String partName,
+                                     String srcSiteName, String srcPinName,
+                                     String dstSiteName, String dstPinName,
+                                     int nodesPoppedLimit) {
+        testSingleConnectionHelper(partName,
+                srcSiteName, srcPinName,
+                dstSiteName, dstPinName,
+                nodesPoppedLimit,
+                true);
+    }
+
     @Test
     public void testDiscussion1245_20250805() {
         // Adapted from https://github.com/Xilinx/RapidWright/discussions/1245#discussioncomment-14003055