1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
|
// SPDX-License-Identifier: Apache-2.0
package firrtlTests
import org.scalatest._
import firrtl.ir._
import firrtl.{Parser, Utils}
import org.scalatest.flatspec.AnyFlatSpec
import org.scalatest.matchers.should.Matchers
object SerializerSpec {
case class WrapStmt(stmt: Statement) extends Statement {
def serialize: String = s"wrap(${stmt.serialize})"
def foreachExpr(f: Expression => Unit): Unit = stmt.foreachExpr(f)
def foreachInfo(f: Info => Unit): Unit = stmt.foreachInfo(f)
def foreachStmt(f: Statement => Unit): Unit = stmt.foreachStmt(f)
def foreachString(f: String => Unit): Unit = stmt.foreachString(f)
def foreachType(f: Type => Unit): Unit = stmt.foreachType(f)
def mapExpr(f: Expression => Expression): Statement = this.copy(stmt.mapExpr(f))
def mapInfo(f: Info => Info): Statement = this.copy(stmt.mapInfo(f))
def mapStmt(f: Statement => Statement): Statement = this.copy(stmt.mapStmt(f))
def mapString(f: String => String): Statement = this.copy(stmt.mapString(f))
def mapType(f: Type => Type): Statement = this.copy(stmt.mapType(f))
}
case class WrapExpr(expr: Expression) extends Expression {
def serialize: String = s"wrap(${expr.serialize})"
def tpe: Type = expr.tpe
def foreachExpr(f: Expression => Unit): Unit = expr.foreachExpr(f)
def foreachType(f: Type => Unit): Unit = expr.foreachType(f)
def foreachWidth(f: Width => Unit): Unit = expr.foreachWidth(f)
def mapExpr(f: Expression => Expression): Expression = this.copy(expr.mapExpr(f))
def mapType(f: Type => Type): Expression = this.copy(expr.mapType(f))
def mapWidth(f: Width => Width): Expression = this.copy(expr.mapWidth(f))
}
private def tab(s: String): String = {
// Careful to only tab non-empty lines
s.split("\n")
.map { line =>
if (line.nonEmpty) Serializer.Indent + line else line
}
.mkString("\n")
}
val testModule: String =
"""module test :
| input in : UInt<8>
| output out : UInt<8>
|
| inst c of child
| c.in <= in
| out <= c.out""".stripMargin
val testModuleTabbed: String = tab(testModule)
val childModule: String =
"""extmodule child :
| input in : UInt<8>
| output out : UInt<8>
| defname = child""".stripMargin
val childModuleTabbed: String = tab(childModule)
val simpleCircuit: String =
s"FIRRTL version ${Serializer.version.serialize}\ncircuit test :\n" + childModuleTabbed + "\n\n" + testModuleTabbed + "\n"
}
class SerializerSpec extends AnyFlatSpec with Matchers {
import SerializerSpec._
"ir.Serializer" should "support custom Statements" in {
val stmt = WrapStmt(DefWire(NoInfo, "myWire", Utils.BoolType))
val ser = "wrap(wire myWire : UInt<1>)"
Serializer.serialize(stmt) should be(ser)
}
it should "support custom Expression" in {
val expr = WrapExpr(Reference("foo"))
val ser = "wrap(foo)"
Serializer.serialize(expr) should be(ser)
}
it should "support nested custom Statements and Expressions" in {
val expr = SubField(WrapExpr(Reference("foo")), "bar")
val stmt = WrapStmt(DefNode(NoInfo, "n", expr))
val stmts = Block(stmt :: Nil)
val ser = "wrap(node n = wrap(foo).bar)"
Serializer.serialize(stmts) should be(ser)
}
it should "support emitting circuits" in {
val parsed = Parser.parse(simpleCircuit)
val serialized = Serializer.serialize(parsed)
serialized should be(simpleCircuit)
}
it should "support emitting individual modules" in {
val parsed = Parser.parse(simpleCircuit)
val m = parsed.modules.find(_.name == "test").get
val serialized = Serializer.serialize(m)
serialized should be(testModule)
}
it should "support emitting indented individual modules" in {
val parsed = Parser.parse(simpleCircuit)
val m = parsed.modules.find(_.name == "test").get
val serialized = Serializer.serialize(m, 1)
serialized should be(testModuleTabbed)
}
it should "support emitting indented individual extmodules" in {
val parsed = Parser.parse(simpleCircuit)
val m = parsed.modules.find(_.name == "child").get
val serialized = Serializer.serialize(m, 1)
serialized should be(childModuleTabbed)
}
it should "emit whens with empty Blocks correctly" in {
val when = Conditionally(NoInfo, Reference("cond"), Block(Seq()), EmptyStmt)
val serialized = Serializer.serialize(when, 1)
serialized should be(" when cond :\n skip\n")
}
it should "serialize read-under-write behavior for smems correctly" in {
def parseSerializeParse(src: String): Circuit = Parser.parse(Parser.parse(src).serialize)
val undefined = parseSerializeParse(SMemTestCircuit.src(""))
assert(SMemTestCircuit.findRuw(undefined) == ReadUnderWrite.Undefined)
val undefined2 = parseSerializeParse(SMemTestCircuit.src(" undefined"))
assert(SMemTestCircuit.findRuw(undefined2) == ReadUnderWrite.Undefined)
val old = parseSerializeParse(SMemTestCircuit.src(" old"))
assert(SMemTestCircuit.findRuw(old) == ReadUnderWrite.Old)
val readNew = parseSerializeParse(SMemTestCircuit.src(" new"))
assert(SMemTestCircuit.findRuw(readNew) == ReadUnderWrite.New)
}
it should "support lazy serialization" in {
var stmtSerialized = false
case class HackStmt(stmt: Statement) extends Statement {
def serialize: String = {
stmtSerialized = true
stmt.serialize
}
def foreachExpr(f: Expression => Unit): Unit = stmt.foreachExpr(f)
def foreachInfo(f: Info => Unit): Unit = stmt.foreachInfo(f)
def foreachStmt(f: Statement => Unit): Unit = stmt.foreachStmt(f)
def foreachString(f: String => Unit): Unit = stmt.foreachString(f)
def foreachType(f: Type => Unit): Unit = stmt.foreachType(f)
def mapExpr(f: Expression => Expression): Statement = this.copy(stmt.mapExpr(f))
def mapInfo(f: Info => Info): Statement = this.copy(stmt.mapInfo(f))
def mapStmt(f: Statement => Statement): Statement = this.copy(stmt.mapStmt(f))
def mapString(f: String => String): Statement = this.copy(stmt.mapString(f))
def mapType(f: Type => Type): Statement = this.copy(stmt.mapType(f))
}
val stmt = HackStmt(DefNode(NoInfo, "foo", Reference("bar")))
val it: Iterable[String] = Serializer.lazily(stmt)
assert(!stmtSerialized, "We should be able to construct the serializer lazily")
var mapExecuted = false
val it2: Iterable[String] = it.map { x =>
mapExecuted = true
x + ","
}
assert(!stmtSerialized && !mapExecuted, "We should be able to map the serializer lazily")
var appendExecuted = false
val it3: Iterable[String] = it2 ++ Seq("hi").view.map { x =>
appendExecuted = true
x
}
assert(!stmtSerialized && !mapExecuted && !appendExecuted, "We should be able to append to the serializer lazily")
val result = it3.mkString
assert(
stmtSerialized && mapExecuted && appendExecuted,
"Once we traverse the serializer, everything should execute"
)
}
}
|
