|
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();endfunctionendclass |
| 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;endpackagetypedef 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] 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)();endmodulemodule 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;endclassinterface 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); endfunctionendclassclass foo2 extends foo1; virtual function bar(int child_name); endfunctionendclass |
| 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();endclassfunction 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);endclassfunction 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 |