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; |
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; |
RETURN_TYPE_SIGNING | Expecting signing after return data type | function signed int foo();endfunction |
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 |
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 | |
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 | for ( ; i < 10; i++) ... |
MISSING_FOR_LOOP_CONDITION | 'for' loop conditional expression required | for (i = 0; ; i++) ... |
MISSING_FOR_LOOP_STEP | 'for' loop step required | 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.for (i=1;; i++) begin end |
FOR_LOOP_INITIALIZATION | Expecting assignment in 'for' loop variable initialization | for (;i<10; i++) begin end |
SELECT_IN_WEIGHT | Select in weight specification not allowed | for (i=1;i<10;) begin end |
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}); |
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); |
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 # | |
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_ARGUMENT_DEFAULT_VALUE | Default value
#'' of # argument ''# not assignable
| task read_pm_reg1(my_class port = e_PORT_0);endtask |
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
| |
NUMERIC_NULL_OPERATION |
#'' operator is undefined for numeric type ''# and
null
| |
STRING_OPERATION | Explicit
string cast required of # operand of type
#
| |
ENUM_ASSIGNMENT | Explicit cast required when assigning
#'' to variable ''# of enum type
#
| |
ENUM_COMPARISON | Explicit cast required when comparing
#'' to variable ''# of enum type
#
| |
ENUM_RETURN | Explicit cast to enum type
#'' required when returning ''#
| |
DIFFERENT_ENUMS_ASSIGNMENT | Explicit cast required when assigning to enum type # from enum type # | |
DIFFERENT_ENUMS_COMPARISON | Explicit cast required when comparing enum type # to enum type # | |
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 ''#
| |
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
| |
REPEAT_CONDITION_STRING | String variable
# not allowed as repeat condition
| |
REPEAT_CONDITION_UNPACKED_STRUCT | Unpacked struct/union
# not allowed as repeat condition
| |
INTERFACE_NAME_SELF_REFERENCE | Interface type name
# not allowed as self reference
| virtual interface_name var = interface_name; |
INTERFACE_SELF_REFERENCE |
#'' not allowed as reference to ''# instance
| interface_name::self; |