SystemVerilog Virtual Methods

In Inheritance and Polymorphism, we saw that a method called through a base class handle pointing to a child class instance still ends up executing the base class's own version, not the child's. If that method is declared virtual, only then does the child class's version actually run:

bc = sc;            // Base class handle is pointed to a sub class

bc.display ();      // This calls the display() in base class and
                    // not the sub class as we might think

This article puts both versions side by side, using the exact same classes from those two articles, so the effect of adding virtual is completely isolated — nothing else about the code changes.

7 min read | Intermediate Level

What You'll Learn

• Why a non-virtual method dispatches based on the handle's declared type, not the object's actual type
• How declaring a method virtual changes dispatch to the object's actual type instead
• Whether a child class's override needs to repeat the virtual keyword itself
• The general rule of thumb for when a base class method should be declared virtual

Without virtual

// Without declaring display() as virtual
class Packet;
   int addr;

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

   // This is a normal function definition which
   // starts with the keyword "function"
   function void display ();
		$display ("[Base] addr=0x%0h", addr);
   endfunction
endclass

// ExtPacket from the Inheritance article, repeated here since this
// article's examples build on it directly
class ExtPacket extends Packet;
   int data;

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

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

module tb;
   Packet bc;
   ExtPacket sc;

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

        bc = sc;
		bc.display ();
	end
endmodule

Output

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

The base class's own display() runs, even though bc actually points to an ExtPacket object — dispatch here is based on bc's declared type, Packet.

With virtual

class Packet;
   int addr;

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

   // Here the function is declared as "virtual"
   // so that a different definition can be given
   // in any child class
   virtual function void display ();
		$display ("[Base] addr=0x%0h", addr);
	endfunction
endclass

// ExtPacket from the Inheritance article, repeated here since this
// article's examples build on it directly
class ExtPacket extends Packet;
   int data;

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

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

module tb;
   Packet bc;
   ExtPacket sc;

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

        bc = sc;
		bc.display ();
	end
endmodule

Output

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

The exact same bc.display() call now runs ExtPacket's own version instead — with virtual, dispatch is based on the object's actual type, not the handle's declared type. The key takeaway: declare base class methods virtual whenever a child class might override them, so that existing base class handles correctly reach the override.

Common Beginner Mistakes

class ExtPacket2 extends ExtPacket;
  int crc;

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

  virtual function void display ();
    $display ("[Grandchild] addr=0x%0h data=0x%0h crc=0x%0h", addr, data, crc);
  endfunction
endclass

module tb;
  Packet bc;
  ExtPacket2 gc;

  initial begin
    gc = new (32'hfeed_feed, 32'h1234_5678, 32'habab_cdcd);
    bc = gc;          // bc is Packet-typed, but points to an ExtPacket2 object
    bc.display ();
  end
endmodule