Merge pull request #224 from DFiantHDL/designparam_refactor

Designparam refactor

Author: soronpo

compiler/ir/src/main/scala/dfhdl/compiler/analysis/DFValAnalysis.scala

@@ -41,19 +41,26 @@ object Ident:
 //  val arg: Bit <> CONST = newArg
 //  val x = Bit <> IN init arg
 //```
-object DesignParam:
-  def unapply(alias: DFVal.Alias.AsIs)(using MemberGetSet): Option[DFVal] =
-    if (alias.hasTagOf[DFVal.Alias.DesignParamTag.type])
-      val relVal = alias.relValRef.get
-      // if (
-      //   relVal.existsInComposedReadDeps { dep =>
-      //     dep.hasTagOf[DFVal.Alias.DesignParamTag.type] &&
-      //     dep.isSameOwnerDesignAs(alias)
-      //   }
-      // ) None
-      Some(relVal)
-    else None
-end DesignParam
+// object DesignParam:
+//   def unapply(alias: DFVal.Alias.AsIs)(using MemberGetSet): Option[DFVal] =
+//     if (alias.hasTagOf[DFVal.Alias.DesignParamTag.type])
+//       val relVal = alias.relValRef.get
+//       // if (
+//       //   relVal.existsInComposedReadDeps { dep =>
+//       //     dep.hasTagOf[DFVal.Alias.DesignParamTag.type] &&
+//       //     dep.isSameOwnerDesignAs(alias)
+//       //   }
+//       // ) None
+//       Some(relVal)
+//     else None
+// end DesignParam
+
+//extract the design param from its default value
+object DefaultOfDesignParam:
+  def unapply(dfVal: DFVal)(using MemberGetSet): Option[DFVal.DesignParam] =
+    dfVal.originMembers.collectFirst {
+      case dp: DFVal.DesignParam if dp.defaultRef.get == dfVal => dp
+    }
 
 object OpaqueActual:
   def unapply(alias: DFVal.Alias.AsIs)(using MemberGetSet): Option[DFVal] =
@@ -410,7 +417,7 @@ extension (net: DFNet)
 extension (member: DFMember)
   def isPublicMember(using MemberGetSet): Boolean =
     member match
-      case DclPort()      => true
-      case DesignParam(_) => true
-      case _: DomainBlock => true
-      case _              => false
+      case DclPort()            => true
+      case _: DFVal.DesignParam => true
+      case _: DomainBlock       => true
+      case _                    => false

compiler/ir/src/main/scala/dfhdl/compiler/ir/DB.scala

@@ -753,7 +753,9 @@ final case class DB(
       membersNoGlobals.view.drop(1).flatMap {
         case _: PortByNameSelect => None
         case m =>
-          val isDesignParam = m.hasTagOf[DFVal.Alias.DesignParamTag.type]
+          val isDesignParam = m match
+            case _: DFVal.DesignParam => true
+            case _                    => false
           m.getRefs.view.map(_.get).flatMap {
             // global values are ok to be referenced
             case dfVal: DFVal.CanBeGlobal if dfVal.isGlobal => None
@@ -765,18 +767,21 @@ final case class DB(
               if (refMember.isOutsideOwner(m.getOwnerDesign))
                 Some(refMember)
               else None
-            // design parameters are expected to reference values from their parent design
-            case refMember if isDesignParam =>
-              if (m.isOneLevelBelow(refMember)) None
-              else Some(refMember)
             // design referenced by its member (like in RelatedDomain)
             case refMember: DFDesignBlock =>
               if (m.isMemberOf(refMember)) None
               else Some(refMember)
-            // the rest must be in the same design
-            case refMember if !refMember.isSameOwnerDesignAs(m) =>
-              Some(refMember)
-            case _ => None
+            case refMember =>
+              m match
+                // design parameters are expected to reference values from their parent design
+                // or from the same design for default parameter values
+                case dp: DFVal.DesignParam =>
+                  if (refMember.isSameOwnerDesignAs(dp) && dp.defaultRef.get == refMember) None
+                  else if (m.isOneLevelBelow(refMember)) None
+                  else Some(refMember)
+                // the rest must be in the same design
+                case _ if !refMember.isSameOwnerDesignAs(m) => Some(refMember)
+                case _                                      => None
           }.map(m -> _)
       }.toList
     val errorMessages = problemReferences.map { (from, to) =>

compiler/ir/src/main/scala/dfhdl/compiler/ir/DFMember.scala

@@ -155,11 +155,13 @@ sealed trait DFVal extends DFMember.Named:
   final def isConst(using MemberGetSet): Boolean = getConstData.nonEmpty
   // two expressions are considered to be similar if
   final def isSimilarTo(that: DFVal)(using MemberGetSet): Boolean =
-    def dealiasAsIs(dfVal: DFVal): DFVal = dfVal match
+    def stripAsIsAndDesignParam(dfVal: DFVal): DFVal = dfVal match
       case DFVal.Alias.AsIs(dfType, DFRef(relVal), _, _, _) if dfType == relVal.dfType =>
-        dealiasAsIs(relVal)
+        stripAsIsAndDesignParam(relVal)
+      case DFVal.DesignParam(_, DFRef(dfVal), _, _, _, _) =>
+        stripAsIsAndDesignParam(dfVal)
       case _ => dfVal
-    (dealiasAsIs(this), dealiasAsIs(that)) match
+    (stripAsIsAndDesignParam(this), stripAsIsAndDesignParam(that)) match
       case (lhs: DFVal.CanBeExpr, rhs: DFVal.CanBeExpr) => lhs.protIsSimilarTo(rhs)
       case (lhs, rhs)                                   => lhs == rhs
   protected def protGetConstData(using MemberGetSet): Option[Any]
@@ -221,6 +223,9 @@ object DFVal:
     def isOpen: Boolean = dfVal match
       case _: DFVal.OPEN => true
       case _             => false
+    def isDesignParam: Boolean = dfVal match
+      case _: DFVal.DesignParam => true
+      case _                    => false
     @tailrec def dealias(using MemberGetSet): Option[DFVal.Dcl | DFVal.OPEN] = dfVal match
       case dcl: DFVal.Dcl                           => Some(dcl)
       case portByNameSelect: DFVal.PortByNameSelect => Some(portByNameSelect.getPortDcl)
@@ -337,6 +342,48 @@ object DFVal:
     ).asInstanceOf[this.type]
   end Const
 
+  final case class DesignParam(
+      dfType: DFType,
+      dfValRef: DesignParam.Ref,
+      defaultRef: DesignParam.DefaultRef,
+      ownerRef: DFOwner.Ref,
+      meta: Meta,
+      tags: DFTags
+  ) extends CanBeExpr:
+    assert(!this.isAnonymous, "Design parameters cannot be anonymous.")
+    protected def protIsFullyAnonymous(using MemberGetSet): Boolean = false
+    protected def protGetConstData(using MemberGetSet): Option[Any] =
+      dfValRef.get.getConstData
+    protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
+      case that: DesignParam =>
+        // design parameters are considered to be the same even if they are referencing
+        // a different member (this should be quite common), because that member is
+        // external to the design. however, different default value is considered to be a
+        // different design parameter.
+        this.dfType =~ that.dfType && this.defaultRef =~ that.defaultRef &&
+        this.meta =~ that.meta && this.tags =~ that.tags
+      case _ => false
+    protected[ir] def protIsSimilarTo(that: CanBeExpr)(using MemberGetSet): Boolean =
+      that match
+        case that: DesignParam =>
+          this.dfType.isSimilarTo(that.dfType) &&
+          this.dfValRef.get.isSimilarTo(that.dfValRef.get)
+        case _ => false
+    protected def setMeta(meta: Meta): this.type = copy(meta = meta).asInstanceOf[this.type]
+    protected def setTags(tags: DFTags): this.type = copy(tags = tags).asInstanceOf[this.type]
+    lazy val getRefs: List[DFRef.TwoWayAny] = dfValRef :: defaultRef :: dfType.getRefs
+    def updateDFType(dfType: DFType): this.type = copy(dfType = dfType).asInstanceOf[this.type]
+    def copyWithNewRefs: this.type = copy(
+      dfType = dfType.copyWithNewRefs,
+      ownerRef = ownerRef.copyAsNewRef,
+      dfValRef = dfValRef.copyAsNewRef,
+      defaultRef = defaultRef.copyAsNewRef
+    ).asInstanceOf[this.type]
+  end DesignParam
+  object DesignParam:
+    type Ref = DFRef.TwoWay[DFVal, DesignParam]
+    type DefaultRef = DFRef.TwoWay[DFVal | DFMember.Empty, DesignParam]
+
   final case class OPEN(
       dfType: DFType,
       ownerRef: DFOwner.Ref
@@ -517,7 +564,6 @@ object DFVal:
 
   object Alias:
     case object IdentTag extends DFTagOf[DFVal]
-    case object DesignParamTag extends DFTagOf[DFVal]
     type Ref = DFRef.TwoWay[DFVal, Alias]
     // This is complete alias that consumes its relative val
     sealed trait Consumer extends Alias:
@@ -546,13 +592,7 @@ object DFVal:
         )
       protected def `prot_=~`(that: DFMember)(using MemberGetSet): Boolean = that match
         case that: AsIs =>
-          // design parameters are considered to be the same even if they are referencing
-          // a different member (this should be quite common), because that member is
-          // external to the design.
-          val sameRelVal =
-            if (this.hasTagOf[DesignParamTag.type]) true
-            else this.relValRef =~ that.relValRef
-          this.dfType =~ that.dfType && sameRelVal &&
+          this.dfType =~ that.dfType && this.relValRef =~ that.relValRef &&
           this.meta =~ that.meta && this.tags =~ that.tags
         case _ => false
       protected[ir] def protIsSimilarTo(that: CanBeExpr)(using MemberGetSet): Boolean =

compiler/ir/src/main/scala/dfhdl/compiler/printing/DFOwnerPrinter.scala

@@ -18,7 +18,7 @@ trait AbstractOwnerPrinter extends AbstractPrinter:
         // excluding binds
         case Bind(_) => false
         // excluding design params
-        case DesignParam(_) => false
+        case _: DFVal.DesignParam => false
         // an ident placeholder (can be anonymous)
         case Ident(_) => true
         // a def design that is anonymous may not be referenced later,
@@ -176,7 +176,7 @@ protected trait DFOwnerPrinter extends AbstractOwnerPrinter:
     val defArgsCS =
       if (defArgList.length <= 2) defArgList.mkString(", ")
       else defArgList.mkString("\n", ",\n", "\n").hindent(2)
-    val designParamList = design.members(MemberView.Folded).collect { case param @ DesignParam(_) =>
+    val designParamList = design.members(MemberView.Folded).collect { case param: DesignParam =>
       s"${param.getName}${printer.csDFValConstType(param.dfType)}"
     }
     val designParamCS =
@@ -194,8 +194,8 @@ protected trait DFOwnerPrinter extends AbstractOwnerPrinter:
       val DFNet.Connection(_, from: DFVal, _) = port.getConnectionTo.get: @unchecked
       printer.csDFValRef(from, design.getOwner)
     }.mkString(", ")
-    val designParamList = design.members(MemberView.Folded).collect { case param @ DesignParam(_) =>
-      s"${param.getName} = ${param.relValRef.refCodeString}"
+    val designParamList = design.members(MemberView.Folded).collect { case param: DesignParam =>
+      s"${param.getName} = ${param.dfValRef.refCodeString}"
     }
     val designParamCS =
       if (designParamList.length == 0) ""
@@ -218,8 +218,13 @@ protected trait DFOwnerPrinter extends AbstractOwnerPrinter:
           case _                   => s"(${printer.csRTDomainCfg(rt.cfg)})"
         s"""RTDesign$cfgStr""".stripMargin
       case _ => "EDDesign"
-    val designParamList = design.members(MemberView.Folded).collect { case param @ DesignParam(_) =>
-      val defaultValue = if (design.isTop) s" = ${param.relValRef.refCodeString}" else ""
+    val designParamList = design.members(MemberView.Folded).collect { case param: DesignParam =>
+      val defaultValue =
+        if (design.isTop) s" = ${param.dfValRef.refCodeString}"
+        else
+          param.defaultRef.get match
+            case DFMember.Empty => ""
+            case _              => s" = ${param.defaultRef.refCodeString}"
       s"val ${param.getName}${printer.csDFValConstType(param.dfType)}$defaultValue"
     }
     val designParamCS =
@@ -233,8 +238,8 @@ protected trait DFOwnerPrinter extends AbstractOwnerPrinter:
   end csDFDesignBlockDcl
   def csDFDesignBlockInst(design: DFDesignBlock): String =
     val body = csDFDesignLateBody(design)
-    val designParamList = design.members(MemberView.Folded).collect { case param @ DesignParam(_) =>
-      s"${param.getName} = ${param.relValRef.refCodeString}"
+    val designParamList = design.members(MemberView.Folded).collect { case param: DesignParam =>
+      s"${param.getName} = ${param.dfValRef.refCodeString}"
     }
     val designParamCS =
       if (designParamList.length <= 1) designParamList.mkString("(", ", ", ")")

compiler/ir/src/main/scala/dfhdl/compiler/printing/DFValPrinter.scala

@@ -73,7 +73,7 @@ trait AbstractValPrinter extends AbstractPrinter:
     extension (named: DFMember.Named)
       def nameCS: String = if (typeCS) s"${csDFMemberName(named)}.type" else csDFMemberName(named)
     member match
-      case dfVal @ DesignParam(_) => dfVal.nameCS
+      case dfVal: DFVal.DesignParam => dfVal.nameCS
       case dfVal: DFVal.CanBeGlobal if dfVal.isGlobal =>
         if (dfVal.isAnonymous) printer.csDFValExpr(dfVal)
         else dfVal.nameCS
@@ -133,6 +133,7 @@ trait AbstractValPrinter extends AbstractPrinter:
       case dv: Const                => csDFValConstExpr(dv)
       case dv: Func                 => csDFValFuncExpr(dv, typeCS)
       case dv: Alias                => csDFValAliasExpr(dv)
+      case dv: DFVal.DesignParam    => dv.dfValRef.refCodeString
       case dv: DFConditional.Header => printer.csDFConditional(dv)
       case dv: Timer.IsActive       => csTimerIsActive(dv)
       case dv: NOTHING              => csNOTHING(dv)

compiler/stages/src/main/resources/dfhdl_defs.svh

@@ -24,9 +24,6 @@
 //  
 //  For more information, please refer to <http://unlicense.org/>
 
-`ifndef DFHDL_DEFS
-`define DFHDL_DEFS
 `define MAX(a,b) ((a) > (b) ? (a) : (b))
 `define MIN(a,b) ((a) < (b) ? (a) : (b))
-`endif
 

compiler/stages/src/main/resources/dfhdl_defs.vh

@@ -24,8 +24,6 @@
 //  
 //  For more information, please refer to <http://unlicense.org/>
 
-`ifndef DFHDL_DEFS
-`define DFHDL_DEFS
 `define MAX(a,b) ((a) > (b) ? (a) : (b))
 `define MIN(a,b) ((a) < (b) ? (a) : (b))
 `define TO_VEC_HEX(hex, hw, vw) \
@@ -77,5 +75,4 @@ begin
   end
 end
 endfunction
-`endif
 

compiler/stages/src/main/scala/dfhdl/compiler/analysis/DBAnalysis.scala

@@ -15,7 +15,7 @@ extension (designDB: DB)
   def getUnusedParamAnnotValues: List[DFVal] =
     import designDB.getSet
     designDB.members.collect:
-      case dfVal @ DesignParam(_) if dfVal.wasConstDataAccessed => dfVal
+      case dfVal: DFVal.DesignParam if dfVal.wasConstDataAccessed => dfVal
   def getUnusedBitsValues: List[(DFVal, Int, Int)] =
     import designDB.getSet
     designDB.members.flatMap:

compiler/stages/src/main/scala/dfhdl/compiler/stages/GlobalizePortVectorParams.scala

@@ -9,7 +9,6 @@ import scala.collection.immutable.ListMap
 import scala.collection.mutable
 import dfhdl.compiler.stages.vhdl.VHDLDialect
 import dfhdl.core.{DFTypeAny, asFE}
-import dfhdl.compiler.ir.DFVal.Alias.DesignParamTag
 import dfhdl.compiler.ir.DFVal.PortByNameSelect
 
 /** This stage globalizes design parameters that set port vector lengths. This is needed only for
@@ -30,14 +29,16 @@ case object GlobalizePortVectorParams extends Stage:
     val designParams = mutable.LinkedHashSet.empty[DFVal]
     // check ref
     def checkRef(ref: DFRef.TwoWayAny): Int =
-      val dfVal = ref.get.asInstanceOf[DFVal]
-      if (dfVal.isGlobal) 0
-      else
-        val ret = dfVal.getRefs.map(checkRef).sum
-        if (dfVal.isAnonymous) ret
-        else
-          designParams += dfVal
-          ret + 1
+      ref.get match
+        case dfVal: DFVal =>
+          if (dfVal.isGlobal) 0
+          else
+            val ret = dfVal.getRefs.map(checkRef).sum
+            if (dfVal.isAnonymous) ret
+            else
+              designParams += dfVal
+              ret + 1
+        case _ => 0
     // check int param ref
     def checkIntParamRef(intParamRef: IntParamRef): Int =
       intParamRef.getRef.map(checkRef).getOrElse(0)
@@ -171,9 +172,23 @@ case object GlobalizePortVectorParams extends Stage:
     val dsn = new MetaDesign(dupDesignDB.top, Patch.Add.Config.Before):
       // patches to replace with properly named parameter or just move the anonymous members
       val replacePatches = addedGlobals.map {
-        case m if !m.isAnonymous =>
+        // design parameters are transformed into global as-is named aliases
+        case param: DFVal.DesignParam =>
+          val updatedMeta = param.meta.setName(param.getFullName.replaceAll("\\.", "_"))
           val globalParam =
-            m.setName(m.getFullName.replaceAll("\\.", "_")).removeTagOf[DesignParamTag.type]
+            DFVal.Alias.AsIs(
+              param.dfType,
+              // TODO: the class tag here is incorrect (currently is DesignParam) and should be fixed or...
+              // do we really need the tags at all?
+              param.dfValRef.asInstanceOf[DFVal.Alias.PartialRef],
+              param.ownerRef,
+              updatedMeta,
+              param.tags
+            )
+          plantMember(globalParam)
+          param -> Patch.Replace(globalParam, Patch.Replace.Config.ChangeRefAndRemove)
+        case m if !m.isAnonymous =>
+          val globalParam = m.setName(m.getFullName.replaceAll("\\.", "_"))
           plantMember(globalParam)
           m -> Patch.Replace(globalParam, Patch.Replace.Config.ChangeRefAndRemove)
         case m =>

compiler/stages/src/main/scala/dfhdl/compiler/stages/OrderMembers.scala

@@ -33,21 +33,23 @@ object OrderMembers:
   object Order:
     object Simple extends Order:
       def apply()(using MemberGetSet): DFMember => Int = {
-        // design parameters come first as they are dependent only on external
-        // initialization and everything else can depend on them
-        case DesignParam(_) => 1
-        // anonymous members that are referenced by declarations come second
-        case dfVal: DFVal if dfVal.isReferencedByAnyDcl => 2
-        // third to come are constant declarations that may be referenced by ports
-        case DclConst() => 3
-        // fourth are ports
-        case DclPort() => 4
-        // fifth are variables
-        case DclVar() => 5
-        // sixth are design blocks instances
-        case _: DFDesignBlock => 6
+        // design parameter's default value comes first
+        case DefaultOfDesignParam(_) => 1
+        // design parameters come second as they are dependent only on external
+        // initialization or default values and everything else can depend on them
+        case _: DFVal.DesignParam => 2
+        // anonymous members that are referenced by declarations come third
+        case dfVal: DFVal if dfVal.isReferencedByAnyDcl => 3
+        // fourth to come are constant declarations that may be referenced by ports
+        case DclConst() => 4
+        // fifth are ports
+        case DclPort() => 5
+        // sixth are variables
+        case DclVar() => 6
+        // seventh are design blocks instances
+        case _: DFDesignBlock => 7
         // then the rest
-        case _ => 7
+        case _ => 8
       }
     end Simple
 //    val GuardedLast: Order = new Order: