package probe
- Source
- package.scala
- Grouped
- Alphabetic
- By Inheritance
- probe
- SourceInfoDoc
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- def define[T <: Data](sink: T, probeExpr: T)(implicit sourceInfo: SourceInfo): Unit
Initialize a probe with a provided probe value.
Initialize a probe with a provided probe value.
- sink
probe to initialize
- probeExpr
value to initialize the sink to
- def do_read[T <: Data](source: T)(implicit sourceInfo: SourceInfo): T
- def force(probe: Data, value: Data)(implicit sourceInfo: SourceInfo): Unit
Override existing driver of a writable probe.
- def forceInitial(probe: Data, value: Data)(implicit sourceInfo: SourceInfo): Unit
Override existing driver of a writable probe on initialization.
Override existing driver of a writable probe on initialization.
- probe
writable Probe to force
- value
to force onto the probe
- macro def read[T <: Data](source: T): T
Access the value of a probe.
Access the value of a probe.
- source
probe whose value is getting accessed
- def release(probe: Data)(implicit sourceInfo: SourceInfo): Unit
Release driver on a probe.
- def releaseInitial(probe: Data)(implicit sourceInfo: SourceInfo): Unit
Release initial driver on a probe.
Release initial driver on a probe.
- probe
writable Probe to release
- object Probe extends ProbeBase with SourceInfoDoc
- object ProbeValue extends ProbeValueBase with SourceInfoDoc
- object RWProbe extends ProbeBase with SourceInfoDoc
- object RWProbeValue extends ProbeValueBase with SourceInfoDoc
Ungrouped
SourceInfoTransformMacro
These internal methods are not part of the public-facing API!
The equivalent public-facing methods do not have the do_
prefix or have the same name. Use and look at the
documentation for those. If you want left shift, use <<
, not do_<<
. If you want conversion to a
Seq of Bools look at the asBools
above, not the one below. Users can safely ignore
every method in this group!
🐉🐉🐉 Here be dragons... 🐉🐉🐉
These do_X
methods are used to enable both implicit passing of SourceInfo
while also supporting chained apply methods. In effect all "normal" methods that you, as a user, will use in your
designs, are converted to their "hidden", do_*
, via macro transformations. Without using macros here, only one
of the above wanted behaviors is allowed (implicit passing and chained applies)---the compiler interprets a
chained apply as an explicit 'implicit' argument and will throw type errors.
The "normal", public-facing methods then take no SourceInfo. However, a macro transforms this public-facing method
into a call to an internal, hidden do_*
that takes an explicit SourceInfo by inserting an
implicitly[SourceInfo]
as the explicit argument.