SystemVerilog Inheritance

Inheritance is a concept in OOP that lets you extend a class to create another class, gaining access to all the properties and methods of the original parent class through the new class's own object handle. The idea is to let you add new properties and methods into the new class while still keeping access to the original class members — and to make modifications without touching the base class at all.

8 min read | Intermediate Level

What You'll Learn

• How extends builds a child class from a parent, inheriting its properties and methods
• How a child class can override a parent's method with its own version
• Why calling an overridden method through a parent-typed handle uses the parent's version, not the child's, unless the method is declared virtual
• How to call a parent's own version of an overridden method from inside the child, using super

A Basic Example

ExtPacket is extended from, and is therefore a child class of, Packet. Being a child class, it inherits properties and methods from its parent. Both classes define a method called display() — when called through a child class handle, the child's own version runs; when called through a parent class handle, the parent's version runs:

class Packet;
   int addr;

   function new (int addr);
      this.addr = addr;
   endfunction

	function display ();
		$display ("[Base] addr=0x%0h", addr);
	endfunction
endclass

// A subclass called 'ExtPacket' is derived from the base class 'Packet' using
// 'extends' keyword which makes 'ExtPacket' a child of the parent class 'Packet'
// The child class inherits all variables and methods from the parent class
class ExtPacket extends Packet;

	// This is a new variable only available in child class
	int data;

   function new (int addr, data);
      super.new (addr); 	// Calls 'new' method of parent class
      this.data = data;
   endfunction

	function display ();
		$display ("[Child] addr=0x%0h data=0x%0h", addr, data);
	endfunction
endclass

module tb;
	Packet      bc; 	// bc stands for BaseClass
	ExtPacket   sc; 	// sc stands for SubClass

	initial begin
		bc = new (32'hface_cafe);
		bc.display ();

        sc = new (32'hfeed_feed, 32'h1234_5678);
		sc.display ();
	end
endmodule

Output

ncsim> run
[Base] addr=0xfacecafe
[Child] addr=0xfeedfeed data=0x12345678
ncsim: *W,RNQUIE: Simulation is complete.

sc's constructor calls super.new(addr) to run Packet's own constructor first (setting addr), then sets its own data property — exactly the constructor-chaining pattern covered in SystemVerilog Class Constructor. ExtPacket's own display() completely replaces Packet's version rather than adding to it, which is why bc and sc print in different formats.

Why the Handle's Type Matters (Without virtual)

It gets more interesting once a base-class-typed handle ends up pointing to a child class object — something that's perfectly legal, since a child class object is also a valid kind of its parent class:

module tb;
	Packet      p;
	ExtPacket   sc;

	initial begin
        sc = new (32'hfeed_feed, 32'h1234_5678);

        // p is declared as type Packet, but now points to the SAME
        // ExtPacket object that sc points to
        p = sc;

        p.display ();
	end
endmodule

Since neither display() here is declared virtual, p.display() is resolved based on p's declared type (Packet), not the actual object it points to (an ExtPacket). The result: this prints [Base] addr=0xfeedfeed — Packet's version of display(), even though p is actually pointing at the exact same object as sc, which has a data field this call never shows.

This is exactly the kind of surprising behavior virtual methods exist to fix — with virtual, the call would instead dispatch based on the object's actual type, not the handle's declared type. See SystemVerilog Virtual Methods and SystemVerilog Polymorphism for the full picture.

Accessing the Parent's Version With super

Overriding a method doesn't have to mean completely replacing the parent's behavior — from inside the child class, super.method_name() calls the parent's own version explicitly, the same way super.new() calls the parent's constructor:

class ExtPacket extends Packet;
  int data;

  function new (int addr, data);
    super.new (addr);
    this.data = data;
  endfunction

  function display ();
    // Run the parent's own display() first, then add the child's own line
    super.display ();
    $display ("        data=0x%0h", data);
  endfunction
endclass

Calling sc.display() with this version would print both lines — Packet's own "[Base] addr=..." line first (via super.display()), followed by the child's own "data=..." line — instead of the child's version having to duplicate the parent's formatting itself.

Common Beginner Mistakes

class ExtPacket2 extends ExtPacket;
  int crc;

  function new (int addr, data, crc);
    super.new (addr, data);
    this.crc = crc;
  endfunction

  function display ();
    super.display ();
    $display ("        crc=0x%0h", crc);
  endfunction
endclass