blob: d31d86a8e272872fda9350c87e92bdec6bde55e3 (
plain)
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
|
// See LICENSE for license details.
package chiselTests
import chisel3._
import org.scalatest._
import chisel3.testers.BasicTester
import org.scalacheck.Shrink
class UIntOps extends Module {
val io = IO(new Bundle {
val a = Input(UInt(32.W))
val b = Input(UInt(32.W))
val addout = Output(UInt(32.W))
val subout = Output(UInt(32.W))
val addampout = Output(UInt(33.W))
val subampout = Output(UInt(33.W))
val timesout = Output(UInt(32.W))
val divout = Output(UInt(32.W))
val modout = Output(UInt(32.W))
val lshiftout = Output(UInt(32.W))
val rshiftout = Output(UInt(32.W))
val lessout = Output(Bool())
val greatout = Output(Bool())
val eqout = Output(Bool())
val noteqout = Output(Bool())
val lesseqout = Output(Bool())
val greateqout = Output(Bool())
})
val a = io.a
val b = io.b
io.addout := a +% b
io.subout := a -% b
io.addampout := a +& b
io.subampout := a -& b
io.timesout := (a * b)(31, 0)
io.divout := a / Mux(b === 0.U, 1.U, b)
io.modout := a % b
io.lshiftout := (a << b(3, 0))(31, 0)
io.rshiftout := a >> b
io.lessout := a < b
io.greatout := a > b
io.eqout := a === b
io.noteqout := (a =/= b)
io.lesseqout := a <= b
io.greateqout := a >= b
}
// Note a and b need to be "safe"
class UIntOpsTester(a: Long, b: Long) extends BasicTester {
require(a >= 0 && b >= 0)
val dut = Module(new UIntOps)
dut.io.a := a.asUInt(32.W)
dut.io.b := b.asUInt(32.W)
assert(dut.io.addout === (a + b).U(32.W))
assert(dut.io.subout === (a - b).S(32.W).asUInt)
assert(dut.io.addampout === (a + b).U(33.W))
assert(dut.io.subampout === (a - b).S(33.W).asUInt)
assert(dut.io.timesout === (a * b).U(32.W))
assert(dut.io.divout === (a / (b max 1)).U(32.W))
assert(dut.io.modout === (a % (b max 1)).U(32.W))
assert(dut.io.lshiftout === (a << (b % 16)).U(32.W))
assert(dut.io.rshiftout === (a >> b).U(32.W))
assert(dut.io.lessout === (a < b).B)
assert(dut.io.greatout === (a > b).B)
assert(dut.io.eqout === (a == b).B)
assert(dut.io.noteqout === (a != b).B)
assert(dut.io.lesseqout === (a <= b).B)
assert(dut.io.greateqout === (a >= b).B)
stop()
}
class GoodBoolConversion extends Module {
val io = IO(new Bundle {
val u = Input(UInt(1.W))
val b = Output(Bool())
})
io.b := io.u.toBool
}
class BadBoolConversion extends Module {
val io = IO(new Bundle {
val u = Input(UInt(5.W))
val b = Output(Bool())
})
io.b := io.u.toBool
}
class UIntOpsSpec extends ChiselPropSpec with Matchers {
// Disable shrinking on error.
implicit val noShrinkListVal = Shrink[List[Int]](_ => Stream.empty)
implicit val noShrinkInt = Shrink[Int](_ => Stream.empty)
property("Bools can be created from 1 bit UInts") {
elaborate(new GoodBoolConversion)
}
property("Bools cannot be created from >1 bit UInts") {
a [Exception] should be thrownBy { elaborate(new BadBoolConversion) }
}
property("UIntOps should elaborate") {
elaborate { new UIntOps }
}
property("UIntOpsTester should return the correct result") {
assertTesterPasses { new UIntOpsTester(123, 7) }
}
}
|
