CounterWrapperBackend

abstract val keywords: HashSet[String]

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

def addPin(m: Module, pin: Data, name: String): Unit

def addReg(m: Module, outType: Bits, name: String = "", updates: Map[Bool, Node] = Map()): Unit

val analyses: ArrayBuffer[(Module) ⇒ Unit]

final def asInstanceOf[T0]: T0

def asValidName(name: String): String

def assignClockAndResetToModules: Unit

def backannotationAnalyses: Unit

def backannotationTransforms: Unit

def checkPorts(topC: Module): Unit

def clone(): AnyRef

def collectNodesIntoComp(dfsStack: Stack[Node]): Unit

def compile(c: Module, flags: String = null): Unit

def connectConsumers(input: Node, via: Node): Unit

def connectDaisyPins(c: Module): Unit

def connectResets: Unit

val counterCopy: HashMap[Module, Bool]

var counterIdx: Int

val counterRead: HashMap[Module, Bool]

def createClkDomain(root: Node, walked: ArrayBuffer[Node]): Unit

def createOutputFile(name: String): FileWriter

val daisyCtrls: HashMap[Module, Bits]

val daisyIns: HashMap[Module, UInt]

val daisyOuts: HashMap[Module, DecoupledIO[UInt]]

def decoupleTarget(c: Module): Unit

val decoupledPins: HashMap[Node, Bits]

def depthString(depth: Int): String

def elaborate(c: Module): Unit

def emitCounterIdx: Int

def emitDec(node: Node): String

def emitDef(node: Node): String

def emitRef(c: Module): String

def emitRef(node: Node): String

def emitTmp(node: Node): String

def ensureDir(dir: String): String

Ensures a directory *dir* exists on the filesystem.

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def execute(c: Module, walks: ArrayBuffer[(Module) ⇒ Unit]): Unit

def extractClassName(comp: Module): String

def finalize(): Unit

val firedPins: HashMap[Module, Bool]

def fullyQualifiedName(m: Node): String

def gatherChildren(root: Module): ArrayBuffer[Module]

def gatherClocksAndResets: Unit

def genIndent(x: Int): String

def generateCounters(c: Module): Unit

def generateDaisyChains(c: Module): Unit

final def getClass(): Class[_]

def getPseudoPath(c: Module, delim: String = "/"): String

def getSignalPathName(n: Node, delim: String = "/", isRealName: Boolean = false): String

def hashCode(): Int

def initBackannotation: Unit

def initializeDFS: Stack[Node]

def isBitsIo(node: Node, dir: IODirection): Boolean

Nodes which are created outside the execution trace from the toplevel component constructor (i.

final def isInstanceOf[T0]: Boolean

def levelChildren(root: Module): Unit

def nameAll(root: Module): Unit

def nameChildren(root: Module): Unit

def nameRsts: Unit

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

val preElaborateTransforms: ArrayBuffer[(Module) ⇒ Unit]

def printStack: Unit

Prints the call stack of Component as seen by the push/pop runtime.

def pruneNodes: Unit

def pruneUnconnectedIOs(m: Module): Unit

def setPseudoNames(c: Module): Unit

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

def toString(): String

val transforms: ArrayBuffer[(Module) ⇒ Unit]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def wirePin(pin: Data, input: Node): Unit

def writeOutGraph(c: Module): Unit