SystemVerilog Typedef Class

Sometimes the compiler errors out because a class variable is used before the declaration of the class itself. This happens when two classes need a handle to each other — the classic chicken-and-egg puzzle. It occurs because the compiler processes the first class it encounters, and finds a reference to a second class that hasn't been declared yet.

9 min read | Intermediate Level

What You'll Learn

• Why two classes referencing each other creates a "used before declared" compile error
• How a typedef forward declaration resolves it
• How to build a complete example where two classes actually hold and use handles to each other
• How the same forward-declaration technique applies to parameterized classes

The Problem: A Chicken-and-Egg Reference

class ABC;
	DEF 	def; 	// Error: DEF has not been declared yet
endclass

class DEF;
	ABC 	abc;
endclass

Output

file: typdef-class.sv
   DEF def;
     |
ncvlog: *E,NOIPRT (typedef-class.sv,2|5): Unrecognized declaration 'DEF' could be an unsupported keyword, a spelling mistake or missing instance port list '()' [SystemVerilog].

ABC references DEF before DEF has been declared anywhere in the file — the compiler has no way to know DEF is a class at this point.

The Fix: Forward Declaration With typedef

A forward declaration using typedef tells the compiler that a class definition will be found later in the same file:

typedef class DEF;  // Inform compiler that DEF might be
                    // used before actual class definition

class ABC;
	DEF 	def;      // Okay: Compiler knows that DEF
	                // declaration will come later
endclass

class DEF;
	ABC 	abc;
endclass

By using typedef, DEF is declared to be of type class, which is later confirmed once its actual definition appears. It isn't necessary to specify that DEF is of type class in the typedef statement:

typedef DEF; 		// Legal

class ABC;
	DEF def;
endclass

A Complete Working Example

Here's the forward-declaration pattern actually put to use — ABC holds a handle to a DEF object and reads a value from it:

typedef class DEF;

class ABC;
  DEF def;
  int val = 10;

  function new (DEF d);
    def = d;
  endfunction

  function void show ();
    $display ("ABC.val=%0d, DEF.val=%0d", val, def.val);
  endfunction
endclass

class DEF;
  ABC abc;
  int val = 20;
endclass

module tb;
  initial begin
    DEF d = new ();
    ABC a = new (d);
    a.show ();
  end
endmodule

This prints ABC.val=10, DEF.val=20. d (a DEF object) is constructed first, then passed into ABC's constructor, which stores the handle. a.show() then reads its own val directly and def.val through the stored DEF handle — exactly the kind of cross-referencing the forward declaration exists to make possible.

Forward-Declaring a Parameterized Class

A typedef forward declaration also works for a class with a parameterized port list:

typedef XYZ;

module top;
	XYZ #(8'h3f, real)              xyz0;   // positional parameter override
	XYZ #(.ADDR(8'h60), .T(real))   xyz1;  	// named parameter override
endmodule

class XYZ #(parameter ADDR = 8'h00, type T = int);
endclass

Exactly like the non-parameterized case, XYZ is used (with parameter overrides) inside top before its actual definition appears later in the file.

Common Beginner Mistakes

typedef class Driver;

class Monitor;
  Driver drv;
  int rx_count = 5;

  function new (Driver d);
    drv = d;
  endfunction

  function void report ();
    $display ("rx_count=%0d, tx_count=%0d", rx_count, drv.tx_count);
  endfunction
endclass

class Driver;
  Monitor mon;
  int tx_count = 7;
endclass

module tb;
  initial begin
    Driver d = new ();
    Monitor m = new (d);
    m.report ();
  end
endmodule