How to avoid latches during synthesis

Question

I want to design a block of combinational logic using VHDL, but occasionally the synthesized result contains an unintentional latch.

What coding guidelines do I need to follow in order to avoid the synthesizer from inferring latches?

Example : in small segment of code, should I use if-else statements?

Answer 1

To avoid latches, you need to make sure all of your outputs are assigned at all possible branches of the code.

for example,

if a = '1' then
   b(0) <= '1';
else
   b(1 downto 0) <= "00";
end if;

would generate a latch, because in the first condition, the value of b(1) is not specified, so the compiler decided you wanted to keep the previous value of b(1) there. One way to write this that would not generate a latch is:

if a = '1' then
   b <= prev_b;
   b(0) <= '1';
else
   b(1 downto 0) <= "00";
end if;

...

if rising_edge (clk)
    prev_b <= b;
end if;

Here you explicitly state that b should retain it's old value, and then overwrite b(0) with the new value.

Another way is to give b a default value, as in @TomiJ's answer.

If you post the code you are getting a latch on, we could help you find the specific reason.

Answer 2

Four rules to avoid latches:

• Don't read from the signals to which you write.
• Have a correct sensitivity list (all signals that you read should be in the sensitivity list)
• Make sure that all signals to which your write are assigned in every path. (for example: in each branch of an if-else-statement)
• For processes which use variable, make sure every variable is initialized a default value before reading it (in another variable or signal ).

Additionally, if you have several combinational processes, make sure you don't create a loop.

Several coding styles can help you stick to these rules, for example the style in @TomiJ's answer. As @Martin Thompson points out, it may be better to avoid combinational logic all together. Put everything in a clocked process instead.

Answer 3

If you are using processes for combinational logic (and I advise against it for just this reason) then make sure every path through the process assigns something to every signal that the process drives. None of the outputs can be dependent on any of the outputs from "last time" the process ran.

Otherwise you infer a latch because the next time the process is scheduled it has to keep the value of the signal which didn't get a new value last time around.

I prefer to keep purely combinational logic as continuous assignments, and use processes for clocked logic, then I don't get latches.

Answer 4

As has been pointed out by @fbo and @Martin Thompson, you need to ensure every signal driven by the process is assigned some value in every branch of the process, and that value must not be dependent on the previous state of any of the outputs of the process.

The easiest way to ensure this is to assign some default value to each output at the very beginning of the process, for example (co-opting fbo's example):

COMBO: process(a)
begin
    b <= (others => '0'); -- Assign default value to b
    if a = '1' then
        b(0) <= '1';
    else
        b(1 downto 0) <= "00";
    end if;
end process COMBO;