Non Standard Checks

ID

Message

Notes/Examples

ASSERTION_IN_CUNIT_SCOPE

Deferred immediate assertion not allowed in compilation-unit scope

assert #0 (0 == 0);

EXTERN_DECLARATION_IN_CUNIT_SCOPE

Extern function not allowed in compilation-unit scope

extern int foo();

FATAL_SYSTEM_TASK_FIRST_ARGUMENT

Expecting 0, 1 or 2 as first argument to ‘$fatal’ system task

$fatal(4, "Sorry");

BEGIN_END_OUTSIDE_GENERATE

‘begin/end’ generate block not allowed

CONFIGURATION_RULE

Unexpected configuration rule

MISSING_CONFIGURATION_RULE_SEMI

Expecting ‘;’ after configuration rule

instance top.sub.u1 liblist gateLib

TIMEUNIT_IN_CLASS_SCOPE

# declaration not allowed in class scope

 
class foo;
   timeunit 100ps;
   timeprecision 10fs;
endclass

FUNCTION_PROTOTYPE

Expecting ‘function’ keyword in prototype declaration

extern void foo();

PURE_QUALIFIER_POSITION

‘pure’ qualifier not allowed before # qualifier

protected pure local virtual function void wrong_order();

CONSTRUCTOR_LIFETIME

‘automatic’ lifetime for class constructor not allowed

 
class foo;
  function automatic new();
  endfunction
endclass

CLASS_VARIABLE_LIFETIME

‘automatic’ lifetime for class variable # not allowed

 
class foo;
    automatic int bar;
endclass

CONSTRAINT_DEFAULT_QUALIFIER

‘default’ qualifier for constraint not allowed

 
default constraint a_cons {
    x == 0;
    y <= 0;
}

HARD_SOLVE_BEFORE

‘hard’ qualifier not allowed

 
constraint c_cons {
    x == 0;
    y <= 0;
    solve x before y hard;
}

SOFT_AFTER_EXPRESSION

‘soft’ must be placed before the expression

 
constraint c_cons {
    x dist {0, 1} soft;
}

SOFT_BEFORE_SOFT

‘soft’ not allowed before ‘soft’

 
constraint c_cons {
    soft soft x;
}

SOFT_BEFORE_UNIQUE

‘soft’ not allowed before ‘unique’

 
constraint c_cons {
    soft unique {}
}

SOFT_BEFORE_IF

‘soft’ not allowed before ‘if’

 
constraint c_cons {
    soft if (condition) {}
}

SOFT_BEFORE_FOREACH

‘soft’ not allowed before ‘foreach’

 
constraint c_cons {
    soft foreach (array[i]) {}
}

SOFT_BEFORE_DISABLE

‘soft’ not allowed before ‘disable’

 
constraint c_cons {
    soft disable soft x;
}

PARENTHESES_DIST_EXPRESSION

Enclosing parentheses not allowed for dist expression

 
constraint c_cons {
    (x dist {0,1});
    (foreach (array[i]) { });
    (x -> 2);
}

SPACE_DIST_WEIGHT

Unexpected space between : and # in dist weight

 
rand int x; constraint c_cons {
    x dist {0 : = 3};
}

DYNAMICPARAM

Unexpected keyword ‘dynamicparam’

dynamicparam p = 3;

CONST_AFTER_STATIC

‘const’ qualifier not allowed after ‘static’

static const int x = 0;

LIFETIME_QUALIFIER_BEFORE_VAR

# qualifier not allowed before ‘var’

automatic var int x = 0;

TYPEDEF_COVERGROUP

Typedef of covergroup not allowed

typedef covergroup cg;

TYPEDEF_DATATYPE

Explicit data type required (implicit ‘logic’ is assumed)

typedef [3:0] new_type;

IMPLICIT_DATA_TYPE_IN_DECLARATION

Expecting net type (e.g. wire) or ‘var’ keyword before implicit data type

[3:0] var_or_net;

PACKED_DIMENSION_INTEGER_TYPE

Unexpected packed dimension for integer type

 
function integer[3:0] foo();
endfunction

PACKED_STRUCT_WITH_SIGNING

Expecting ‘packed’ before signing

 
typedef struct signed {
    int x;
    int y;}
packed_with_sign;

TYPEOF_SYSTEM_FUNCTION

‘$typeof’ system function not allowed

 
bit[3:0] field;
typedef $typeof(field) new_type;

PACKAGE_SCOPE_IN_ENUM_BASE_TYPE

Package scope before enum base type not allowed

 
package package_name;
  typedef int id;
endpackage

typedef enum package_name::id {R,G,B} new_enum;

ENUM_IMPLICIT_DATATYPE

Explicit data type required (implicit # is assumed)

typedef enum [1:0] {R,G,B} new_enum;

DELAY_VALUE_EXPRESSION

Expecting parentheses around bit-select and part-select

always ... #del[0] ok = 1;

PARAMETER_DYNAMIC_ARRAY

Fixed size required for parameter dimension

 
parameter logic flag1[] = '{2};
localparam logic flag2[] = '{2};

CONST_EXPR_PACKED_DIMENSION

Expecting constant range instead of constant expression for packed dimension

enum bit[1] { A, B } foo;

QUALIFIER_BEFORE_METHOD

# qualifier not allowed before method keyword

 
static function foo();

  ...

endfunction

CLASS_SCOPE_END_LABEL

Class scope #:: before end label not allowed

... endfunction : class_scope::func_name

HIERARCHICAL_INTERFACE_IDENTIFIER

Hierarchical interface identifier #.# not allowed

task id1.id2.id3();

PROTOTYPE_RETURN_DATA_TYPE

Expecting return data type or void for function prototype

extern function doCheck();

DPI_DECLARATION_STRING

Expecting “DPI” or “DPI-C”

import "DPI_C" init_1 = function void moo();

EMPTY_ARGUMENTS_LIST

Empty arguments list ‘()’ not allowed when arguments are declared inside function / task body

 
function void foo();
    output integer x;
endfunction

DYNAMIC_ARRAY_INITIALIZATION

Unexpected ‘new’ initialization for dynamic array

 
task foo(input int a[] = new[1]);
endtask

CLASS_INSTANCE_INITIALIZATION

Unexpected ‘new’ initialization for class instance

 
function void foo(cls i = new());
endfunction

MODPORT_PORTS_DECLARATION

Unexpected empty modport ports declaration

modport mp_name();

MODPORT_PORT_DIRECTION

Explicit direction required for port #

modport mp_name(x, input y);

MODPORT_HIERARCHICAL_PORT

Hierarchical identifier not allowed in modport port declaration

modport master (output sb.gnt);

MODPORT_IMPORT_EXPORT

Unexpected .* used in modport import / export declaration

modport master (import sb.\*);

REPETITION_IN_SEQUENCE

Goto repeat ‘[->’ and non-consecutive repeat ‘[=’ operators not allowed

COVERPOINT_IFF_EXPRESSION

Expecting parentheses around coverpoint ‘iff’ expression

coverpoint a iff test;

BINS_IFF_EXPRESSION

Expecting parentheses around bins ‘iff’ expression

bins a = { [0:63],65 } iff ana;

COVERCROSS_IFF_EXPRESSION

Expecting parentheses around covercross ‘iff’ expression

BINS_SELECTION_IFF_EXPRESSION

Expecting parentheses around bins selection ‘iff’ expression

WILDCARD_BINS_SELECTION

‘wildcard’ not allowed for bins selection

 
covergroup cov @(posedge clk);
  aXb : cross a, b { wildcard bins i_zero = binsof(a) intersect { 0 }; }
endgroup

HIERARCHICAL_ACCESS_IN_BINS_EXPRESSION

Cover point hierarchical identifier not allowed in bins expression

binsof(x.cover_point_id.bin_id);

SELECT_IN_BINS_EXPRESSION

Select not allowed in bins expression

binsof(cover_point_id.bin_id[3]);

COVERPOINT_EXPRESSION_TYPE

Coverpoint expression should be of an integral data type

COVERGROUP_EXPRESSION

Expecting constant expression or non-ref covergroup argument, found #

 
int field;
covergroup cg() with function sample(int unsigned foo);
  coverpoint foo {
      ignore_bins ignore = foo with (field > 2);
  }
endgroup

CONCATENATION_MULTIPLIER

Expecting constant expression as concatenation multiplier, found #

 
int field = 8;
logic[7:0&#93 x = { field {1'b1}}

PULL_GATE_INSTANCE

Multiple terminals to a pull gate instance not allowed

pullup p (t1, t2, t3);

IMPLICIT_INSTANCE_NAME

Implicit name not allowed for instance of #

 
module top(input i, output o);
  m1(.i(i), .o(o));
  endmodule

PARENTHESES_GATE_TERMINAL

Enclosing parentheses around gate terminal not allowed

tranif0 ti0 (x, (y), z);

PARAMETER_OVERRIDE

Expecting parentheses around parameter override

 
module m #(P1=1)();
endmodule

module top();
  m # 3 u_m();
endmodule

EMPTY_ORDERED_PARAMETER_OVERRIDE

Empty parameter override in ordered list not allowed

xmm_atomic_gen #(transaction, ,"Atomic Gen") msg_rx_gen;

MULTIPLE_DOT_STAR_CONNECTIONS

Dot start port connection ‘.*’ cannot appear more than once in the port list

m u_m(.*, .\*);

INITIAL_BLOCK_SCOPE

Unexpected initial block construct

 
package p1;
    initial begin end;
endpackage

FINAL_BLOCK_SCOPE

Unexpected final block construct

 
package p1;
    final begin end;
endpackage

SELECT_IN_EVENT_CONTROL

Select in event control not allowed

@u_m3_1.a[1];

EVENT_TRIGGER

‘class_name::’ not allowed in event trigger construct

'->' a_class::a;

DISABLE_STATEMENT

‘class_name::’ not allowed in disable statement

disable a_class::a;

EMPTY_CASE_STATEMENT

Empty case statement not allowed

 
case (x)

endcase

EMPTY_ASSIGNMENT_PATTERN

Empty assignment pattern ‘{} not allowed

x = '{};

MISSING_FOR_LOOP_INITIALIZATION

‘for’ loop variable initialization required

Note

Not applicable in IEEE 1800-2012 standard syntax or newer.

for ( ; i < 10; i++) ...

MISSING_FOR_LOOP_CONDITION

‘for’ loop conditional expression required

Note

Not applicable in IEEE 1800-2012 standard syntax or newer.

for (i = 0; ; i++) ...

MISSING_FOR_LOOP_STEP

‘for’ loop step required

Note

Not applicable in IEEE 1800-2012 standard syntax or newer.

for (i = 0; i < 10; ) ...

FOREACH_LOOP_CONDITION

Multidimensional array select not allowed in foreach loop condition

Note

Strict only check. See +dvt_strict_non_standard_checks build directive on how to activate it.

foreach (array[val][i]) ...

FOR_LOOP_INITIALIZATION

Expecting assignment in ‘for’ loop variable initialization

for (++i;i<10; i++) begin end

SELECT_IN_WEIGHT

Select in weight specification not allowed

randsequence() ... first : add := array[0]; endsequence

PARALLEL_PATH_DESCRIPTION

List of inputs in parallel path description not allowed

(in1,in2 => q[1]) = 1;

RANGE_IN_MULTIPLE_CONCATENATION

Range in multiple concatenation not allowed

x = {0:3{1}};

ASSIGNMENT_PATTERN

Expecting assignment pattern ‘{…} instead of concatenation

x = {a : '0, b : '1};

ASSIGNMENT_PATTERN_CONTEXT

Assignment pattern not allowed outside assignment-like context (could not determine data type)

if (struct_signal == '{ a, b }) ...

SCALAR_ASSIGNMENT_PATTERN

Variable of 1-bit scalar type # not allowed as target of assignment pattern

bit x = '{ '0 };

TARGET_UNPACKED_ARRAY_CONCATENATION

Unpacked array concatenation not allowed as target expression

.out({ a, b })

STREAM_CONCATENATION_TYPE

Packed dimension on stream concatenation type not allowed

result = { >> bit [7:0] { variable_name } };

RANDOMIZE_ARGUMENT

Range selection of randomize argument # not allowed

std::randomize(rand_var[7:0]) with {...};

INSIDE_OPERATOR

‘inside’ operator in constant expression not allowed

int y[a inside {b, c} ? 10 : 2];

INSIDE_OPERATOR_RANGE

Expecting curly braces {} around ‘inside’ operator range

if ( a inside x ) ...

TYPE_CASTING

Expecting tick before type casting expression

int(some_var)

NULL_CONSTANT_EXPRESSION

Expecting constant expression instead of ‘null’

class my_class #(parameter string x = null

TIME_VALUE

Unexpected white space between number and time value

timeunit 10 ps;

HIERARCHICAL_CLASS_ACCESS

Class scope resolution access ‘::’ not allowed

a.b.c::enum_value

SELECT_IN_CROSS_ITEMS_LIST

Select in cross items list not allowed

 
covergroup g2 @(posedge clk);
    AxC: cross color[2], pixel_adr;
endgroup

HIERARCHICAL_ROOT_ACCESS

Unexpected ‘$root’ name before package or class scope access

$root.my_pkg::my_signal

COMMA_AFTER_ATTRIBUTE_INSTANCE

Attribute instance followed by ‘;’ not allowed

(\* full_case, parallel_case; \*)

CONST_ATTRIBUTE_INSTANCE

‘const’ for attribute instance not allowed

(\* const int full_case=1, parallel_case \*)

ATTRIBUTE_INSTANCE_DATA_TYPE

Attribute instance data type not allowed

(\* integer library_binding = 1, something = 1 \*)

SELECT_IN_ATTRIBUTE_INSTANCE

Select in attribute instance not allowed

(\* cds_net_set[0:2] = {"a", "b", "c"} \*)

TYPEOF_SYSTEM_TASK

Unexpected ‘$typeof’ system task

$typeof(a) b;

KEYWORD_AS_IDENTIFIER

Reserved keyword # not allowed as identifier

instance, restrict, checker, table, cell, config, design

MULTIPLE_BINS

Specification of multiple bins dimension not allowed

wildcard bins trans 2 = ({1'bx} => {1'bx});

ASSERTION_STATEMENT_ATTRIBUTE_INSTANCE

Expecting attribute instance after block identifier # for procedural assertion statement

(\* cover_attribute \*) block_identifier : cover property ...

SYSTEM_FUNCTION_ARGUMENTS

Maximum number of arguments for # system function is #

$typename(x, 39);

PARENTHESES_PATTERN

Enclosing parentheses around pattern not allowed

matches (tagged VAL .c)

WILDCARD_EQUALITY_OPERATOR

Expecting wildcard operator ‘==?’ instead of ‘=?=’

WILDCARD_INEQUALITY_OPERATOR

Expecting wildcard operator ‘!=?’ instead of ‘!?=’

STRING_CONTINUATION

Expecting ‘\’ to continue the string on the next line

 
string str = "string is splittedon

multiple lines";

STRING_CONTINUATION_WS

White-space not allowed after ‘\’ line continuation

 
string str = "string is splitted \\[white-space]

\\[white-space]

on multiple lines";

COMPILER_GUARD

Expecting identifier after `ifdef, `ifndef, `elsif instead of `#

USELIB_DIRECTIVE

Unexpected Verilog-XL directive `uselib, use -y, -v, and +libext command line flags instead

LIBRARY_PATH

Quotes for library path specification not allowed

library rtlLib "top.v";

MACRO_TEXT

Macro text string must terminate with `” instead of “

$sformat(errStr, \`"ID``_``SUFFIX SIGNAL is %b",SIGNAL);

MACRO_MULTILINE_DELIMITER

Unexpected whitespace character(s) after macro multiline delimiter

 
\`define my_macro int i; \\

int j;

EXPONENT_FORMAT_TIME_VALUE

Unexpected exponent format for time value

#(1.0e9ns)

API

Unexpected method / field #

Note

Strict only check for some API. See +dvt_strict_non_standard_checks build directive on how to activate all.

NOF_PARAMETER_OVERRIDES

Expected # parameter overrides, found #

 
module mod;
endmodule

...

mod#(2) field;

MISSING_FUNCTION_IMPLEMENTATION

# extern function is not implemented

MISSING_TASK_IMPLEMENTATION

# extern task is not implemented

FUNCTION_IMPLEMENTATION_SCOPE

Function implementation of # must be in the same scope as class #

TASK_IMPLEMENTATION_SCOPE

Task implementation of # must be in the same scope as class #

CONSTRAINT_IMPLEMENTATION_SCOPE

Constraint implementation # must be in the same scope as class #

MODPORT_IMPORT_EXPORT_PORT

Expecting method name instead of interface signal name #

 
class foo;
endclass

interface bar(input clk);
  foo field;
  modport mp1(export field);
endinterface

SELECT_METHOD_CALL

Select not allowed after # method call

m4.foo()[0]

EVENT_CONTROL_EXPRESSION

Expecting singular data type for event control expression instead of type #

 
initial begin
    @(cif_enable) $display("list_of_arguments");
end

METHOD_OVERRIDE_ARGUMENT_NAME

Argument name # of method # does not match # of override #

 
class foo1;
    virtual function bar(int base_name);
    endfunction
endclass

class foo2 extends foo1;
    virtual function bar(int child_name);
    endfunction
endclass

FUNCTION_IMPLEMENTATION_RETURN_TYPE

Return type # of function # must be the same as prototype return type (non-standard use of type alias)

 
typedef bit my_type;

class foo;
    extern function bit boo();
endclass

function my_type foo::boo();
endfunction

FUNCTION_IMPLEMENTATION_INTERNAL_RETURN_TYPE

Internal return type # for the implementation of extern method # requires scope resolution

function cls_internal_type cls::foo(); ...

METHOD_IMPLEMENTATION_ARGUMENT_TYPE

Argument type # of method # must be the same as prototype argument type (non-standard use of type alias)

 
typedef bit my_type;
class foo;
    extern function bit boo(bit arg);
    extern function bit goo(bit arg);
endclass

function bit foo::boo(my_type arg);
endfunction

VOID_CAST_OF_VOID_FUNCTION

Void cast of void function # not allowed

void'(void_return_function())

LOGICAL_NEGATION

Operand of type # not allowed with logical negation # (use == null instead)

if (!class_obj) ...

BINARY_LOGICAL_OPERATOR

Operand of type # not allowed with binary logical operator # (use != null instead)

if (class_obj && class_obj.field == 0) ...

DYNAMIC_ARRAY_NULL_OPERATION

# operator is undefined for dynamic array # and ‘null’

if (array == null) ...

NUMERIC_NULL_OPERATION

# operator is undefined for numeric type # and ‘null’

if (sig == null) ...

STRING_OPERATION

Explicit ‘string’ cast required of # operand of type #

 
string a;
int b;
if (a == b) ...

ENUM_ASSIGNMENT

Explicit cast required when assigning # to variable # of enum type #

 
enum_type a;
a+=1;

ENUM_COMPARISON

Explicit cast required when comparing # to variable # of enum type #

 
enum_type a;
if (a < 1) ...

ENUM_RETURN

Explicit cast to enum type # required when returning #

 
function enum_type foo();
   return 1;
endfunction

DIFFERENT_ENUMS_ASSIGNMENT

Explicit cast required when assigning to enum type # from enum type #

 
enum_type a;
a = other_enum_literal;

DIFFERENT_ENUMS_COMPARISON

Explicit cast required when comparing enum type # to enum type #

 
enum_type a;
if (a < other_enum_literal) ...

EVENT_CONTROL

The following events must be of a singular data type:#

 
always @(a or b) begin
    c = a[0] & b;
end

IMPORT_TYPE_WITHOUT_EXPORT

Package # must export type #

import pkg::not_exported_type;

TYPE_SPECIALIZATION

Type # is already a specialization of #

 
typedef cls#(.T(int)) type_alias;
type_alias#(.T(int)) field;

REPEAT_CONDITION_UNPACKED_ARRAY

Unpacked array # not allowed as repeat condition

 
int array[2];
repeat (array) ...

REPEAT_CONDITION_STRING

String variable # not allowed as repeat condition

 
string str;
repeat (str) ...

REPEAT_CONDITION_UNPACKED_STRUCT

Unpacked struct / union # not allowed as repeat condition

 
struct { int x; } val;
repeat (val) ...

INTERFACE_NAME_SELF_REFERENCE

Interface type name # not allowed as self reference

virtual interface_name var = interface_name;

INVALID_VIRTUAL_INTERFACE

Interface # containing interface ports cannot be used as a virtual interface

interface intf(interface port)

INVALID_RAND_MODE_CALL

‘rand_mode’ call not allowed for non-random variable #

 
int x;

function foo();
    x.rand_mode(0);
endfunction

PORT_DEFAULT_VALUE

Ouput / Inout / Ref port # cannot have a default value

ANSI_ARGUMENT_REDECLARATION

Redeclaration of ANSI argument # is not allowed

 
function foo(input ansi_arg);
    logic ansi_arg;
endfunction

ANSI_PORT_REDECLARATION

Redeclaration of ANSI port # is not allowed

 
module foo(input ansi_port);
    logic ansi_port;
endmodule

REDUNDANT_NON_ANSI_PORT_DIRECTION

Declaration of port # has redundant input / output / inout direction

 
module foo(arg);
    input arg;
    input wire arg;
endmodule