Bits

abstract def fromInt(x: Int): Bits.this.type

abstract def fromNode(n: Node): Bits.this.type

Factory method to create and assign a leaf-type instance out of a subclass of *Node* instance which we have lost the concrete type.

def !=(b: Bits): Bool

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

def ##[T <: Data](right: T): Bits.this.type

def ##(b: Node): Node

final def ##(): Int

def %(b: Bits): Bits

def &(b: Bits): Bits.this.type

def *(b: Bits): Bits

def +(b: Bits): Bits

def -(b: Bits): Bits

def /(b: Bits): Bits

def :=[T <: Data](src: T): Unit

Assignment operator

def <>(src: Node): Unit

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def ===[T <: Data](right: T): Bool

var CppVertex: CppVertex

def ^(b: Bits): Bits.this.type

def ^^(src: Node): Unit

val _id: Int

def addConsumers(): Unit

def andR(): Bool

final def apply(range: (Int, Int)): UInt

final def apply(hi: UInt, lo: UInt): UInt

final def apply(hi: Int, lo: Int): UInt

Extract a range of bits

final def apply(bit: UInt): Bool

final def apply(bit: Int): Bool

Extract a single Bool at index *bit*.

def apply(name: String): Data

def asDirectionless(): Bits.this.type

def asInput(): Bits.this.type

final def asInstanceOf[T0]: T0

def asOutput(): Bits.this.type

Sets the direction (*dir*) of instances derived from Bits to OUTPUT or recursively sets members of Bundle/Vec to OUTPUT.

final def asTypeFor(node: Node): Bits.this.type

assigns this instance as the data type for *node*.

def assign(src: Node): Unit

def bitSet(off: UInt, dat: UInt): UInt

var canBeUsedAsDefault: Boolean

def canCSE: Boolean

def checkAssign(src: Node): Unit

lazy val chiselName: String

var clock: Clock

def clone(): Bits.this.type

var cntrIdx: Int

var comp: proc

var component: Module

def componentOf: Module

val consumers: ArrayBuffer[Node]

var counter: Bits

def create(dir: IODirection, width: Int): Unit

def dblLitValue: Double

def default: Node

var depth: Int

var dir: IODirection

var driveRand: Boolean

lazy val emitIndex: Int

final def eq(arg0: AnyRef): Boolean

def equals(that: Any): Boolean

def equalsForCSE(x: Node): Boolean

def error(b: Bits): Bits

def extract(b: Bundle): List[Node]

def extract(widths: Array[Int]): List[UInt]

def finalize(): Unit

def flatten: Array[(String, Bits)]

var flattened: Boolean

def flip(): Bits.this.type

def floLitValue: Float

def forceMatchingWidths: Unit

def fromBits(b: Bits): Bits.this.type

var genError: Boolean

def genMuxes(default: Node): Unit

def genMuxes(default: Node, others: Seq[(Bool, Node)]): Unit

final def getClass(): Class[_]

def getLit: Literal

def getNode(): Node

def getWidth(): Int

def hashCode(): Int

def hashCodeForCSE: Int

def infer: Boolean

var inferCount: Int

var inferWidth: (Node) ⇒ Int

def init(n: String, w: Int, ins: Node*): Node

def init(n: String, width: (Node) ⇒ Int, ins: Node*): Node

def initOf(n: String, width: (Node) ⇒ Int, ins: Iterable[Node]): Node

val inputs: ArrayBuffer[Node]

def isByValue: Boolean

var isClkInput: Boolean

def isDirectionless: Boolean

var isFixedWidth: Boolean

def isInObject: Boolean

def isInVCD: Boolean

final def isInstanceOf[T0]: Boolean

def isIo: Boolean

def isIo_=(isIo: Boolean): Unit

def isLit: Boolean

var isPrintArg: Boolean

def isRamWriteInput(i: Node): Boolean

def isReg: Boolean

var isScanArg: Boolean

var isTypeNode: Boolean

def isUsedByRam: Boolean

var isWidthWalked: Boolean

val line: StackTraceElement

def litOf: Literal

def litValue(default: BigInt = BigInt(-1)): BigInt

def matchWidth(w: Int): Node

def maxNum: BigInt

def maybeFlatten: Seq[Node]

def minNum: BigInt

val muxes: HashMap[(Bool, Node), Node]

var name: String

var nameHolder: nameable

def nameIt(path: String, isNamingIo: Boolean): Unit

var named: Boolean

_named_ is used to indicates name was set explicitely and should not be overriden by a _nameIt_ generator.

final def ne(arg0: AnyRef): Boolean

final def newBinaryOp(right: Bits, opName: String): Bits.this.type

final def newLogicalOp(right: Bits, opName: String): Bool

final def newReductionOp(opName: String): Bool

final def newUnaryOp(opName: String): Bits.this.type

final def notify(): Unit

final def notifyAll(): Unit

def orR(): Bool

var pName: String

def printTree(writer: PrintStream, depth: Int = 4, indent: String = ""): Unit

Prints all members of a node and recursively its inputs up to a certain depth level.

def procAssign(src: Node): Unit

var prune: Boolean

def removeTypeNodes(): Unit

var sccIndex: Int

var sccLowlink: Int

def setIsTypeNode: Unit

def setName(n: String): Unit

def setPseudoName(path: String, isNamingIo: Boolean): Unit

def setWidth(w: Int): Unit

var shadow: Bits

final def synchronized[T0](arg0: ⇒ T0): T0

def terminate(): Unit

def toBits(): UInt

def toBool(): Bool

def toNode: Node

def toSInt(): SInt

def toString(): String

def toUInt(): UInt

def traceNode(c: Module, stack: Stack[() ⇒ Any]): Any

def traceableNodes: Array[Node]

def unary_~(): Bits.this.type

val updates: ListBuffer[(Bool, Node)]

def verifyMuxes: Unit

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

var walked: Boolean

def width: Int

var width_: Int

def width_=(w: Int): Unit

Sets the width of a Node.

def xorR(): Bool

def |(b: Bits): Bits.this.type