[MSFT] Add multicycle path op

include/circt/Dialect/MSFT/MSFTOpInterfaces.h

@@ -14,7 +14,13 @@
 
 namespace circt {
 namespace msft {
-LogicalResult verifyDynInstData(Operation *);
+LogicalResult verifyUnaryDynInstDataOp(Operation *);
+
+/// Returns the top-level module which the given HierPathOp that defines
+/// pathSym, refers to.
+Operation *getHierPathTopModule(Location loc,
+                                circt::hw::HWSymbolCache &symCache,
+                                FlatSymbolRefAttr pathSym);
 class InstanceHierarchyOp;
 } // namespace msft
 } // namespace circt

include/circt/Dialect/MSFT/MSFTOpInterfaces.td

@@ -9,12 +9,31 @@
 include "mlir/IR/OpBase.td"
 
 def DynInstDataOpInterface : OpInterface<"DynInstDataOpInterface"> {
+  let description = [{
+    Interface for ops that define dynamic instance data.
+  }];
+  let cppNamespace = "::circt::msft";
+
+  let methods = [
+    InterfaceMethod<
+      /*desc=*/[{
+        Get the top module op to which this op is providing data for.
+      }],
+      /*retTy=*/"Operation *",
+      /*methodName=*/"getTopModule",
+      /*args=*/(ins "circt::hw::HWSymbolCache &":$symCache)
+    >
+  ];
+}
+
+  def UnaryDynInstDataOpInterface : OpInterface<"UnaryDynInstDataOpInterface",
+    [DynInstDataOpInterface]> {  
   let description = [{
     Interface for anything which needs to refer to a HierPathOp.
   }];
   let cppNamespace = "::circt::msft";
   let verify = [{
-    return ::circt::msft::verifyDynInstData($_op);
+    return ::circt::msft::verifyUnaryDynInstDataOp($_op);
   }];
 
   let methods = [
@@ -41,33 +60,6 @@ def DynInstDataOpInterface : OpInterface<"DynInstDataOpInterface"> {
       /*defaultImplementation=*/[{
         return $_op.getRefAttr();
       }]
-    >,
-    InterfaceMethod<
-      /*desc=*/[{
-        Get the top module op to which the HierPathOp which this op is referring.
-      }],
-      /*retTy=*/"Operation *",
-      /*methodName=*/"getTopModule",
-      /*args=*/(ins "circt::hw::HWSymbolCache &":$symCache),
-      /*methodBody=*/[{}],
-      /*defaultImplementation=*/[{
-        FlatSymbolRefAttr refSym = $_op.getPathSym();
-        if (!refSym) {
-          $_op->emitOpError("must run dynamic instance lowering first");
-          return nullptr;
-        }
-        auto ref = dyn_cast_or_null<hw::HierPathOp>(
-            symCache.getDefinition(refSym));
-        if (!ref) {
-          $_op->emitOpError("could not find hw.hierpath ") << refSym;
-          return nullptr;
-        }
-        if (ref.getNamepath().empty())
-          return nullptr;
-        auto modSym = FlatSymbolRefAttr::get(
-            ref.getNamepath()[0].cast<hw::InnerRefAttr>().getModule());
-        return symCache.getDefinition(modSym);
-      }]
     >
   ];
 }

include/circt/Dialect/MSFT/MSFTPDOps.td

@@ -22,7 +22,7 @@ def DeclPhysicalRegionOp : MSFTOp<"physical_region",
 }
 
 def PDPhysLocationOp : MSFTOp<"pd.location",
-      [DeclareOpInterfaceMethods<DynInstDataOpInterface>]> {
+      [DeclareOpInterfaceMethods<UnaryDynInstDataOpInterface>]> {
   let summary = "Specify a location for an instance";
   let description = [{
     Used to specify a specific location on an FPGA to place a dynamic instance.
@@ -38,10 +38,16 @@ def PDPhysLocationOp : MSFTOp<"pd.location",
   let assemblyFormat = [{
     ($ref^)? custom<PhysLoc>($loc) (`path` `:` $subPath^)? attr-dict
   }];
+
+  let extraClassDeclaration = [{
+    Operation* getTopModule(circt::hw::HWSymbolCache &symCache) {
+      return getHierPathTopModule(getOperation()->getLoc(), symCache, getPathSym());
+    }
+  }];
 }
 
 def PDRegPhysLocationOp : MSFTOp<"pd.reg_location",
-      [DeclareOpInterfaceMethods<DynInstDataOpInterface>]> {
+      [DeclareOpInterfaceMethods<UnaryDynInstDataOpInterface>]> {
   let summary = "Specify register locations";
   let description = [{
     A version of "PDPhysLocationOp" specialized for registers, which have one
@@ -52,10 +58,34 @@ def PDRegPhysLocationOp : MSFTOp<"pd.reg_location",
   let assemblyFormat = [{
     (`ref` $ref^)? custom<ListOptionalRegLocList>($locs) attr-dict
   }];
+
+  let extraClassDeclaration = [{
+    Operation* getTopModule(circt::hw::HWSymbolCache &symCache) {
+      return getHierPathTopModule(getOperation()->getLoc(), symCache, getPathSym());
+    }
+  }];
+}
+
+def PDMulticycleOp : MSFTOp<"pd.multicycle",
+    [DeclareOpInterfaceMethods<DynInstDataOpInterface>]> {
+  let summary = "Specify a multicycle constraint";
+  let description = [{
+    Specifies a multicycle constraint in between two registers.
+    `source` and `dest` symbols reference `HierPathOp` symbols denoting the
+    exact registers in the instance hierarchy to which the constraint applies.
+  }];
+  let arguments = (ins
+    FlatSymbolRefAttr:$source,
+    FlatSymbolRefAttr:$dest,
+    ConfinedAttr<I32Attr, [IntMinValue<1>]>:$cycles
+  );
+  let assemblyFormat = [{
+    $cycles $source `->` $dest attr-dict
+  }];
 }
 
 def PDPhysRegionOp : MSFTOp<"pd.physregion",
-      [DeclareOpInterfaceMethods<DynInstDataOpInterface>]> {
+      [DeclareOpInterfaceMethods<UnaryDynInstDataOpInterface>]> {
   let summary = "Specify a physical region for an instance";
   let description = [{
     Annotate a particular entity within an op with the region of the devices
@@ -68,6 +98,12 @@ def PDPhysRegionOp : MSFTOp<"pd.physregion",
   let assemblyFormat = [{
     ($ref^)? $physRegionRef (`path` `:` $subPath^)? attr-dict
   }];
+
+  let extraClassDeclaration = [{
+    Operation* getTopModule(circt::hw::HWSymbolCache &symCache) {
+      return getHierPathTopModule(getOperation()->getLoc(), symCache, getPathSym());
+    }
+  }];
 }
 
 def InstanceHierarchyOp : MSFTOp<"instance.hierarchy",
@@ -123,7 +159,8 @@ def DynamicInstanceOp : MSFTOp<"instance.dynamic",
 }
 
 def DynamicInstanceVerbatimAttrOp : MSFTOp<
-    "instance.verb_attr", [DeclareOpInterfaceMethods<DynInstDataOpInterface>]> {
+    "instance.verb_attr", [
+      DeclareOpInterfaceMethods<UnaryDynInstDataOpInterface>]> {
   let summary = "Specify an arbitrary attribute attached to a dynamic instance";
   let description = [{
     Allows a user to specify a custom attribute name and value which is attached
@@ -139,4 +176,10 @@ def DynamicInstanceVerbatimAttrOp : MSFTOp<
   let assemblyFormat = [{
     ($ref^)? `name` `:` $name `value` `:` $value (`path` `:` $subPath^)? attr-dict
   }];
+
+  let extraClassDeclaration = [{
+    Operation* getTopModule(circt::hw::HWSymbolCache &symCache) {
+      return getHierPathTopModule(getOperation()->getLoc(), symCache, getPathSym());
+    }
+  }];
 }

lib/Dialect/MSFT/ExportQuartusTcl.cpp

@@ -94,27 +94,33 @@ struct TclOutputState {
   SmallVector<Attribute> symbolRefs;
 
   void emit(PhysLocationAttr);
-  LogicalResult emitLocationAssignment(DynInstDataOpInterface refOp,
+  LogicalResult emitLocationAssignment(UnaryDynInstDataOpInterface refOp,
                                        PhysLocationAttr,
                                        std::optional<StringRef> subpath);
 
   LogicalResult emit(PDPhysRegionOp region);
   LogicalResult emit(PDPhysLocationOp loc);
   LogicalResult emit(PDRegPhysLocationOp);
   LogicalResult emit(DynamicInstanceVerbatimAttrOp attr);
+  LogicalResult emit(PDMulticycleOp op);
 
   void emitPath(hw::HierPathOp ref, std::optional<StringRef> subpath);
   void emitInnerRefPart(hw::InnerRefAttr innerRef);
 
   /// Get the HierPathOp to which the given operation is pointing. Add it to
   /// the set of used global refs.
-  HierPathOp getRefOp(DynInstDataOpInterface op) {
-    auto ref = dyn_cast_or_null<hw::HierPathOp>(
-        emitter.getDefinition(op.getPathSym()));
+  HierPathOp getRefOp(UnaryDynInstDataOpInterface op) {
+    return getRefOp(op.getLoc(), op.getPathSym());
+  }
+
+  /// Get the HierPathOp to which a given value is pointing. Add it to the
+  /// set of used global refs.
+  HierPathOp getRefOp(Location loc, FlatSymbolRefAttr pathSym) {
+    auto ref = dyn_cast_or_null<hw::HierPathOp>(emitter.getDefinition(pathSym));
     if (ref)
       emitter.usedRef(ref);
     else
-      op.emitOpError("could not find hw.hierpath named ") << op.getPathSym();
+      emitError(loc, "could not find hw.hierpath named ") << pathSym;
     return ref;
   }
 };
@@ -166,7 +172,7 @@ void TclOutputState::emit(PhysLocationAttr pla) {
 /// "set_location_assignment MPDSP_X34_Y285_N0 -to
 /// $parent|fooInst|entityName(subpath)"
 LogicalResult
-TclOutputState::emitLocationAssignment(DynInstDataOpInterface refOp,
+TclOutputState::emitLocationAssignment(UnaryDynInstDataOpInterface refOp,
                                        PhysLocationAttr loc,
                                        std::optional<StringRef> subpath) {
   indent() << "set_location_assignment ";
@@ -199,6 +205,19 @@ LogicalResult TclOutputState::emit(PDRegPhysLocationOp locs) {
   return success();
 }
 
+LogicalResult TclOutputState::emit(PDMulticycleOp op) {
+  indent() << "set_multicycle_path ";
+  os << "-hold 1 ";
+  os << "-setup " << op.getCycles() << " ";
+  os << "-from [get_registers {$parent|";
+  emitPath(getRefOp(op.getLoc(), op.getSourceAttr()), std::nullopt);
+  os << "}] ";
+  os << "-to [get_registers {$parent|";
+  emitPath(getRefOp(op.getLoc(), op.getDestAttr()), std::nullopt);
+  os << "}]\n";
+  return success();
+}
+
 /// Emit tcl in the form of:
 /// "set_global_assignment -name NAME VALUE -to $parent|fooInst|entityName"
 LogicalResult TclOutputState::emit(DynamicInstanceVerbatimAttrOp attr) {
@@ -299,6 +318,7 @@ LogicalResult TclEmitter::emit(Operation *hwMod, StringRef outputFile) {
               .Case([&](PDPhysLocationOp op) { return state.emit(op); })
               .Case([&](PDRegPhysLocationOp op) { return state.emit(op); })
               .Case([&](PDPhysRegionOp op) { return state.emit(op); })
+              .Case([&](PDMulticycleOp op) { return state.emit(op); })
               .Case([&](DynamicInstanceVerbatimAttrOp op) {
                 return state.emit(op);
               })

lib/Dialect/MSFT/MSFTOpInterfaces.cpp

@@ -12,9 +12,10 @@
 using namespace circt;
 using namespace msft;
 
-LogicalResult circt::msft::verifyDynInstData(Operation *op) {
+LogicalResult circt::msft::verifyUnaryDynInstDataOp(Operation *op) {
   auto inst = dyn_cast<DynamicInstanceOp>(op->getParentOp());
-  FlatSymbolRefAttr pathRef = cast<DynInstDataOpInterface>(op).getPathSym();
+  FlatSymbolRefAttr pathRef =
+      cast<UnaryDynInstDataOpInterface>(op).getPathSym();
 
   if (inst && pathRef)
     return op->emitOpError("cannot both have a global ref symbol and be a "
@@ -25,6 +26,22 @@ LogicalResult circt::msft::verifyDynInstData(Operation *op) {
   return success();
 }
 
+Operation *circt::msft::getHierPathTopModule(Location loc,
+                                             circt::hw::HWSymbolCache &symCache,
+                                             FlatSymbolRefAttr pathSym) {
+  assert(pathSym && "pathSym must be non-null");
+  auto ref = dyn_cast_or_null<hw::HierPathOp>(symCache.getDefinition(pathSym));
+  if (!ref) {
+    emitError(loc) << "could not find hw.hierpath " << pathSym;
+    return nullptr;
+  }
+  if (ref.getNamepath().empty())
+    return nullptr;
+  auto modSym = FlatSymbolRefAttr::get(
+      ref.getNamepath()[0].cast<hw::InnerRefAttr>().getModule());
+  return symCache.getDefinition(modSym);
+}
+
 namespace circt {
 namespace msft {
 #include "circt/Dialect/MSFT/MSFTOpInterfaces.cpp.inc"

lib/Dialect/MSFT/MSFTOps.cpp

@@ -248,5 +248,22 @@ LogicalResult LinearOp::verify() {
   return success();
 }
 
+//===----------------------------------------------------------------------===//
+// PDMulticycleOp
+//===----------------------------------------------------------------------===//
+
+Operation *PDMulticycleOp::getTopModule(hw::HWSymbolCache &cache) {
+  // Both symbols should reference the same top-level module in their respective
+  // HierPath ops.
+  Operation *srcTop = getHierPathTopModule(getLoc(), cache, getSourceAttr());
+  Operation *dstTop = getHierPathTopModule(getLoc(), cache, getDestAttr());
+  if (srcTop != dstTop) {
+    emitOpError("source and destination paths must refer to the same top-level "
+                "module.");
+    return nullptr;
+  }
+  return srcTop;
+}
+
 #define GET_OP_CLASSES
 #include "circt/Dialect/MSFT/MSFT.cpp.inc"

lib/Dialect/MSFT/Transforms/MSFTLowerInstances.cpp

@@ -80,7 +80,7 @@ LogicalResult LowerInstancesPass::lower(DynamicInstanceOp inst,
     hierBlock.insert(&op);
 
     // Assign a ref for ops which need it.
-    if (auto specOp = dyn_cast<DynInstDataOpInterface>(op)) {
+    if (auto specOp = dyn_cast<UnaryDynInstDataOpInterface>(op)) {
       assert(ref);
       specOp.setPathOp(ref);
     }

test/Dialect/MSFT/dynamic_instance.mlir

@@ -40,7 +40,11 @@ msft.instance.hierarchy @reg "bar" {
 // CHECK: hw.hierpath @instref_3 [@reg::@reg]
 // CHECK-DAG: msft.pd.reg_location ref @instref_3 i4 [<3, 4, 5>, *, *, *]
 
-
+hw.hierpath @reg.reg [@reg::@reg]
+hw.hierpath @reg.reg2 [@reg::@reg2]
+msft.instance.hierarchy @reg "multicycle" {
+  msft.pd.multicycle 2 @reg.reg -> @reg.reg2
+}
 
 hw.module.extern @Foo()
 
@@ -76,6 +80,7 @@ hw.module @deeper () {
 
 hw.module @reg (in %input : i4, in %clk : !seq.clock) {
   %reg = seq.compreg sym @reg %input, %clk  : i4
+  %reg2 = seq.compreg sym @reg2 %input, %clk  : i4
 }
 // TCL-LABEL: proc reg_0_foo_config
 // TCL: set_location_assignment FF_X1_Y2_N3 -to $parent|reg_0[1]
@@ -84,3 +89,6 @@ hw.module @reg (in %input : i4, in %clk : !seq.clock) {
 
 // TCL-LABEL: proc reg_0_bar_config
 // TCL: set_location_assignment FF_X3_Y4_N5 -to $parent|reg_0[0]
+
+// TCL-LABEL: proc reg_0_multicycle_config { parent } {
+// TCL: set_multicycle_path -hold 1 -setup 2 -from [get_registers {$parent|reg_0}] -to [get_registers {$parent|reg2}]