Checked casts and type safety

Upcasts are free, downcasts must be checked

Assigning a derived handle to a base handle is an upcast, and it is always legal: every err_txn is an axi_txn. The compiler accepts t = e; without any check.

The opposite direction, a downcast, assigns a base handle to a derived one. It is safe only if the object really is of the derived class, and the compiler cannot know that, so e = t; does not compile.

$cast(e, t) performs the downcast with a check while the simulation runs. It succeeds when the object t refers to is an err_txn or a class derived from it.

A function and a task

$cast can be called in two ways, and they fail differently.

Use the task form only where a failure really is a bug in the testbench, because it stops the run on the first unexpected object. Use the function form wherever other classes may legitimately arrive, and act on its result every time.

$cast(e, t);                 // task: no result
cov_err_beat = e.err_beat;

if ($cast(e, t))
  cov_err_beat = e.err_beat;
// plain reads are skipped

A failed cast changes nothing

When the function form fails, the target keeps whatever it held before. That is the stale handle in the opening story, and it is worse than an error, because nothing stops.

If later code must not see an old value, set the target to null before the cast. Then a mistake shows up as a null-handle error at the first use instead of as quietly wrong data.

Declaring the target inside the smallest block that needs it helps as well. A handle that does not outlive one loop iteration cannot carry a stale object into the next one.

Casting to a class in the middle

A cast succeeds for any object of the target class or of a class derived from it. If burst_err_txn extends err_txn, then $cast(e, t) into an err_txn handle succeeds for a burst error transaction too.

That is usually what you want: a coverage point for error beats should count every kind of error transaction, including kinds added later. Cast to the most general class that has the member you need.

A cast never converts an object

A successful cast creates no object and changes no object. It only gives you a second handle, of a more specific type, to an object that already was of that type.

A plain axi_txn can never become an err_txn. If you need an error transaction built from a read, construct a new err_txn and copy the fields across.

Where casts appear

Casts appear wherever a testbench passes objects around by their base type. A mailbox of axi_txn handles, a generic queue, or a configuration table that stores every setting as one base class all hand back base handles.

The receiving code knows which derived class it expects, and $cast turns that expectation into a check. When the check fails, report the class you expected and what arrived, as Module 1 recommends for every message.

Prefer a virtual method where you can

A chain of casts that asks "is it an error transaction, a burst, a write?" grows with every new class, and every copy of the chain must be updated. That is the job virtual methods do better.

If the caller only needs an answer, such as the expected response or a description, add a virtual method to the base class and let each object answer. Keep $cast for code that truly needs data that only one derived class has, such as an error-beat coverage point.

$cast also converts integers to enum types with a check, as Module 1 showed, and the same rule applies there: use the returned status.

Try it

The loop used the function form and acted on its result, so only ID 2 was treated as an error transaction. The ignored cast failed and left e on ID 2, which is exactly the stale handle from the opening story.

Replace void'($cast(e, stream[2])); with the task form $cast(e, stream[2]); and predict what happens to the last two lines.

Check yourself

class t;
endclass

class e_txn extends t;
  int err_beat;
endclass

module tb;
  t b;
  e_txn x, y;
  int ok;
  initial begin
    x = new();
    x.err_beat = 2;
    b = x;
    ok = $cast(y, b);
    b = new();
    ok = ok + $cast(y, b);
    $display("%0d %0d", ok, y.err_beat);
  end
endmodule

err_txn e;
if ($cast(e, t)) return e.err_beat;
return -1;

err_txn e;
int ok;
ok = $cast(e, t);
return ok ? e.err_beat : -1;

err_txn e;
if (!$cast(e, t)) return -1;
return e.err_beat;

err_txn e;
void'($cast(e, t));
return e.err_beat;

Practice

• Safe downcast Implement · Easy
• Stale cast destination Fix · Medium