Add Property expression for integer multiplication.

core/src/main/scala/chisel3/properties/Property.scala

@@ -321,8 +321,15 @@ sealed trait Property[T] extends Element { self =>
     }
   }
 
+  /** Perform addition as defined by FIRRTL spec section Integer Add Operation.
+    */
   final def +(that: Property[T])(implicit ev: PropertyArithmeticOps[Property[T]], sourceInfo: SourceInfo): Property[T] =
     ev.add(this, that)
+
+  /** Perform multiplication as defined by FIRRTL spec section Integer Multiply Operation.
+    */
+  final def *(that: Property[T])(implicit ev: PropertyArithmeticOps[Property[T]], sourceInfo: SourceInfo): Property[T] =
+    ev.mul(this, that)
 }
 
 private[chisel3] sealed trait ClassTypeProvider[A] {
@@ -343,6 +350,7 @@ private[chisel3] object ClassTypeProvider {
 @implicitNotFound("arithmetic operations are not supported on Property type ${T}")
 sealed trait PropertyArithmeticOps[T] {
   def add(lhs: T, rhs: T)(implicit sourceInfo: SourceInfo): T
+  def mul(lhs: T, rhs: T)(implicit sourceInfo: SourceInfo): T
 }
 
 object PropertyArithmeticOps {
@@ -351,18 +359,24 @@ object PropertyArithmeticOps {
     new PropertyArithmeticOps[Property[Int]] {
       def add(lhs: Property[Int], rhs: Property[Int])(implicit sourceInfo: SourceInfo) =
         binOp(sourceInfo, fir.IntegerAddOp, lhs, rhs)
+      def mul(lhs: Property[Int], rhs: Property[Int])(implicit sourceInfo: SourceInfo) =
+        binOp(sourceInfo, fir.IntegerMulOp, lhs, rhs)
     }
 
   implicit val longArithmeticOps: PropertyArithmeticOps[Property[Long]] =
     new PropertyArithmeticOps[Property[Long]] {
       def add(lhs: Property[Long], rhs: Property[Long])(implicit sourceInfo: SourceInfo) =
         binOp(sourceInfo, fir.IntegerAddOp, lhs, rhs)
+      def mul(lhs: Property[Long], rhs: Property[Long])(implicit sourceInfo: SourceInfo) =
+        binOp(sourceInfo, fir.IntegerMulOp, lhs, rhs)
     }
 
   implicit val bigIntArithmeticOps: PropertyArithmeticOps[Property[BigInt]] =
     new PropertyArithmeticOps[Property[BigInt]] {
       def add(lhs: Property[BigInt], rhs: Property[BigInt])(implicit sourceInfo: SourceInfo) =
         binOp(sourceInfo, fir.IntegerAddOp, lhs, rhs)
+      def mul(lhs: Property[BigInt], rhs: Property[BigInt])(implicit sourceInfo: SourceInfo) =
+        binOp(sourceInfo, fir.IntegerMulOp, lhs, rhs)
     }
 
   // Helper function to create Property expression IR.

docs/src/explanations/properties.md

@@ -143,6 +143,7 @@ class IntegerArithmeticExample extends RawModule {
 The following table lists the possible arithmetic operators that are supported
 on integral `Property` typed values.
 
-| Operation | Description                                                |
-| --------- | -----------                                                |
-| `+`       | Perform addition as defined by FIRRTL spec section 25.1.1. |
+| Operation | Description                                                                         |
+| --------- | -----------                                                                         |
+| `+`       | Perform addition as defined by FIRRTL spec section Integer Add Operation            |
+| `*`       | Perform multiplication as defined by FIRRTL spec section Integer Multiply Operation |

firrtl/src/main/scala/firrtl/ir/IR.scala

@@ -263,6 +263,7 @@ sealed abstract class PropPrimOp(name: String) {
   override def toString: String = name
 }
 case object IntegerAddOp extends PropPrimOp("integer_add")
+case object IntegerMulOp extends PropPrimOp("integer_mul")
 
 /** Property expressions.
   *

src/test/scala/chiselTests/properties/PropertySpec.scala

@@ -738,4 +738,19 @@ class PropertySpec extends ChiselFlatSpec with MatchesAndOmits {
       "propassign c, _c_propExpr"
     )()
   }
+
+  it should "support multiplication" in {
+    val chirrtl = ChiselStage.emitCHIRRTL(new RawModule {
+      val a = IO(Input(Property[BigInt]()))
+      val b = IO(Input(Property[BigInt]()))
+      val c = IO(Output(Property[BigInt]()))
+      c := a * b
+    })
+
+    matchesAndOmits(chirrtl)(
+      "wire _c_propExpr : Integer",
+      "propassign _c_propExpr, integer_mul(a, b)",
+      "propassign c, _c_propExpr"
+    )()
+  }
 }