SystemVerilog Scope Resolution Operator

The scope resolution operator :: is used to refer to an identifier within the scope of a class, package, covergroup, coverpoint, cross, or typedef name. The left-hand side must be one of those scope names; the right-hand side is an identifier inside that scope, like a variable or method name.

7 min read | Intermediate Level

What You'll Learn

• What :: does, and what's legal on each side of it
• How to define a class method's body outside the class declaration itself
• How :: accesses a class's static members without needing an object
• How to reference a package's members directly, with or without importing the package
• How :: resolves a naming collision between an imported package and a local declaration

Why Is the Scope Resolution Operator Required?

Classes and other scopes can have identically-named identifiers, which can create a namespace collision if referred to without specifying which scope you mean. :: uniquely identifies a member or parameter of a given scope. It's also used to access a class's static variables and methods, parameters, and local parameters from outside the class, and to access public and protected members of a base class from within a derived class.

Defining an extern Function

A method can be declared inside a class with extern, and its actual body defined separately, outside the class, using :: to say which class it belongs to:

class ABC;
	int 	data;

	extern virtual function void display();
endclass

// Definition of an external function using scope
// resolution operator
function void ABC::display();
	$display("data = 0x%0h", data);
endfunction

module tb;
	initial begin
		ABC abc = new();
		abc.data = 32'hface_cafe;
		abc.display();
	end
endmodule

Output

ncsim> run
data = 0xfacecafe
ncsim: *W,RNQUIE: Simulation is complete.
ncsim> exit

ABC::display() is what tells the compiler "this function body belongs to the display() method declared inside ABC," even though it's written outside the class entirely.

Accessing Static Methods and Variables

A class's static members belong to the class itself, not to any one object, and :: lets you reach them without creating an instance first:

class ABC;
	static int 	data;

	static function void display();
		$display("data = 0x%0h", data);
	endfunction
endclass

module tb;
	initial begin
      	ABC a1, a2;

      	// Assign to static variable before creating
      	// class objects, and display using class_type and
      	// scope resolution operator
		ABC::data = 32'hface_cafe;
		ABC::display();
  
      	a1 = new();
      	a2 = new();
      	$display ("a1.data=0x%0h a2.data=0x%0h", a1.data, a2.data);
	end
endmodule

Output

ncsim> run
data = 0xfacecafe
a1.data=0xfacecafe a2.data=0xfacecafe
ncsim: *W,RNQUIE: Simulation is complete.
ncsim> exit

ABC::data is assigned before either a1 or a2 even exists, and both objects still see the same value once created — exactly what static means: one shared copy for the whole class, not one per object. See SystemVerilog Static Variables & Functions for more on this.

Referencing Package Members

:: can also reach directly into a package, referencing a type or parameter declared there without importing the whole package first — the package just needs to be included in compilation:

package my_pkg;
	typedef enum bit {FALSE, TRUE} e_bool;
endpackage

module tb;
  bit val;
  
  initial begin
  	// Refer to types that have been declared
  	// in a package. Note that package has to
  	// be included in compilation but not
  	// necessarily "imported"
    val = my_pkg::TRUE;
    $display("val = 0x%0h", val);
  end
endmodule

Output

ncsim> run
val = 0x1
ncsim: *W,RNQUIE: Simulation is complete.
ncsim> exit

my_pkg::TRUE reaches directly into the package to grab its TRUE enum value (1, since it's the second value declared in FALSE, TRUE) without an import statement anywhere.

Avoiding Namespace Collisions

Things get more interesting when a locally-declared identifier shares a name with something already imported from a package:

package my_pkg;
	typedef enum bit {FALSE, TRUE} e_bool;
endpackage

import my_pkg::*;

module tb;
  typedef enum bit {TRUE, FALSE} e_bool;
  
  initial begin
    e_bool val;
  
    // Be explicit and say that TRUE from my_pkg
    // should be assigned to val
    val = my_pkg::TRUE;
    $display("val = 0x%0h", val);
  
    // TRUE from current scope will be assigned to
    // val
    val = TRUE;
    $display("val = 0x%0h", val);
  end
endmodule

Output

ncsim> run
val = 0x1
val = 0x0
ncsim: *W,RNQUIE: Simulation is complete.
ncsim> exit

Notice the local e_bool reverses the order: TRUE, FALSE instead of the package's FALSE, TRUE — so the module's own TRUE is 0, while the package's TRUE is 1. val = my_pkg::TRUE explicitly forces the package's version, giving 0x1. val = TRUE, with no qualification, resolves to the module's own local declaration instead — giving 0x0 — because a local declaration takes precedence over a wildcard-imported (import my_pkg::*;) one, even though both are visible in the same scope.

Common Beginner Mistakes