Utils

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

val BoolType: UIntType

final def asInstanceOf[T0]: T0

def ceilLog2(x: BigInt): Int

def clone(): AnyRef

def create_exps(e: Expression): Seq[Expression]

def create_exps(n: String, t: Type): Seq[Expression]

def diff(e1: Expression, e2: Expression): Seq[(Expression, Expression)]

Walks two expression trees and returns a sequence of tuples of where they differ

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(str: String, cause: Throwable = null): Nothing

def expandPrefixes(name: String, prefixDelim: String = "_"): Seq[String]

Expand a name into its prefixes, e.g., 'foo_barbaz' becomes 'Seq[foo_, foo_bar, foo_barbaz]'. This can be used to produce better names when generating prefix unique names.

def expandRef(e: Expression): Seq[Expression]

Like create_exps, but returns intermediate Expressions as well

def field_flip(v: Type, s: String): Orientation

def field_type(v: Type, s: String): Type

def flow(e: Expression): Flow

final def getClass(): Class[_]

def getDeclaration(m: Module, expr: Expression): IsDeclaration

Gets the root declaration of an expression

def getKids(e: Expression): Seq[Expression]

Returns children Expressions of e

def getThrowable(maybeException: Option[Throwable], first: Boolean): Throwable

Unwind the causal chain until we hit the initial exception (which may be the first).

def get_field(v: Type, s: String): Field

def get_flow(p: Port): Flow

def get_flow(s: Statement): Flow

def get_info(s: Statement): Info

def get_point(e: Expression): Int

def get_size(t: Type): Int

def get_valid_points(t1: Type, t2: Type, flip1: Orientation, flip2: Orientation): Seq[(Int, Int)]

def hasFlip(t: Type): Boolean

Returns true if t, or any subtype, contains a flipped field

def hashCode(): Int

def indent(str: String): String

Indent the results of ir.FirrtlNode.serialize

def inline(nodeMap: NodeMap, stop: (String) ⇒ Boolean = x: String => false)(e: Expression): Expression

Returns an inlined expression (replacing node references with values), stopping on a stopping condition or until the reference is not a node

def isBitExtract(expr: Expression): Boolean

Returns true if Expression is a Bits PrimOp, false otherwise

def isBitExtract(op: PrimOp): Boolean

Returns true if PrimOp is a BitExtraction, false otherwise

def isCast(expr: Expression): Boolean

Returns true if Expression is a casting PrimOp, false otherwise

def isCast(op: PrimOp): Boolean

Returns true if PrimOp is a cast, false otherwise

final def isInstanceOf[T0]: Boolean

def isTemp(str: String): Boolean

def kind(e: Expression): Kind

val logger: Logger

def max(a: BigInt, b: BigInt): BigInt

def mergeRef(root: Expression, body: Expression): Expression

Adds a root reference to some SubField/SubIndex chain

def min(a: BigInt, b: BigInt): BigInt

def module_type(m: DefModule): BundleType

def mux_type(t1: Type, t2: Type): Type

def mux_type(e1: Expression, e2: Expression): Type

def mux_type_and_widths(t1: Type, t2: Type): Type

def mux_type_and_widths(e1: Expression, e2: Expression): Type

final def ne(arg0: AnyRef): Boolean

def niceName(depth: Int)(e: Expression): String

def niceName(e: Expression): String

Provide a nice name to create a temporary *

final def notify(): Unit

final def notifyAll(): Unit

val one: UIntLiteral

def pow_minus_one(a: BigInt, b: BigInt): BigInt

def splitRef(e: Expression): (WRef, Expression)

Splits an Expression into root Ref and tail

def squashEmpty(s: Statement): Statement

Removes all firrtl.ir.EmptyStmt statements and condenses firrtl.ir.Block statements.

def sub_type(v: Type): Type

def swap(f: Orientation): Orientation

def swap(d: Direction): Direction

def swap(g: Flow): Flow

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

def throwInternalError(message: String = "", exception: Option[Exception] = None): Nothing

Throw an internal error, possibly due to an exception.

def time[R](block: ⇒ R): (Double, R)

def times(f1: Orientation, f2: Orientation): Orientation

def times(flip: Orientation, g: Flow): Flow

def times(g: Flow, flip: Orientation): Flow

def times(d: Direction, g: Flow): Direction

def times(g: Flow, d: Direction): Direction

def times(d: Direction, flip: Orientation): Direction

def toString(): String

def toTarget(main: String, module: String)(expression: Expression): ReferenceTarget

implicit def toWrappedExpression(x: Expression): WrappedExpression

def to_dir(g: Flow): Direction

def to_flip(g: Flow): Orientation

def to_flip(d: Direction): Orientation

def to_flow(d: Direction): Flow

val v_keywords: Set[String]

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

final def wait(arg0: Long): Unit

final def wait(): Unit

val zero: UIntLiteral

def finalize(): Unit

def gender(e: Expression): Gender

def get_flip(t: Type, i: Int, f: Orientation): Orientation

def get_gender(p: Port): Gender

def get_gender(s: Statement): Gender

def to_gender(d: Direction): Gender