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
|
// See LICENSE for license details.
package chisel3.core
import scala.language.experimental.macros
import chisel3.internal.sourceinfo._
private[chisel3] object SeqUtils {
/** Concatenates the data elements of the input sequence, in sequence order, together.
* The first element of the sequence forms the least significant bits, while the last element
* in the sequence forms the most significant bits.
*
* Equivalent to r(n-1) ## ... ## r(1) ## r(0).
*/
def asUInt[T <: Bits](in: Seq[T]): UInt = macro SourceInfoTransform.inArg
def do_asUInt[T <: Bits](in: Seq[T])(implicit sourceInfo: SourceInfo): UInt = {
if (in.tail.isEmpty) {
in.head.asUInt
} else {
val left = asUInt(in.slice(0, in.length/2))
val right = asUInt(in.slice(in.length/2, in.length))
right ## left
}
}
/** Outputs the number of elements that === true.B.
*/
def count(in: Seq[Bool]): UInt = macro SourceInfoTransform.inArg
def do_count(in: Seq[Bool])(implicit sourceInfo: SourceInfo): UInt = in.size match {
case 0 => 0.U
case 1 => in.head
case n => count(in take n/2) +& count(in drop n/2)
}
/** Returns the data value corresponding to the first true predicate.
*/
def priorityMux[T <: Data](in: Seq[(Bool, T)]): T = macro CompileOptionsTransform.inArg
def do_priorityMux[T <: Data](in: Seq[(Bool, T)])(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T = {
if (in.size == 1) {
in.head._2
} else {
Mux(in.head._1, in.head._2, priorityMux(in.tail))
}
}
/** Returns the data value corresponding to the lone true predicate.
*
* @note assumes exactly one true predicate, results undefined otherwise
*/
def oneHotMux[T <: Data](in: Iterable[(Bool, T)]): T = macro CompileOptionsTransform.inArg
def do_oneHotMux[T <: Data](in: Iterable[(Bool, T)])(implicit sourceInfo: SourceInfo, compileOptions: CompileOptions): T = {
if (in.tail.isEmpty) {
in.head._2
} else {
val masked = for ((s, i) <- in) yield Mux(s, i.asUInt, 0.U)
val output = cloneSupertype(in.toSeq map {_._2}, "oneHotMux")
output.fromBits(masked.reduceLeft(_|_))
}
}
}
|
