Type Members

1.  case class ArrayConstant(e: BVExpr, indexWidth: Int) extends ArrayExpr with Product with Serializable
2.  case class ArrayEqual(a: ArrayExpr, b: ArrayExpr) extends BVExpr with Product with Serializable
3.  sealed trait ArrayExpr extends SMTExpr
4.  case class ArrayFunctionCall(name: String, args: List[SMTFunctionArg], indexWidth: Int, dataWidth: Int) extends ArrayExpr with Product with Serializable

   apply arguments to a function which returns a result of array type

5.  case class ArrayIte(cond: BVExpr, tru: ArrayExpr, fals: ArrayExpr) extends ArrayExpr with Product with Serializable
6.  case class ArrayRead(array: ArrayExpr, index: BVExpr) extends BVExpr with Product with Serializable
7.  case class ArrayStore(array: ArrayExpr, index: BVExpr, data: BVExpr) extends ArrayExpr with Product with Serializable
8.  case class ArraySymbol(name: String, indexWidth: Int, dataWidth: Int) extends ArrayExpr with SMTSymbol with Product with Serializable
9.  case class ArrayType(indexWidth: Int, dataWidth: Int) extends SMTType with Product with Serializable
10.  case class BVAnd(terms: List[BVExpr]) extends BVExpr with Product with Serializable
11.  sealed trait BVBinaryExpr extends BVExpr
12.  case class BVComparison(op: Compare.Value, a: BVExpr, b: BVExpr, signed: Boolean) extends BVBinaryExpr with Product with Serializable
13.  case class BVConcat(a: BVExpr, b: BVExpr) extends BVBinaryExpr with Product with Serializable
14.  case class BVEqual(a: BVExpr, b: BVExpr) extends BVBinaryExpr with Product with Serializable
15.  sealed trait BVExpr extends SMTExpr

    a SMT bit vector expression: https://smtlib.cs.uiowa.edu/theories-FixedSizeBitVectors.shtml

16.  case class BVExtend(e: BVExpr, by: Int, signed: Boolean) extends BVUnaryExpr with Product with Serializable
17.  case class BVForall(variable: BVSymbol, e: BVExpr) extends BVUnaryExpr with Product with Serializable
18.  case class BVFunctionCall(name: String, args: List[SMTFunctionArg], width: Int) extends BVExpr with Product with Serializable

    apply arguments to a function which returns a result of bit vector type

19.  class BVImplies extends BVBinaryExpr
20.  case class BVIte(cond: BVExpr, tru: BVExpr, fals: BVExpr) extends BVExpr with Product with Serializable
21.  case class BVLiteral(value: BigInt, width: Int) extends BVExpr with SMTNullaryExpr with Product with Serializable
22.  case class BVNegate(e: BVExpr) extends BVUnaryExpr with Product with Serializable
23.  case class BVNot(e: BVExpr) extends BVUnaryExpr with Product with Serializable
24.  case class BVOp(op: Op.Value, a: BVExpr, b: BVExpr) extends BVBinaryExpr with Product with Serializable
25.  case class BVOr(terms: List[BVExpr]) extends BVExpr with Product with Serializable
26.  case class BVReduceAnd(e: BVExpr) extends BVUnaryExpr with Product with Serializable
27.  case class BVReduceOr(e: BVExpr) extends BVUnaryExpr with Product with Serializable
28.  case class BVReduceXor(e: BVExpr) extends BVUnaryExpr with Product with Serializable
29.  case class BVSlice(e: BVExpr, hi: Int, lo: Int) extends BVUnaryExpr with Product with Serializable
30.  case class BVSymbol(name: String, width: Int) extends BVExpr with SMTSymbol with Product with Serializable
31.  case class BVType(width: Int) extends SMTType with Product with Serializable
32.  sealed trait BVUnaryExpr extends BVExpr
33.  case class Comment(msg: String) extends SMTCommand with Product with Serializable
34.  case class DeclareFunction(sym: SMTSymbol, args: Seq[SMTFunctionArg]) extends SMTCommand with Product with Serializable
35.  case class DeclareUninterpretedSort(name: String) extends SMTCommand with Product with Serializable
36.  case class DeclareUninterpretedSymbol(name: String, tpe: String) extends SMTCommand with Product with Serializable
37.  case class DefineFunction(name: String, args: Seq[SMTFunctionArg], e: SMTExpr) extends SMTCommand with Product with Serializable
38.  case class EmittedSMTModelAnnotation(name: String, src: String, outputSuffix: String) extends NoTargetAnnotation with CustomFileEmission with Product with Serializable
39.  case class GlobalClockAnnotation(target: ReferenceTarget) extends SingleTargetAnnotation[ReferenceTarget] with Product with Serializable
40.  sealed trait SMTCommand extends AnyRef
41.  sealed trait SMTExpr extends SMTFunctionArg

    base trait for all SMT expressions

42.  sealed trait SMTFunctionArg extends AnyRef
43.  sealed trait SMTNullaryExpr extends SMTExpr
44.  sealed trait SMTSymbol extends SMTExpr with SMTNullaryExpr
45.  sealed trait SMTType extends AnyRef
46.  case class SetLogic(logic: String) extends SMTCommand with Product with Serializable
47.  case class Signal(name: String, e: SMTExpr, lbl: SignalLabel = IsNode) extends Product with Serializable
48.  sealed trait SignalLabel extends AnyRef
49.  case class State(sym: SMTSymbol, init: Option[SMTExpr], next: Option[SMTExpr]) extends Product with Serializable
50.  class StutteringClockTransform extends Transform with DependencyAPIMigration

    Converts every input clock into a clock enable input and adds a single global clock.

    Converts every input clock into a clock enable input and adds a single global clock. - all registers and memory ports will be connected to the new global clock - all registers and memory ports will be guarded by the enable signal of their original clock - the clock enabled signal can be understood as a clock tick or posedge - this transform can be used in order to (formally) verify designs with multiple clocks or asynchronous resets

51.  case class TransitionSystem(name: String, inputs: List[BVSymbol], states: List[State], signals: List[Signal], comments: Map[String, String] = Map(), header: String = "") extends Product with Serializable
52.  case class TransitionSystemAnnotation(sys: TransitionSystem) extends NoTargetAnnotation with Product with Serializable
53.  case class UTSymbol(name: String, tpe: String) extends SMTFunctionArg with Product with Serializable
54.  case class UninterpretedModuleAnnotation(target: ModuleTarget, prefix: String, stateBits: Int = 0) extends SingleTargetAnnotation[ModuleTarget] with Product with Serializable

    ExtModules annotated as UninterpretedModule will be modelled as UninterpretedFunction (SMTLib) or constant arrays (btor2).

    ExtModules annotated as UninterpretedModule will be modelled as UninterpretedFunction (SMTLib) or constant arrays (btor2). This can be useful when trying to abstract over a function that the SMT solver or model checker is struggling with.

    E.g., one could declare an abstract 64bit multiplier like this: extmodule Mul64 : input a : UInt<64> input b : UInt<64> output r : UInt<64> Now instead of using Chisel to actually implement a multiplication circuit we can instantiate this Mul64 module twice: Once in our implementation and once for our correctness property that might specify how the multiply instruction is supposed to be executed on our CPU. Now instead of having to prove equivalence of multiplication circuits, the solver only has to make sure that the connections to the multiplier are correct, since if a and b are the same on both instances of Mul64, then the r output will also be the same. This is a much easier problem and will result in much faster solving due to manual abstraction.

    When stateBits is 0, we model the module as purely combinatorial circuit and thus expect there to be no clock wire going into the module. Every output is thus a function of all inputs of the module.

    When stateBits is an N greater than zero, we will model the module as having an abstract state of width N. Thus on every clock transition the abstract state is updated and all outputs will take the state as well as the current inputs as arguments. TODO: Support for stateful circuits is work in progress.

    All output functions well be prefixed with prefix and end in the name of the output pin. It is the users responsibility to ensure that all function names will be unique by choosing apropriate prefixes.

    The annotation is consumed by the FirrtlToTransitionSystem pass.