Generated with

chisel3.experimental

Package for experimental features, which may have their API changed, be removed, etc.

Because its contents won't necessarily have the same level of stability and support as non-experimental, you must explicitly import this package to use its contents.

Attributes

Members list

Packages

Implicit conversions from some Scala standard library types and Data

Attributes

Note: As this leans heavily on the experimental DataView feature, these APIs are experimental and subject to change

Type members

Classlikes

If mixed in with a user-defined type, Chisel will attempt to name instances of the type

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any

Generate prefixes from values of this type in the Chisel compiler plugin

Users can mixin this trait to tell the Chisel compiler plugin to include the names of vals of this type when generating prefixes for naming Data and Mem instances. This is generally useful whenever creating a class that contains Data, Mem, or Module instances but does not itself extend Data or Module.

Attributes

See also

See the compiler plugin documentation for more information on this process.

Example

import chisel3._
import chisel3.experimental.AffectsChiselPrefix
class MyModule extends Module {
 // Note: This contains a Data but is not a named component itself
 class NotAData extends AffectsChiselPrefix {
   val value = Wire(Bool())
 }
 // Name with AffectsChiselPrefix:    "nonData_value"
 // Name without AffectsChiselPrefix: "value"
 val nonData = new NotAData
 // Name with AffectsChiselPrefix:    "nonData2_value"
 // Name without AffectsChiselPrefix: "value_1"
 val nonData2 = new NotAData
}

Source

package.scala

Supertypes

class Object

trait Matchable

class Any

Known subtypes

class Counter

Data type for representing bidirectional bitvectors of a given width

Analog support is limited to allowing wiring up of Verilog BlackBoxes with bidirectional (inout) pins. There is currently no support for reading or writing of Analog types within Chisel code.

Given that Analog is bidirectional, it is illegal to assign a direction to any Analog type. It is legal to "flip" the direction (since Analog can be a member of aggregate types) which has no effect.

Analog types are generally connected using the bidirectional attach mechanism, but also support limited bulkconnect <>. Analog types are only allowed to be bulk connected once in a given module. This is to prevent any surprising consequences of last connect semantics.

Attributes

Note: This API is experimental and subject to change
Companion: object
Source: Analog.scala
Supertypes: class Element

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Object that provides factory methods for Analog objects

Attributes

Note: This API is experimental and subject to change
Companion: class
Source: Analog.scala
Supertypes: class Object

trait Matchable

class Any
Self type: Analog.type

Existential Type class for types that can be converted to a Target

This is useful for containers of Targetables.

Attributes

Companion: object
Source: Targetable.scala
Supertypes: class Object

trait Matchable

class Any

Attributes

Companion: trait
Source: Targetable.scala
Supertypes: class Object

trait Matchable

class Any
Self type: AnyTargetable.type

Attributes

Companion: class
Source: Module.scala
Supertypes: class Object

trait Matchable

class Any
Self type: BaseModule.type

Abstract base class for Modules, an instantiable organizational unit for RTL.

Attributes

Companion: object
Source: Module.scala
Supertypes: trait Selectable

trait Selectable

trait IsInstantiable

trait InstanceId

class Object

trait Matchable

class Any
Show all
Known subtypes: class Class

trait FixedIOBaseModule[A]

class FixedIOExtModule[A]

class AutoBlackBox

class FixedIOModule[A]

class FixedIORawModule[A]

class CIRCTSRAM[T]

class SimulationTestHarness

class TestHarness[M]

class RawModule

class AllUnitTests

class Module

class PRNG

class FibonacciLFSR

class MaxPeriodFibonacciLFSR

class GaloisLFSR

class MaxPeriodGaloisLFSR

trait LFSR

class Arbiter[T]

class LockingArbiterLike[T]

class LockingArbiter[T]

class LockingRRArbiter[T]

class RRArbiter[T]

class Pipe[T]

class Queue[T]

trait RequireAsyncReset

trait RequireSyncReset
Show all

Attributes

Source: Aggregate.scala
Supertypes: class ChiselException

class Exception

class Throwable

trait Serializable

class Object

trait Matchable

class Any
Show all

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: BundleLiterals.type

Attributes

Source: ChiselSubtypeOf.scala
Supertypes: class Object

trait Matchable

class Any

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: CloneModuleAsRecord.type

For when source info isn't generated because the function is deprecated and we're lazy.

Attributes

Source: SourceInfo.scala
Supertypes: trait Singleton

trait Product

trait Mirror

trait Serializable

trait Product

trait Equals

trait NoSourceInfo

trait SourceInfo

class Object

trait Matchable

class Any
Show all
Self type: DeprecatedSourceInfo.type

Data equivalent of Scala's scala.Tuple9

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple9 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple2

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple2 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple3

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple3 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple4

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple4 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple5

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple5 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple6

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple6 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple7

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple7 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple8

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple8 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Data equivalent of Scala's scala.Tuple9

Users may not instantiate this class directly. Instead they should use the implicit conversion from Tuple9 in chisel3.experimental.conversions

Attributes

Source: package.scala
Supertypes: class Bundle

class Record

trait Selectable

trait Aggregate

class Data

trait InstanceId

class Object

trait Matchable

class Any
Show all

Trait for Records that signals the compiler plugin to generate a typeName for the inheriting Record based on the parameter values provided to its constructor.

Attributes

Example

Consider a Bundle which manually implements typeName:

class MyBundle(param1: Int, param2: Int)(gen: Data) extends Bundle {
 val foo = UInt(param1.W)
 val bar = UInt(param2.W)
 val data = gen
 override def typeName = s"MyBundle_${param1}_${param2}_${gen.typeName}"
}
(new MyBundle(3, 4)(SInt(3.W))).typeName // "MyBundle_3_4_SInt3"
(new MyBundle(1, 32)(Bool())).typeName   // "MyBundle_1_32_Bool"

An identical typeName implementation can be generated and provided with HasAutoTypename, making the manual implementation unnecessary:

class MyBundle(param1: Int, param2: Int)(gen: Data) extends Bundle with HasAutoTypename {
 val foo = UInt(param1.W)
 val bar = UInt(param2.W)
 val data = gen
}
(new MyBundle(3, 4)(SInt(3.W))).typeName // "MyBundle_3_4_SInt3"
(new MyBundle(1, 32)(Bool())).typeName   // "MyBundle_1_32_Bool"

Source

HasAutoTypename.scala

Supertypes

class Object

trait Matchable

class Any

Self type

Record

Attributes

Source: HasTypeAlias.scala
Supertypes: class Object

trait Matchable

class Any
Self type: Record

Attributes

Source: HierarchyMarker.scala
Supertypes: class Object

trait Matchable

class Any

Attributes

Source: SourceInfo.scala
Supertypes: trait SourceInfo

class Object

trait Matchable

class Any
Known subtypes: object DeprecatedSourceInfo

object UnlocatableSourceInfo

Indicates if this Record represents an "Opaque Type"

Opaque types provide a mechanism for user-defined types that do not impose any "boxing" overhead in the emitted FIRRTL and Verilog. You can think about an opaque type Record as a box around a single element that only exists at Chisel elaboration time. Put another way, if this trait is mixed into a Record, the Record may only contain a single element with an empty name and there will be no _ in the name for that element in the emitted Verilog.

Attributes

See also: OpaqueTypeSpec in Chisel's tests for example usage and expected output
Source: OpaqueType.scala
Supertypes: class Data

trait InstanceId

class Object

trait Matchable

class Any
Self type: Record

Wrapper object for a Record alias name. Primarily intended to provide an invocation point for source line locators, but also contains pertinent information to generating FIRRTL alias statements.

Value parameters

id: The desired name to generate an alias statement
strippedSuffix: In the case of forced coersion by Input or Output, the string to append to the end of the alias name. Takes the default value of "_stripped"

Attributes

Companion: object
Source: HasTypeAlias.scala
Supertypes: trait Serializable

trait Product

trait Equals

class Object

trait Matchable

class Any
Show all

Attributes

Companion: class
Source: HasTypeAlias.scala
Supertypes: trait Product

trait Mirror

class Object

trait Matchable

class Any
Self type: RecordAlias.type

Abstract base class for generalized source information.

Attributes

Companion: object
Source: SourceInfo.scala
Supertypes: class Object

trait Matchable

class Any
Known subtypes: trait NoSourceInfo

object DeprecatedSourceInfo

object UnlocatableSourceInfo

class SourceLine

Attributes

Companion: trait
Source: SourceInfo.scala
Supertypes: trait Sum

trait Mirror

class Object

trait Matchable

class Any
Self type: SourceInfo.type

For FIRRTL lines from a Scala source line.

Attributes

Note: A column == 0 indicates no column
Source: SourceInfo.scala
Supertypes: trait Serializable

trait Product

trait Equals

trait SourceInfo

class Object

trait Matchable

class Any
Show all

Type class for types that can be converted to a Target

See AnyTargetable for type-erased containers of Targetables

Attributes

Note: This uses type classes instead of inheritance because Hierarchy does not constrain its type parameter and thus not all instances of Hierarchy are Targetable.
Companion: object
Source: Targetable.scala
Supertypes: class Object

trait Matchable

class Any

Attributes

Companion: trait
Source: Targetable.scala
Supertypes: class Object

trait Matchable

class Any
Self type: Targetable.type

The util that records the reference map from original Data/Module annotated in Chisel and final FIRRTL.

Attributes

Example

 class Dut extends Module {
   val a = WireDefault(Bool())
   Trace.traceName(a)
 }
 val annos = (new ChiselStage).execute(Seq(ChiselGeneratorAnnotation(() => new Dut)))
 val dut = annos.collectFirst { case DesignAnnotation(dut) => dut }.get.asInstanceOf[CollideModule]
 // get final reference of `a` Seq(ReferenceTarget("Dut", "Dut", Seq.empty, "a", Seq.empty))
 val firrtlReferenceOfDutA = finalTarget(annos)(dut.a)

Source

Trace.scala

Supertypes

class Object

trait Matchable

class Any

Self type

Trace.type

For when source info can't be generated because of a technical limitation, like for Reg because Scala macros don't support named or default arguments.

Attributes

Source: SourceInfo.scala
Supertypes: trait Singleton

trait Product

trait Mirror

trait Serializable

trait Product

trait Equals

trait NoSourceInfo

trait SourceInfo

class Object

trait Matchable

class Any
Show all
Self type: UnlocatableSourceInfo.type

Attributes

Source: Aggregate.scala
Supertypes: class ChiselException

class Exception

class Throwable

trait Serializable

class Object

trait Matchable

class Any
Show all

This class provides the Lit method needed to define a Vec literal

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: VecLiterals.type

Attributes

Source: Annotation.scala
Supertypes: class Object

trait Matchable

class Any
Self type: annotate.type

Attributes

Source: Attach.scala
Supertypes: class Object

trait Matchable

class Any
Self type: attach.type

Attributes

Source: Annotation.scala
Supertypes: class Object

trait Matchable

class Any
Self type: dedupGroup.type

Marks that a module to be ignored in Dedup Transform in Firrtl pass

Attributes

Example

def fullAdder(a: UInt, b: UInt, myName: String): UInt = {
  val m = Module(new Module {
    val io = IO(new Bundle {
      val a = Input(UInt(32.W))
      val b = Input(UInt(32.W))
      val out = Output(UInt(32.W))
    })
    override def desiredName = "adder_" + myNname
    io.out := io.a + io.b
  })
  doNotDedup(m)
  m.io.a := a
  m.io.b := b
  m.io.out
}
class AdderTester extends Module
with ConstantPropagationTest {
val io = IO(new Bundle {
  val a = Input(UInt(32.W))
  val b = Input(UInt(32.W))
  val out = Output(Vec(2, UInt(32.W)))
})
io.out(0) := fullAdder(io.a, io.b, "mod1")
io.out(1) := fullAdder(io.a, io.b, "mod2")
}

Source

Annotation.scala

Supertypes

class Object

trait Matchable

class Any

Self type

doNotDedup.type

Use to leave a comment in the generated FIRRTL.

These can be useful for debugging complex generators. Note that these are comments and thus are ignored by the FIRRTL compiler.

Attributes

Example

firrtlComment("This is a comment")
val w = Wire(Bool())
firrtlComment("This is another comment")

Source

FirrtlComment.scala

Supertypes

class Object

trait Matchable

class Any

Self type

firrtlComment.type

Attributes

Source: Annotation.scala
Supertypes: class Object

trait Matchable

class Any
Self type: flattenInstance.type

Attributes

Source: Annotation.scala
Supertypes: class Object

trait Matchable

class Any
Self type: flattenInstanceAllowDedup.type

Attributes

Source: Annotation.scala
Supertypes: class Object

trait Matchable

class Any
Self type: inlineInstance.type

Attributes

Source: Annotation.scala
Supertypes: class Object

trait Matchable

class Any
Self type: inlineInstanceAllowDedup.type

Use to eliminate any existing prefixes within the provided scope.

Attributes

Example

val x1 = noPrefix {
 // Anything generated here will not be prefixed by anything outside this scope
}

Source

prefix.scala

Supertypes

class Object

trait Matchable

class Any

Self type

noPrefix.type

Use to add a prefix to any components generated in the provided scope.

Attributes

Example

val x1 = prefix("first") {
 // Anything generated here will be prefixed with "first"
}
val x2 = prefix(mysignal) {
 // Anything generated here will be prefixed with the name of mysignal
}

Source

prefix.scala

Supertypes

class Object

trait Matchable

class Any

Self type

prefix.type

Require that a Data can be annotated. It must be non-literal hardware.

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: requireIsAnnotatable.type

Requires that a node is a chisel type (not hardware, "unbound")

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: requireIsChiselType.type

Requires that a node is hardware ("bound")

Attributes

Source: package.scala
Supertypes: class Object

trait Matchable

class Any
Self type: requireIsHardware.type

Attributes

Source: prefix.scala
Supertypes: class Object

trait Matchable

class Any
Self type: skipPrefix.type

Deprecated classlikes

Attributes

Deprecated: [Since version since] deprecatedCaseClass
Source: ExtModule.scala
Supertypes: trait Serializable

trait Product

trait Equals

class Param

class Object

trait Matchable

class Any
Show all

Defines a black box, which is a module that can be referenced from within Chisel, but is not defined in the emitted Verilog. Useful for connecting to RTL modules defined outside Chisel.

A variant of BlackBox, this has a more consistent naming scheme in allowing multiple top-level IO and does not drop the top prefix.

Attributes

Note

The parameters API is experimental and may change

Example

Some design require a differential input clock to clock the all design. With the xilinx FPGA for example, a Verilog template named IBUFDS must be integrated to use differential input:

IBUFDS #(.DIFF_TERM("TRUE"),
         .IOSTANDARD("DEFAULT")) ibufds (
 .IB(ibufds_IB),
 .I(ibufds_I),
 .O(ibufds_O)
);

To instantiate it, a BlackBox can be used like following:

import chisel3._
// Example with Xilinx differential buffer IBUFDS
class IBUFDS extends ExtModule(Map("DIFF_TERM" -> "TRUE", // Verilog parameters
                                  "IOSTANDARD" -> "DEFAULT"
                    )) {
 val O = IO(Output(Clock()))
 val I = IO(Input(Clock()))
 val IB = IO(Input(Clock()))
}

Deprecated

[Since version since] this has moved from `chisel3.experimental` to `chisel3`

Source

ExtModule.scala

Supertypes

class BaseModule

trait Selectable

trait IsInstantiable

trait InstanceId

class Object

trait Matchable

class Any

Show all

Known subtypes

class FixedIOExtModule[A]

class AutoBlackBox

Attributes

Deprecated: [Since version since] deprecatedCaseClass
Source: ExtModule.scala
Supertypes: trait Serializable

trait Product

trait Equals

class Param

class Object

trait Matchable

class Any
Show all

Attributes

Deprecated: [Since version Chisel 7.0.0] use Intrinsic and IntrinsicExpr instead, intrinsic modules are deprecated
Source: IntrinsicModule.scala
Supertypes: class BaseModule

trait Selectable

trait Selectable

trait IsInstantiable

trait InstanceId

class Object

trait Matchable

class Any
Show all

Parameters for BlackBoxes

Attributes

Deprecated: [Since version since] deprecatedCaseClass
Source: ExtModule.scala
Supertypes: class Object

trait Matchable

class Any
Known subtypes: class DoubleParam

class IntParam

class PrintableParam

class RawParam

class StringParam

Creates a parameter from the Printable's resulting format String

Attributes

Deprecated: [Since version since] deprecatedCaseClass
Source: ExtModule.scala
Supertypes: trait Serializable

trait Product

trait Equals

class Param

class Object

trait Matchable

class Any
Show all

Unquoted String

Attributes

Deprecated: [Since version since] deprecatedCaseClass
Source: ExtModule.scala
Supertypes: trait Serializable

trait Product

trait Equals

class Param

class Object

trait Matchable

class Any
Show all

Attributes

Deprecated: [Since version since] deprecatedCaseClass
Source: ExtModule.scala
Supertypes: trait Serializable

trait Product

trait Equals

class Param

class Object

trait Matchable

class Any
Show all