Fix D/I sources to cross compile

Author: adkian-sifive

core/src/main/scala-2/chisel3/experimental/hierarchy/InstantiateImpl.scala

@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package chisel3.experimental.hierarchy
+
+import scala.reflect.runtime.{universe => ru}
+import scala.collection.mutable
+
+import chisel3._
+import chisel3.experimental.{BaseModule, SourceInfo, UnlocatableSourceInfo}
+import chisel3.reflect.DataMirror
+import chisel3.reflect.DataMirror.internal.isSynthesizable
+import chisel3.internal.Builder
+
+private[chisel3] trait InstantiateImpl {
+
+  // Data uses referential equality by default, but for looking up Data in the cache, we need to use
+  // structural equality for Data unbound types and literal values
+  // Note that this is somewhat incomplete because we can't handle the general case of user-defined
+  // types that contain Data.
+  // A more complete and robust solution would require either refining hashCode and equality on Data
+  // to have the desired behavior, or using a different Map implementation that uses typeclasses for
+  // equality and hashcode (eg. cats-collections-core's HashMap)
+  private class DataBox(private val d: Data) {
+
+    private def convertDataForHashing(data: Data): Any = data match {
+      // Using toString is a bit weird but it works
+      case elt: Element => elt.toString
+      case rec: Record  =>
+        // Purely structural, actual class of Record isn't involved
+        rec.elements.map { case (name, data) => name -> convertDataForHashing(data) }
+      case vec: Vec[_] =>
+        // We could map on elements but that's a lot of duplicated work for a type
+        // Note that empty vecs of the same type will give same hash value, probably should be equal
+        // as well, but Vec.typeEquivalent checks sample_element so they will not be equal
+        ("Vec", vec.size, vec.headOption.map(convertDataForHashing(_)))
+    }
+
+    override def hashCode: Int = convertDataForHashing(d).hashCode
+
+    // If literals, check same types and equal
+    // If types, chck same types
+    // If bound, fall back to normal equality
+    override def equals(that: Any): Boolean = {
+      that match {
+        case that: DataBox =>
+          // def because it's not needed by non-literal but is synthesizable check
+          def sameTypes = DataMirror.checkTypeEquivalence(this.d, that.d)
+          // Lits are synthesizable so must check them first
+          if (this.d.isLit) {
+            that.d.isLit &&
+            (this.d.litValue == that.d.litValue) &&
+            sameTypes
+          } else if (isSynthesizable(this.d)) {
+            this.d.equals(that.d)
+          } else {
+            // We have checked that this.d is not synthesizable but need to check that.d as well
+            sameTypes && !isSynthesizable(that.d)
+          }
+
+        case _ => false
+      }
+    }
+  }
+
+  // Recursively box all Data (by traversing Products and Iterables) in DataBoxes
+  private def boxAllData(a: Any): Any = a match {
+    case d: Data => new DataBox(d) // Must check this before Iterable because Vec is Iterable
+    // Must check before Product, because many Iterables are Products, but can still be equal, eg. List(1) == Vector(1)
+    case it: Iterable[_] => it.map(boxAllData(_))
+    case p:  Product     => Vector(p.getClass) ++ p.productIterator.map(boxAllData(_))
+    case other => other
+  }
+
+  import chisel3.internal.BuilderContextCache
+  // Include type of module in key since different modules could have the same arguments
+  private case class CacheKey[A <: BaseModule](args: Any, tt: Any, modulePrefix: List[String])
+      extends BuilderContextCache.Key[Definition[A]]
+
+  protected def _instanceImpl[K, A <: BaseModule](
+    args: K,
+    f:    K => A,
+    tt:   Any
+  )(
+    implicit sourceInfo: SourceInfo
+  ): Instance[A] = Instance.do_apply(_definitionImpl(args, f, tt))(sourceInfo)
+
+  /** This is not part of the public API, do not call directly! */
+  protected def _definitionImpl[K, A <: BaseModule](
+    args: K,
+    f:    K => A,
+    tt:   Any
+  ): Definition[A] = {
+    val modulePrefix = Builder.getModulePrefixList
+    Builder.contextCache
+      .getOrElseUpdate(
+        CacheKey[A](boxAllData(args), tt, modulePrefix), {
+          // The definition needs to have no source locator because otherwise it will be unstably
+          // derived from the first invocation of Instantiate for the particular Module
+          Definition.do_apply(f(args))(UnlocatableSourceInfo)
+        }
+      )
+      .asInstanceOf[Definition[A]]
+  }
+}

core/src/main/scala-2/chisel3/experimental/hierarchy/core/Hierarchy.scala

@@ -0,0 +1,68 @@
+package chisel3.experimental.hierarchy.core
+
+import chisel3._
+import scala.collection.mutable.{HashMap, HashSet}
+import chisel3.experimental.BaseModule
+import _root_.firrtl.annotations.IsModule
+import scala.reflect.runtime.universe.TypeTag
+
+trait Hierarchy[+A] extends HierarchyImpl[A] {
+/** Determine whether underlying proto is of type provided.
+    *
+    * @note IMPORTANT: this function requires summoning a TypeTag[B], which will fail if B is an inner class.
+    * @note IMPORTANT: this function IGNORES type parameters, akin to normal type erasure.
+    * @note IMPORTANT: this function relies on Java reflection for underlying proto, but Scala reflection for provided type
+    *
+    * E.g. isA[List[Int]] will return true, even if underlying proto is of type List[String]
+    * @return Whether underlying proto is of provided type (with caveats outlined above)
+    */
+  def isA[B: TypeTag]: Boolean = {
+    val tptag = implicitly[TypeTag[B]]
+    // drop any type information for the comparison, because the proto will not have that information.
+    val name = tptag.tpe.toString.takeWhile(_ != '[')
+    inBaseClasses(name)
+  }
+
+}
+
+object Hierarchy {
+  implicit class HierarchyBaseModuleExtensions[T <: BaseModule](i: Hierarchy[T]) {
+
+    /** Returns the toTarget of this hierarchy
+      * @return target of this hierarchy
+      */
+    def toTarget: IsModule = i match {
+      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toTarget
+      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toTarget
+      case _ => throw new InternalErrorException("Match error: toTarget i=$i")
+    }
+
+    /** Returns the toAbsoluteTarget of this hierarchy
+      * @return absoluteTarget of this Hierarchy
+      */
+    def toAbsoluteTarget: IsModule = i match {
+      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toAbsoluteTarget
+      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toAbsoluteTarget
+      case _ => throw new InternalErrorException("Match error: toAbsoluteTarget i=$i")
+    }
+
+    /** Returns the toRelativeTarget of this hierarchy
+      * @return relativeTarget of this Hierarchy
+      */
+    def toRelativeTarget(root: Option[BaseModule]): IsModule = i match {
+      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toRelativeTarget(root)
+      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toRelativeTarget(root)
+      case _ => throw new InternalErrorException("Match error: toAbsoluteTarget i=$i")
+    }
+
+    /** Returns the toRelativeTarget of this hierarchy
+      * @return relativeTarget of this Hierarchy
+      */
+    def toRelativeTargetToHierarchy(root: Option[Hierarchy[BaseModule]]): IsModule = i match {
+      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toRelativeTargetToHierarchy(root)
+      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toRelativeTargetToHierarchy(root)
+      case _ => throw new InternalErrorException("Match error: toAbsoluteTarget i=$i")
+    }
+
+  }
+}

core/src/main/scala/chisel3/experimental/hierarchy/core/Definition.scala

@@ -9,7 +9,6 @@ import chisel3.internal.{Builder, DynamicContext}
 import chisel3.internal.firrtl.Converter
 import chisel3.experimental.{BaseModule, SourceInfo}
 import firrtl.annotations.{IsModule, ModuleTarget, NoTargetAnnotation}
-
 import firrtl.seqToAnnoSeq
 
 import scala.annotation.nowarn

core/src/main/scala/chisel3/experimental/hierarchy/core/Hierarchy.scala renamed to core/src/main/scala/chisel3/experimental/hierarchy/core/HierarchyImpl.scala

@@ -5,7 +5,6 @@ package chisel3.experimental.hierarchy.core
 import chisel3._
 
 import scala.collection.mutable.{HashMap, HashSet}
-import scala.reflect.runtime.universe.TypeTag
 import chisel3.experimental.BaseModule
 import _root_.firrtl.annotations.IsModule
 
@@ -15,7 +14,7 @@ import scala.annotation.implicitNotFound
   *
   * Enables writing functions which are Instance/Definition agnostic
   */
-sealed trait Hierarchy[+A] {
+trait HierarchyImpl[+A] {
   private[chisel3] def underlying: Underlying[A]
   private[chisel3] def proto: A = underlying match {
     case Proto(value) => value
@@ -26,22 +25,6 @@ sealed trait Hierarchy[+A] {
   private[chisel3] val cache = HashMap[Data, Data]()
   private[chisel3] def getInnerDataContext: Option[BaseModule]
 
-  /** Determine whether underlying proto is of type provided.
-    *
-    * @note IMPORTANT: this function requires summoning a TypeTag[B], which will fail if B is an inner class.
-    * @note IMPORTANT: this function IGNORES type parameters, akin to normal type erasure.
-    * @note IMPORTANT: this function relies on Java reflection for underlying proto, but Scala reflection for provided type
-    *
-    * E.g. isA[List[Int]] will return true, even if underlying proto is of type List[String]
-    * @return Whether underlying proto is of provided type (with caveats outlined above)
-    */
-  def isA[B: TypeTag]: Boolean = {
-    val tptag = implicitly[TypeTag[B]]
-    // drop any type information for the comparison, because the proto will not have that information.
-    val name = tptag.tpe.toString.takeWhile(_ != '[')
-    inBaseClasses(name)
-  }
-
   // This code handles a special-case where, within an mdoc context, the type returned from
   //  scala reflection (typetag) looks different than when returned from java reflection.
   //  This function detects this case and reshapes the string to match.
@@ -95,45 +78,3 @@ sealed trait Hierarchy[+A] {
 
 // Used to effectively seal Hierarchy, without requiring Definition and Instance to be in this file.
 private[chisel3] trait SealedHierarchy[+A] extends Hierarchy[A]
-
-object Hierarchy {
-  implicit class HierarchyBaseModuleExtensions[T <: BaseModule](i: Hierarchy[T]) {
-
-    /** Returns the toTarget of this hierarchy
-      * @return target of this hierarchy
-      */
-    def toTarget: IsModule = i match {
-      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toTarget
-      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toTarget
-      case _ => throw new InternalErrorException(s"Match error: toTarget i=$i")
-    }
-
-    /** Returns the toAbsoluteTarget of this hierarchy
-      * @return absoluteTarget of this Hierarchy
-      */
-    def toAbsoluteTarget: IsModule = i match {
-      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toAbsoluteTarget
-      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toAbsoluteTarget
-      case _ => throw new InternalErrorException(s"Match error: toAbsoluteTarget i=$i")
-    }
-
-    /** Returns the toRelativeTarget of this hierarchy
-      * @return relativeTarget of this Hierarchy
-      */
-    def toRelativeTarget(root: Option[BaseModule]): IsModule = i match {
-      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toRelativeTarget(root)
-      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toRelativeTarget(root)
-      case _ => throw new InternalErrorException(s"Match error: toAbsoluteTarget i=$i")
-    }
-
-    /** Returns the toRelativeTarget of this hierarchy
-      * @return relativeTarget of this Hierarchy
-      */
-    def toRelativeTargetToHierarchy(root: Option[Hierarchy[BaseModule]]): IsModule = i match {
-      case d: Definition[T] => new Definition.DefinitionBaseModuleExtensions(d).toRelativeTargetToHierarchy(root)
-      case i: Instance[T]   => new Instance.InstanceBaseModuleExtensions(i).toRelativeTargetToHierarchy(root)
-      case _ => throw new InternalErrorException(s"Match error: toAbsoluteTarget i=$i")
-    }
-
-  }
-}

core/src/main/scala/chisel3/experimental/hierarchy/core/Instance.scala

@@ -166,7 +166,7 @@ object Instance extends SourceInfoDoc {
           Some(component)
         }
       }
-      Definition(new EmptyExtModule() {})
+      Definition(new EmptyExtModule() {}.asInstanceOf[Underlying[_]])
     }
 
     val ports = experimental.CloneModuleAsRecord(definition.proto)