Update Chisel version to 5.1.0 (ucb-bar#8)

* Update Chisel version to 5.1.0

Remove deprecated APIs (`CompileOptions`, `fromDoubleToLiteral`,
`fromIntToBinaryPoint`, `fromBigDecimalToLiteral`,
`ChiselStage.elaborate`, `chisel3.experimental.FixedPoint`).

Remove `FixedPoint.typeEquivalent` definition, as this is now a `final`
method on `chisel3.Data`. See here for more context: chipsalliance/chisel#3201

Bump firtool version to 1.43.0

Author: tymcauley

.github/workflows/test.yml

@@ -20,8 +20,8 @@ env:
   VERILATOR_REPO: https://github.com/verilator/verilator
   VERILATOR_DIR: verilator
   VERILATOR_VERSION_TAG: v4.228
-  FIRTOOL_VERSION: v1.37.0
-  FIRTOOL_VERSION_TAG: firtool-1.37.0
+  FIRTOOL_VERSION: v1.43.0
+  FIRTOOL_VERSION_TAG: firtool-1.43.0
 
 jobs:
   test:

README.md

@@ -10,14 +10,14 @@ work just as it did before. To that end, the following classes/traits have been
 * BinaryPoint, KnownBinaryPoint, UnknownBinaryPoint
 * HasBinaryPoint
 
-Currently, this library works with [Chisel v3.6.0](https://github.com/chipsalliance/chisel/releases/v3.6.0).
+Currently, this library works with [Chisel v5.1.0](https://github.com/chipsalliance/chisel/releases/v5.1.0).
 
 ## Usage
 
 Here is an example module using this library's FixedPoint type:
 
 ```scala
-import chisel3.{fromDoubleToLiteral => _, fromIntToBinaryPoint => _, _}
+import chisel3._
 import circt.stage.ChiselStage
 import fixedpoint._
 
@@ -38,7 +38,7 @@ object ExampleApp extends App {
 This outputs the following SystemVerilog code:
 
 ```systemverilog
-// Generated by CIRCT firtool-1.37.0
+// Generated by CIRCT firtool-1.43.0
 module Example(	// <stdin>:3:10
   input         clock,	// <stdin>:4:11
                 reset,	// <stdin>:5:11
@@ -54,7 +54,7 @@ endmodule
 
 ## How It Works
 
-FixedPoint is implemented as an extension of `Record`, which has one *anonymous* data field of type `SInt`; it is also an [opaque type](https://github.com/chipsalliance/chisel/blob/v3.6.0/core/src/main/scala/chisel3/experimental/OpaqueType.scala). Most of the arithmetic involving FixedPoints has been delegated to the `SInt` arithmetic of the underlying data field, where shift operations are first used to align the data of FixedPoints that have different binary points. Connect methods have also been  overridden to account for data alignment of FixedPoints with different binary points, and to implement binary point inference.
+FixedPoint is implemented as an extension of `Record`, which has one *anonymous* data field of type `SInt`; it is also an [opaque type](https://github.com/chipsalliance/chisel/blob/v5.1.0/core/src/main/scala/chisel3/experimental/OpaqueType.scala). Most of the arithmetic involving FixedPoints has been delegated to the `SInt` arithmetic of the underlying data field, where shift operations are first used to align the data of FixedPoints that have different binary points. Connect methods have also been  overridden to account for data alignment of FixedPoints with different binary points, and to implement binary point inference.
 
 ## Limitations
 

build.sbt

@@ -12,10 +12,10 @@ scalacOptions ++= Seq(
   "-language:reflectiveCalls",
   "-Ymacro-annotations"
 )
-val chiselVersion = "3.6.0"
-addCompilerPlugin("edu.berkeley.cs" %% "chisel3-plugin" % chiselVersion cross CrossVersion.full)
+val chiselVersion = "5.1.0"
+addCompilerPlugin("org.chipsalliance" %% "chisel-plugin" % chiselVersion cross CrossVersion.full)
 libraryDependencies ++= Seq(
-  "edu.berkeley.cs" %% "chisel3" % chiselVersion,
+  "org.chipsalliance" %% "chisel" % chiselVersion,
   "org.scalatest" %% "scalatest" % "3.2.15" % "test",
   "org.scalatestplus" %% "scalacheck-1-14" % "3.2.2.0" % "test",
 )

src/main/scala/fixedpoint/FixedPoint.scala

@@ -13,7 +13,7 @@
 
 package fixedpoint
 
-import chisel3.{fromDoubleToLiteral => _, fromIntToBinaryPoint => _, _}
+import chisel3._
 import chisel3.experimental.BundleLiterals.AddBundleLiteralConstructor
 import chisel3.experimental.OpaqueType
 import chisel3.internal.firrtl.{KnownWidth, UnknownWidth, Width}
@@ -91,8 +91,7 @@ object FixedPoint extends NumObject {
     data:        Data,
     widthOption: Option[Width] = None
   )(
-    implicit sourceInfo: SourceInfo,
-    compileOptions:      CompileOptions
+    implicit sourceInfo: SourceInfo
   ): FixedPoint = {
     val _new = Wire(
       FixedPoint(
@@ -110,12 +109,7 @@ object FixedPoint extends NumObject {
 
   /** Align all FixedPoints in a (possibly heterogeneous) sequence by width and binary point
     */
-  private[fixedpoint] def dataAligned[T <: Data](
-    in: Iterable[T]
-  )(
-    implicit sourceInfo: SourceInfo,
-    compileOptions:      CompileOptions
-  ): Seq[T] = {
+  private[fixedpoint] def dataAligned[T <: Data](in: Iterable[T])(implicit sourceInfo: SourceInfo): Seq[T] = {
     val bps = in.collect {
       case el: FixedPoint =>
         el.requireKnownBP()
@@ -145,12 +139,8 @@ object FixedPoint extends NumObject {
     out.toSeq
   }
 
-  private[fixedpoint] def dataAligned(
-    in: FixedPoint*
-  )(
-    implicit sourceInfo: SourceInfo,
-    compileOptions:      CompileOptions
-  ): Seq[FixedPoint] = dataAligned(in)
+  private[fixedpoint] def dataAligned(in: FixedPoint*)(implicit sourceInfo: SourceInfo): Seq[FixedPoint] =
+    dataAligned(in)
 
   class ImplicitsCls private[fixedpoint] {
 
@@ -193,13 +183,7 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
   private def requireKnownBP(message: String = "Unknown binary point is not supported in this operation"): Unit =
     if (!binaryPoint.known) throw new ChiselException(message)
 
-  private def additiveOp(
-    that: FixedPoint,
-    f:    (SInt, SInt) => SInt
-  )(
-    implicit sourceInfo: SourceInfo,
-    compileOptions:      CompileOptions
-  ): FixedPoint = {
+  private def additiveOp(that: FixedPoint, f: (SInt, SInt) => SInt)(implicit sourceInfo: SourceInfo): FixedPoint = {
     val Seq(_this, _that) = FixedPoint.dataAligned(this, that).map(WireDefault(_))
     FixedPoint.fromData(binaryPoint.max(that.binaryPoint), f(_this.data, _that.data))
   }
@@ -209,13 +193,7 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
     f(_this.data, _that.data)
   }
 
-  private def connectOp(
-    that: Data,
-    c:    (Data, Data) => Unit
-  )(
-    implicit sourceInfo:   SourceInfo,
-    connectCompileOptions: CompileOptions
-  ): Unit = {
+  private def connectOp(that: Data, c: (Data, Data) => Unit)(implicit sourceInfo: SourceInfo): Unit = {
     that match {
       case that: FixedPoint =>
         if (binaryPoint.known) {
@@ -232,62 +210,49 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
     }
   }
 
-  override def do_+(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    additiveOp(that, _ + _)
+  override def do_+(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint = additiveOp(that, _ + _)
 
-  override def do_-(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    additiveOp(that, _ - _)
+  override def do_-(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint = additiveOp(that, _ - _)
 
-  def do_+%(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    additiveOp(that, _ +% _)
+  def do_+%(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint = additiveOp(that, _ +% _)
 
-  def do_+&(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    additiveOp(that, _ +& _)
+  def do_+&(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint = additiveOp(that, _ +& _)
 
-  def do_-%(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    additiveOp(that, _ -% _)
+  def do_-%(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint = additiveOp(that, _ -% _)
 
-  def do_-&(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    additiveOp(that, _ -& _)
+  def do_-&(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint = additiveOp(that, _ -& _)
 
-  def do_unary_-(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, -data)
+  def do_unary_-(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, -data)
 
-  def do_unary_-%(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data.unary_-%)
+  def do_unary_-%(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data.unary_-%)
 
-  override def do_*(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
+  override def do_*(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint =
     FixedPoint.fromData(binaryPoint + that.binaryPoint, data * that.data)
 
-  override def do_/(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
+  override def do_/(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint =
     throw new ChiselException(s"division is illegal on FixedPoint types")
 
-  override def do_%(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
+  override def do_%(that: FixedPoint)(implicit sourceInfo: SourceInfo): FixedPoint =
     throw new ChiselException(s"mod is illegal on FixedPoint types")
 
-  override def do_<(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ < _)
+  override def do_<(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ < _)
 
-  override def do_<=(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ <= _)
+  override def do_<=(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ <= _)
 
-  override def do_>(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ > _)
+  override def do_>(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ > _)
 
-  override def do_>=(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ >= _)
+  override def do_>=(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ >= _)
 
-  override def do_abs(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data.abs)
+  override def do_abs(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data.abs)
 
-  def do_floor(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint = {
+  def do_floor(implicit sourceInfo: SourceInfo): FixedPoint = {
     requireKnownBP()
     // Set the fractional part to zeroes
     val floored = Cat(data >> binaryPoint.get, 0.U(binaryPoint.get.W.min(width)))
     FixedPoint.fromData(binaryPoint, floored, Some(width))
   }
 
-  def do_ceil(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint = {
+  def do_ceil(implicit sourceInfo: SourceInfo): FixedPoint = {
     requireKnownBP()
     // Get a number with the fractional part set to ones
     val almostOne = ((1 << binaryPoint.get) - 1).S
@@ -296,39 +261,30 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
     FixedPoint.fromData(binaryPoint, ceiled, Some(width))
   }
 
-  def do_round(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint = {
+  def do_round(implicit sourceInfo: SourceInfo): FixedPoint = {
     requireKnownBP()
     // Add 0.5 to the number and then floor it
     val rounded = (this + 0.5.F(1.BP)).floor.setBinaryPoint(binaryPoint.get)
     FixedPoint.fromData(binaryPoint, rounded, Some(width))
   }
 
-  def do_===(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ === _)
+  def do_===(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ === _)
 
-  def do_=/=(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ =/= _)
+  def do_=/=(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ =/= _)
 
-  def do_!=(that: FixedPoint)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): Bool =
-    comparativeOp(that, _ =/= _)
+  def do_!=(that: FixedPoint)(implicit sourceInfo: SourceInfo): Bool = comparativeOp(that, _ =/= _)
 
-  def do_>>(that: Int)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data >> that)
+  def do_>>(that: Int)(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data >> that)
 
-  def do_>>(that: BigInt)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data >> that)
+  def do_>>(that: BigInt)(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data >> that)
 
-  def do_>>(that: UInt)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data >> that)
+  def do_>>(that: UInt)(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data >> that)
 
-  def do_<<(that: Int)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data << that)
+  def do_<<(that: Int)(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data << that)
 
-  def do_<<(that: BigInt)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data << that)
+  def do_<<(that: BigInt)(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data << that)
 
-  def do_<<(that: UInt)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint =
-    FixedPoint.fromData(binaryPoint, data << that)
+  def do_<<(that: UInt)(implicit sourceInfo: SourceInfo): FixedPoint = FixedPoint.fromData(binaryPoint, data << that)
 
   def +%(that: FixedPoint): FixedPoint = macro SourceInfoTransform.thatArg
 
@@ -366,18 +322,11 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
 
   def <<(that: UInt): FixedPoint = macro SourceInfoWhiteboxTransform.thatArg
 
-  override def connect(that: Data)(implicit sourceInfo: SourceInfo, connectCompileOptions: CompileOptions): Unit =
-    connectOp(that, _ := _)
+  override def connect(that: Data)(implicit sourceInfo: SourceInfo): Unit = connectOp(that, _ := _)
 
-  override def bulkConnect(that: Data)(implicit sourceInfo: SourceInfo, connectCompileOptions: CompileOptions): Unit =
-    connectOp(that, _ <> _)
+  override def bulkConnect(that: Data)(implicit sourceInfo: SourceInfo): Unit = connectOp(that, _ <> _)
 
-  override def connectFromBits(
-    that: Bits
-  )(
-    implicit sourceInfo: SourceInfo,
-    compileOptions:      CompileOptions
-  ): Unit = {
+  override def connectFromBits(that: Bits)(implicit sourceInfo: SourceInfo): Unit = {
     this.data := that.asTypeOf(this.data)
   }
 
@@ -397,17 +346,12 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
 
   final def asSInt: SInt = data.asSInt
 
-  def do_asFixedPoint(
-    binaryPoint: BinaryPoint
-  )(
-    implicit sourceInfo: SourceInfo,
-    compileOptions:      CompileOptions
-  ): FixedPoint = {
+  def do_asFixedPoint(binaryPoint: BinaryPoint)(implicit sourceInfo: SourceInfo): FixedPoint = {
     requireKnownBP(s"cannot call $this.asFixedPoint(binaryPoint=$binaryPoint), you must specify a known binaryPoint")
     FixedPoint.fromData(binaryPoint, data, Some(width))
   }
 
-  def do_setBinaryPoint(that: Int)(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): FixedPoint = {
+  def do_setBinaryPoint(that: Int)(implicit sourceInfo: SourceInfo): FixedPoint = {
     requireKnownBP(s"cannot set new binary point if current binary point is unknown")
     val diff = that - binaryPoint.get
     FixedPoint.fromData(
@@ -424,10 +368,6 @@ sealed class FixedPoint private[fixedpoint] (width: Width, private var _inferred
 
   def widthKnown: Boolean = data.widthKnown
 
-  override def typeEquivalent(that: Data): Boolean = {
-    this.getClass == that.getClass
-  }
-
   override def litOption: Option[BigInt] = data.litOption
 
   override def litValue: BigInt = data.litValue

src/main/scala/fixedpoint/ForceElementwiseConnect.scala

@@ -5,20 +5,14 @@
 
 package fixedpoint
 
-import chisel3.{ChiselException, CompileOptions, Data, DontCare, Record}
+import chisel3.{ChiselException, Data, DontCare, Record}
 import chisel3.experimental.SourceInfo
 
 import scala.reflect.ClassTag
 
 trait ForceElementwiseConnect[T <: Record] extends Record {
   implicit val ct: ClassTag[T]
-  private def connectOp(
-    that: Data,
-    c:    (Data, Data) => Unit
-  )(
-    implicit sourceInfo:   SourceInfo,
-    connectCompileOptions: CompileOptions
-  ): Unit =
+  private def connectOp(that: Data, c: (Data, Data) => Unit)(implicit sourceInfo: SourceInfo): Unit =
     that match {
       case that: T =>
         this.elements.zip(that.elements).foreach(x => c(x._1._2, x._2._2))
@@ -28,9 +22,7 @@ trait ForceElementwiseConnect[T <: Record] extends Record {
         throw new ChiselException(s"Cannot connect ${this} and ${that}")
     }
 
-  override def connect(that: Data)(implicit sourceInfo: SourceInfo, connectCompileOptions: CompileOptions): Unit =
-    connectOp(that, _ := _)(sourceInfo, connectCompileOptions)
+  override def connect(that: Data)(implicit sourceInfo: SourceInfo): Unit = connectOp(that, _ := _)(sourceInfo)
 
-  override def bulkConnect(that: Data)(implicit sourceInfo: SourceInfo, connectCompileOptions: CompileOptions): Unit =
-    connectOp(that, _ <> _)(sourceInfo, connectCompileOptions)
+  override def bulkConnect(that: Data)(implicit sourceInfo: SourceInfo): Unit = connectOp(that, _ <> _)(sourceInfo)
 }

src/test/scala/AsTypeOfTester.scala

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 import chisel3.testers.BasicTester
-import chisel3.{fromDoubleToLiteral => _, fromIntToBinaryPoint => _, _}
+import chisel3._
 import fixedpoint._
 
 class AsTypeOfBundleTester extends BasicTester {

src/test/scala/BundleLiteralSpec.scala

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 
-import chisel3.{fromDoubleToLiteral => _, fromIntToBinaryPoint => _, _}
+import chisel3._
 import chisel3.experimental.BundleLiterals._
 import chisel3.testers.BasicTester
 import fixedpoint._

src/test/scala/ChiselSpec.scala

@@ -96,7 +96,7 @@ trait ChiselRunners extends Assertions {
 
   def elaborateAndGetModule[A <: RawModule](t: => A): A = {
     var res: Any = null
-    ChiselStage.elaborate {
+    ChiselStage.convert {
       res = t
       res.asInstanceOf[A]
     }