dfhdl.compiler.stages

This stage adds clock and reset ports across the entire design. For each design, clock and reset ports are added once per unique domain configuration.

This connects clock and reset ports across the entire design

This stage drops register aliases (e.g., x.reg) and replaces them with explicit register variables. The most complex mechanism about this stage is the naming conversion convention.

1. If .reg is applied on a named immutable value x or a mutated wire/port that is mutated only once, then that register variable will be named x_reg. If we have several register stages applied, then we create an enumeration. So x.reg(2) yields x_reg1 and x_reg2.
2. If .reg is applied on a named mutable wire x that is mutated more than once, then we treat every new .reg application as a new version of x. In this case we get an enumeration of the version. E.g.:

      val i = DFUInt(8) <> IN
      val o = DFUInt(8) <> OUT
      val x = DFUInt(8) <> WIRE
      x := i
      o := x.reg //x_ver1_reg
      x := i + 1
      o := x.reg(2) //x_ver2_reg1, x_ver2_reg2

1. If .reg is applied on an anonymous value, then extrapolate a name suggestion based on the destination variable. This is part of the destination, so it adds _part suffix to the name of the destination. In case of several parts, we create an enumeration. E.g.:

      val i = DFUInt(8) <> IN
      val o = DFUInt(8) <> OUT
      val z = DFUInt(8) <> OUT
      o := (i + 1).reg //o_part_reg
      z := ((i + 1).reg + 7).reg(2) //z_part1_reg, z_part2_reg1, z_part2_reg2

This stage transforms a register-transfer (RT) design/domain into a valid event-driven (ED) design/domain. For this purpose it does the following: a. Adds clock and reset ports and connects them across designs. a. Converts the design/domain domainType from RT to ED. a. Adds combinational process blocks and moves the core logic to it. a. Drops register and wire declarations in favor of regular variable declarations. There are two kinds of variable declarations: local and global. Local variable declarations will appear inside the combinational process block and assignments to these variables are always blocking. Global variables are declared outside the process blocks (within the scope of the design/domain) and assignments to them are always non-blocking. a. Adds a sequential process block according to the clock and reset parameters and adds the register next value assignments to it.

This stage transforms a sequential process from a VHDL style to Verilog style. E.g.,

 process(clk):
   if (clk.rising)
     ....

is transformed into

 process(clk.rising):
   ....