SystemVerilog Class Constructor

A constructor is simply a method used to create a new object of a particular class data type. C/C++ requires complex memory allocation techniques, and improper de-allocation there can lead to memory leaks and other behavioral issues. SystemVerilog, although not a general-purpose programming language, handles object construction simply and provides automatic garbage collection — you never have to manually free a class object yourself.

9 min read | Intermediate Level

What You'll Learn

• What a constructor is, and what happens if you don't write one yourself
• How constructor chaining works between a base and derived class via super.new()
• Why a constructor can never be declared virtual or static
• How a "typed constructor" lets you construct a subclass object directly into a base-class handle

Explicitly Defining a Constructor

// Define a class called "Packet" with a 32-bit variable to store address
// Initialize "addr" to 32'hfade_cafe in the new function, also called constructor
class Packet;
  bit [31:0] addr;

  function new ();
    addr = 32'hfade_cafe;
  endfunction
endclass

module tb;
  
  // Create a class handle called "pkt" and instantiate the class object
  initial begin
    // The class's constructor new() fn is called when the object is instantiated
    Packet pkt = new;  
  
    // Display the class variable - Because constructor was called during
    // instantiation, this variable is expected to have 32'hfade_cafe;
    $display ("addr=0x%0h", pkt.addr);
  end
endmodule

Declaring pkt and calling new creates an object of class Packet and automatically calls the new() function inside the class. new() is the class constructor — a way to initialize class variables with some value. It has no return type, and it's non-blocking (no time-consuming statements allowed inside it).

Output

ncsim> run
addr=0xfadecafe
ncsim: *W,RNQUIE: Simulation is complete.

The Implicit Constructor

If a class doesn't define its own new() function, SystemVerilog automatically provides one. Every property then gets its type's own default value — here, addr initializes to zero, since that's the default for bit:

// Define a simple class with a variable called "addr"
// Note that the new() function is not defined here
class Packet;
	bit [31:0] addr;
endclass

module tb;
  
  	// When the class object is instantiated, then the constructor is
  	// implicitly defined by the tool and called
	initial begin
		Packet pkt = new;  
		$display ("addr=0x%0h", pkt.addr);
	end
endmodule

Output

ncsim> run
addr=0x0
ncsim: *W,RNQUIE: Simulation is complete.

Constructor Chaining in Inherited Classes

A derived class's new() method typically calls its parent class's constructor first, using super.new(). Once the base class constructor completes, each property defined in the derived class gets its own default value, and only then does the rest of the derived class's new() method run:

// Define a simple class and initialize the class member "data" in new() function
class baseClass;
  bit [15:0] data;

  function new ();
    data = 16'hface;
  endfunction
endclass

// Define a child class extended from the above class with more members
// The constructor new() function accepts a value as argument, and by default is 2
class subClass extends baseClass;
  bit [3:0] id;
  bit [2:0] mode = 3;

  function new (int val = 2);
    // The new() function in child class calls the new function in
    // the base class using the "super" keyword
    super.new ();
  
    // Assign the value obtained through the argument to the class member
    id = val;
  endfunction
endclass

module tb;
  initial begin
    // Create two handles for the child class
    subClass  sc1, sc2;
  
    // Instantiate the child class and display member variable values
    sc1 = new ();
    $display ("data=0x%0h id=%0d mode=%0d", sc1.data, sc1.id, sc1.mode);
  
    // Pass a value as argument to the new function in this case and print
    sc2 = new (4);
    $display ("data=0x%0h id=%0d mode=%0d", sc2.data, sc2.id, sc2.mode);
  end
endmodule

The order of operations here is: subClass's new() starts, immediately calls super.new(), baseClass's constructor runs to completion (setting data), control returns to subClass, its own properties get their declared or default values (mode = 3), and finally the rest of subClass's constructor body runs (id = val).

Output

ncsim> run
data=0xface id=2 mode=3
data=0xface id=4 mode=3
ncsim: *W,RNQUIE: Simulation is complete.

Why a Constructor Can't Be virtual or static

A constructor can be declared local or protected (see SystemVerilog local vs protected for what those restrict), but never static or virtual:

class ABC;
  string fruit;
  
  // Note that the constructor is defined as "virtual" which is not allowed
  // in SystemVerilog. Class constructor cannot be "static" either
  virtual function new ();
    fruit = "Apple";
  endfunction
  
endclass

// Instantiate the class object and print its contents
module tb;
  	initial begin
      ABC abc = new();
      $display ("fruit = %s", abc.fruit);
    end
endmodule

Output

  virtual function new ();
                     |
ncvlog: *E,BADQAL (testbench.sv,6|21): Lifetime or qualifier(s) 'virtual' not allowed before function new declaration.

Typed Constructors

You can call a subclass's new() function and assign the result directly to a handle of the base class, all in a single statement, by referencing the subclass's constructor with the scope resolution operator :::

class C;
endclass

class D extends C;
endclass

module tb;
   initial begin
      C c = D::new;
   end
endmodule

c, a handle of base class C, now references a newly constructed object of type D. This achieves the exact same effect as the more verbose two-step version below:

module tb;
	initial begin
		D d = new;
		C c = d;
	end
endmodule

Common Beginner Mistakes

class grandchildClass extends subClass;
  bit [3:0] tag = 7;

  function new (int val = 2);
    super.new (val);
  endfunction
endclass

module tb;
  initial begin
    grandchildClass gc;
    gc = new ();
    $display ("data=0x%0h id=%0d mode=%0d tag=%0d", gc.data, gc.id, gc.mode, gc.tag);
  end
endmodule