A negative hold time means the data input of a flip-flop may change slightly before the clock edge and the flop will still capture the old value correctly. It usually appears because the library cell has more internal delay on its data path than on its clock path, so the hold requirement measured at the cell's pins shifts below zero. The price is a larger setup time by the same amount.
Key takeaways
- Hold time is measured at the cell's external pins, so internal delays move it. Extra internal data delay makes hold smaller, possibly negative.
- A negative hold time makes hold checks easier and reduces hold buffering after layout.
- Setup time grows by the same shift, so the sampling window does not get narrower; it just moves earlier.
- Setup time can also be negative, when the internal clock path is slower than the data path. Setup and hold cannot normally both be negative, because their sum is the width of the window in which D must be stable.
Why a flip-flop can have a negative hold time
Negative hold time is generally seen where a delay is already added in the data path inside the flop. This is usually done by the library vendor.
Assume the flop which foundry gives us as a library part that has ports named as CLK-port, Data-port. Now, in essence this is a wrapper and should be treated as one. Inside this we have the actual flop whose ports are CLK-in, Data-in. CLK-port is connected directly to CLK-in, Data-port goes through some delay element (either buffer or routing net) to Data-in. So even if the actual flop has hold requirement of say 0.2ns, if the data delay element value is 0.5ns, the library will give spec as -0.3ns HOLD requirement for the above flop. This signifies that even if the data changes 0.3ns before CLK, it can still be latched and as for the actual flop (inside the wrapper) it will still meet 0.2ns HOLD (data changes after 0.2ns from clk change).
In other words, "it can still be latched" means the flop still captures the old data correctly, because the change takes 0.5 ns to reach the inner flop and arrives 0.2 ns after the clock edge there.
An everyday picture
Think of a photographer and a runner. The photographer needs the runner to stand still for a short time around the shutter click. If there is a long corridor between where the runner starts moving and where the camera sees him, the runner can start walking a little before the click and the camera still sees him standing still. The corridor is the internal data delay; starting early is the negative hold time. But the runner must also arrive at the spot earlier, which is the larger setup time.
Advantages and disadvantages
Advantage:
The biggest advantage is less iteration after layout.
Easy and less painful synthesis (else HOLD fixing can be an iterative process).
Disadvantage:
We pay the cost in bigger setup times for above flops.
Library designers choose this trade where hold is the bigger risk, for example in scan chains and shift registers with no logic between flops.
Deep dive: the numbers and details
This part holds the equations, worked timing tables, the hold check with numbers and a Verilog simulation model. Skip it if the overview is all you need.
The general relationship
Let d_data be the internal delay from the Data-port to Data-in, and d_clk the internal delay from the CLK-port to CLK-in. Let Δ = d_data - d_clk. Then, at the pins of the cell:
thold(pin) = thold(internal) - Δ
tsetup(pin) = tsetup(internal) + Δ
When Δ is larger than the internal hold time, the pin hold time is negative. The window width, tsetup(pin) + thold(pin), equals tsetup(internal) + thold(internal), so it does not change.
Worked example: the original numbers, extended
The original example gives the internal hold time and the data delay. The internal setup time of 0.1 ns below is an assumed value added to show the setup side.
| Quantity | Inner flop | Library cell pins (Δ = 0.5 ns) |
|---|---|---|
| Hold time | 0.2 ns | 0.2 - 0.5 = -0.3 ns |
| Setup time | 0.1 ns (assumed) | 0.1 + 0.5 = 0.6 ns |
| Stable window width | 0.3 ns | 0.3 ns |
| Window position relative to the clock edge at the pins | -0.1 ns to +0.2 ns | -0.6 ns to -0.3 ns |
The window has kept its width but moved 0.5 ns earlier. Data must be stable from 0.6 ns before the edge to 0.3 ns before the edge, and is free to change after that.
Timing table: data changing 0.3 ns before the edge
| Event | At the cell pins | At the inner flop |
|---|---|---|
| Clock edge | 0.0 ns | 0.0 ns (no internal clock delay) |
| Data changes | -0.3 ns | -0.3 + 0.5 = +0.2 ns |
| Hold requirement | -0.3 ns: met, slack 0 | 0.2 ns: met, slack 0 |
What a negative hold time does to the hold check
The standard hold check, with skew defined as capture clock arrival minus launch clock arrival, is the min-delay constraint derived in the Harvey Mudd CMOS VLSI Design lecture on sequential circuit design:
tcq,min + tcomb,min >= thold + tskew
Take a shift register: two flops wired back to back, so tcomb,min is about 0. Let tcq,min = 0.10 ns and tskew = +0.25 ns.
- With thold = +0.2 ns: requirement 0.45 ns, arrival 0.10 ns, hold slack -0.35 ns. Needs delay buffers.
- With thold = -0.3 ns: requirement -0.05 ns, arrival 0.10 ns, hold slack +0.15 ns. Passes with no buffers.
This is the advantage described above, in numbers.
And what it does to setup
In the example above, setup grew from 0.1 ns to 0.6 ns, which takes 0.5 ns away from every path ending at that flop. At 1 GHz (a 1.0 ns period) that is half the cycle, so a shift this large only makes sense on hold-critical paths with plenty of setup slack. The numbers here are chosen to make the arithmetic easy to follow; read the actual values from your library's timing tables.
Negative timing checks in Verilog simulation
Gate-level simulation models express a negative hold limit with $setuphold. Because a timing check cannot look into the past, the simulator internally delays the clock and data signals so that both limits become non-negative. The model reads the delayed copies.
`timescale 1ns/1ps
module dff_neg_hold (input clk, input d, output reg q);
wire clk_dly, d_dly; // delayed copies, driven by the simulator
reg notifier;
always @(posedge clk_dly)
q <= d_dly;
specify
(posedge clk => (q +: d)) = (0.12, 0.10);
// setup limit 0.6 ns, hold limit -0.3 ns
$setuphold(posedge clk, d, 0.6, -0.3, notifier, , , clk_dly, d_dly);
endspecify
endmodule
Some simulators only honor negative limits when a specific option is enabled; otherwise they treat the negative value as zero. Check your simulator's documentation for gate-level runs with SDF.
Common mistakes to avoid
- Reading negative hold as "no hold check needed". The check still applies; it is simply easier to meet. With enough positive skew it can still fail.
- Forgetting the setup cost. The window moves; it does not shrink.
- Clamping negative values to zero in a custom flow. That makes hold look worse than it is and causes needless buffering.
Related reading
- Setup time and hold time: equations, examples and fixes
- Contamination delay and the hold time condition
- Estimating clock skew variation
- The Semiconductor Hub glossary: hold time and setup time
Frequently asked questions
What does a negative hold time mean? The data may change a little before the active clock edge and the flip-flop will still capture the previous value correctly. A hold time of -0.3 ns means data must be stable until 0.3 ns before the edge.
Is a negative hold time good or bad? It is good for hold, since short paths need fewer delay buffers, and bad for setup, since the setup time rises by the same amount.
Can setup time be negative? Yes, if the internal clock path of the cell is slower than its internal data path. The data may then arrive slightly after the clock edge at the pins.
Can setup and hold time both be negative? Not in a normal flip-flop. Their sum is the width of the window in which the data must be stable, and that width is positive.
Where is negative hold time specified? In the cell's timing library (for example the hold constraint tables in a Liberty file) and in the SDF and simulation models derived from it.


Your comments will be moderated before it appears here.