SVT - Macro Reference

`define _OVM_CB_MSG_NO_CBS ( FUNC )

$sformatf(`"ovm_callback::FUNC - No callbacks registered with object '%s'`",
(obj==null?"null":obj.get_full_name()))

`define _OVM_CB_MSG_NOT_REG ( FUNC )

$sformatf(`"ovm_callback::FUNC - Callback '%s' not registered with object '%s'`",cb.get_name(),
(obj==null?"null":obj.get_full_name()))

`define _OVM_CB_MSG_NULL_CB ( FUNC )

$sformatf(`"ovm_callback::FUNC - Callback argument for object '%s' is null`",
(obj==null?"null":obj.get_full_name()))

`define _OVM_CB_MSG_NULL_OBJ ( FUNC )

`"ovm_callback::FUNC - Object argument is null`"

`define _protected

protected

`define abstract_avm_to_ovm_component ( name )

virtual class avm_``name #(type T=int) extends ovm_``name#(T);
function new(string name , ovm_component parent = null );
super.new( name, parent );
endfunction : new
endclass

`define ANSI_BG_BLACK

"\033[40m"

`define ANSI_BG_BLUE

"\033[44m"

`define ANSI_BG_CYAN

"\033[46m"

`define ANSI_BG_GREEN

"\033[42m"

`define ANSI_BG_MAGENTA

"\033[45m"

`define ANSI_BG_RED

"\033[41m"

`define ANSI_BG_WHITE

"\033[47m"

`define ANSI_BG_YELLOW

"\033[43m"

`define ANSI_BOLD

"\033[5m"

`define ANSI_BRIGHT

"\033[1m"

`define ANSI_DIM

"\033[2m"

`define ANSI_FG_BLACK

"\033[30m"

`define ANSI_FG_BLUE

"\033[34m"

`define ANSI_FG_CYAN

"\033[36m"

`define ANSI_FG_GREEN

"\033[32m"

`define ANSI_FG_MAGENTA

"\033[35m"

`define ANSI_FG_RED

"\033[31m"

`define ANSI_FG_WHITE

"\033[37m"

`define ANSI_FG_YELLOW

"\033[33m"

`define ANSI_RESET

"\033[0m"

`define ANSI_REVERSE

"\033[7m"

`define ANSI_UNDERSCORE

"\033[4m"

`define apply_request_with ( OVM_DATA_REQ, CONSTRAINTS )

wait_for_grant();
  pre_apply();
  if (! OVM_DATA_REQ.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("ovm_scenario", "Randomization failed in apply_request_with");
  end
  mid_apply();

`define apply_send_with ( OVM_DATA_REQ, CONSTRAINTS )

apply_request_with(OVM_DATA_REQ, CONSTRAINTS);
send_request(OVM_DATA_REQ);
post_apply();

`define apply_with ( OVM_DATA_REQ, OVM_DATA_RSP, CONSTRAINTS )

apply_request_with(OVM_DATA_REQ, CONSTRAINTS)
  send_request(OVM_DATA_REQ);
  get_response(OVM_DATA_RSP);
  post_apply();

`define AVM_compatibility_SVH

`define avm_to_ovm_bidi ( kind )

class avm_``kind``_port #(type REQ=int,RSP=int) extends ovm_``kind``_port #(REQ,RSP);
function new( string name, ovm_component parent, int min_size = 1, int max_size = 1 );
      super.new( name, parent, min_size, max_size );
endfunction : new
endclass
class avm_``kind``_export #(type REQ=int,RSP=int) extends ovm_``kind``_export #(REQ,RSP);
function new( string name, ovm_component parent, int min_size = 1, int max_size = 1 );
      super.new( name, parent, min_size, max_size );
endfunction : new
endclass
class avm_``kind``_imp #( type REQ = int , type RSP = int ,
    type IMP = int ,
    type REQ_IMP = IMP ,
    type RSP_IMP = IMP )
  extends ovm_``kind``_imp #( REQ, RSP, IMP, REQ_IMP, RSP_IMP);
   function new( string name , IMP imp ,
   REQ_IMP req_imp = imp , RSP_IMP rsp_imp = imp );
     super.new( name , imp , req_imp, rsp_imp);
  endfunction
endclass

`define avm_to_ovm_component ( name )

class avm_``name #(type T=int) extends ovm_``name#(T);
function new(string name , ovm_component parent = null );
super.new( name, parent );
endfunction : new
endclass

`define avm_to_ovm_policy ( name )

class avm_``name #(type T=int) extends ovm_``name#(T);
endclass

`define avm_to_ovm_uni ( kind )

class avm_``kind``_port #(type T=int) extends ovm_``kind``_port #(T);
function new( string name, ovm_component parent, int min_size = 1, int max_size = 1 );
      super.new( name, parent, min_size, max_size );
endfunction : new
endclass
class avm_``kind``_export #(type T=int) extends ovm_``kind``_export #(T);
function new( string name, ovm_component parent, int min_size = 1, int max_size = 1 );
      super.new( name, parent, min_size, max_size );
endfunction : new
endclass
class avm_``kind``_imp #(type T=int,IMP=int) extends ovm_``kind``_imp #(T,IMP);
function new( string name, IMP imp);
      super.new( name, imp );
endfunction : new
endclass

`define BACKWARD_COMPAT_MACROS_SVH

`define BASE_COMPATIBILITY_SVH

`define BLOCKING_GET_IMP ( imp, TYPE, arg )

task get (output TYPE arg);
imp.get(arg);
endtask

`define BLOCKING_GET_IMP_SFX ( SFX, imp, TYPE, arg )

task get( output TYPE arg); imp.get``SFX( arg); endtask

`define BLOCKING_GET_PEEK_IMP ( imp, TYPE, arg )

BLOCKING_GET_IMP(imp, TYPE, arg)
BLOCKING_PEEK_IMP(imp, TYPE, arg)

`define BLOCKING_PEEK_IMP ( imp, TYPE, arg )

task peek (output TYPE arg);
imp.peek(arg);
endtask

`define BLOCKING_PEEK_IMP_SFX ( SFX, imp, TYPE, arg )

task peek( output TYPE arg);imp.peek``SFX( arg); endtask

`define BLOCKING_PUT_IMP ( imp, TYPE, arg )

task put (TYPE arg);
imp.put(arg);
endtask

`define BLOCKING_PUT_IMP_SFX ( SFX, imp, TYPE, arg )

task put( input TYPE arg); imp.put``SFX( arg); endtask

`define BLOCKING_TRANSPORT_IMP ( imp, REQ, RSP, req_arg, rsp_arg )

task transport (REQ req_arg, output RSP rsp_arg);
imp.transport(req_arg, rsp_arg);
endtask

`define BLOCKING_TRANSPORT_IMP_SFX ( SFX, imp, REQ, RSP, req_arg, rsp_arg )

task transport( input REQ req_arg, output RSP rsp_arg);
imp.transport``SFX(req_arg, rsp_arg);
endtask

`define COMPATIBILITY_SVH

`define const

const

`define DODEEPCOPY ( ARG, FLAG )

begin
    ovm_object this_d__, from_d__;
    if(tmp_data__ != null)
      if(!$cast(local_data__, tmp_data__)) begin
        ovm_object::m_sc.scratch1 = `"Cast failed for argument: ARG`";
      end
    if(ARG != null) $cast(this_d__,ARG);
    if(local_data__.ARG != null) $cast(from_d__,local_data__.ARG);

    if((this_d__==null) && (from_d__!=null)) begin
      this_d__ = from_d__.clone();
      this_d__.set_name(`"ARG`");
    end
    else if(from_d__ == null)
      this_d__ = from_d__;
    else begin
      this_d__.copy(from_d__);
    end
    if((this_d__ == null) || !$cast(ARG, this_d__)) begin
      ovm_object::m_sc.scratch1 = `"Cast failed for ARG during copy`";
      _global_reporter.ovm_report_error("CSTFLD", ovm_object::m_sc.scratch1, OVM_NONE);
    end
  end

`define DOREFERENCECOPY ( ARG, FLAG )

if( (FLAG)&OVM_REFERENCE))
ARG = local_data__.``ARG;

`define DOSHALLOWCOPY ( ARG1, ARG2, FLAG )

if( (FLAG)&OVM_SHALLOW)
    begin
      ovm_object lhs__, rhs__;
      ovm_object::m_sc.scratch1 = `"Executing shallow copy of arg ARG`";
/* Can't do shallow copy right now due to an issue with abstract classes */
/* like ovm_object, so do a deep copy instead. */
      if(ARG2==null) ARG1 = ARG2;
      else begin
        if(ARG1 != null) $cast(lhs__, ARG1);
        if(ARG2 != null) $cast(rhs__, ARG2);
        if(rhs__!=null && lhs__!=null)
          lhs__.copy(rhs__);
        else if(rhs__ != null) begin
          $cast(lhs__, rhs__.clone());
          if (lhs__ != null)
            $cast(ARG1, lhs__);
        end
        else
          ARG1 = null;
/* ARG = new local_data__.ARG; */
      end
    end
  else
    begin
      ovm_object::m_sc.scratch1 = `"Shallow copy off for arg ARG`";
    end

`define DUT_ERROR ( MESSAGE )

do urm_pkg_msg_imp("DUT",MESSAGE,ovm_pkg::OVM_URM_MSG_DUT,ovm_pkg::OVM_ERROR,ovm_pkg::OVM_NONE,"",ovm_global_reporter)
while (0)

`define dut_error ( MESSAGE )

urm_msg_imp("DUT",MESSAGE,OVM_URM_MSG_DUT,OVM_ERROR,OVM_NONE,get_full_name(),m_get_report_object())

`define FUNCTION_ERROR

"TLM interface function not implemented"

`define GET_IMP ( imp, TYPE, arg )

BLOCKING_GET_IMP(imp, TYPE, arg)
NONBLOCKING_GET_IMP(imp, TYPE, arg)

`define GET_PEEK_IMP ( imp, TYPE, arg )

BLOCKING_GET_PEEK_IMP(imp, TYPE, arg)
NONBLOCKING_GET_PEEK_IMP(imp, TYPE, arg)

`define GUARD_SVT_8B10B_DATA_SV

`define GUARD_SVT_AGENT_SV

`define GUARD_SVT_BASE_MEM_SUITE_CONFIGURATION_SV

`define GUARD_SVT_BFM_SHELL_ASSISTANT_SV

`define GUARD_SVT_BFM_SHELL_OVM_PKG

`define GUARD_SVT_BFM_SHELL_SOURCE_OVM_SVI

`define GUARD_SVT_BOOTLOADER_SVI

Clients wishing to pull in the OVM package manually have a couple of options for doing so.

SVT_EXCLUDE_METHODOLOGY_PKG - If the goal is to avoid having to specify OVM_HOME on the command line, then the SVT package needs to exclude all OVM file references. The client can accomplish this by setting the SVT_EXCLUDE_METHODOLOGY_PKG define on the command line. This will cause both ovm_pkg.sv and ovm_macros.svh to be excluded from svt.ovm.pkg. The testbench must ensure that the OVM package has already been compiled and that the ovm_pkg is available to be imported before compiling the VIP package when using this option. The ovm_macros.svh file must also be included by the testbench before compiling the VIP package.
SVT_EXCLUDE_METHODOLOGY_PKG_INCLUDE - If the goal is to just externalize the compile, but to support the specification of an OVM_HOME on the command line, then the SVT package just needs to exclude the 'include' reference for the OVM package. The client can accomplish this by setting the SVT_EXCLUDE_METHODOLOGY_PKG_INCLUDE define on the command line. This will cause ovm_pkg.sv to be excluded from svt.ovm.pkg, but ovm_macros.svh will still be included by the SVT package. The testbench must ensure that the OVM package has already been compiled and that the ovm_pkg is available to be imported before compiling the VIP package when using this option.

`define GUARD_SVT_BROADCAST_SEQUENCE_SV

`define GUARD_SVT_BROADCAST_SV

`define GUARD_SVT_CALLBACK_SOURCE_SV

`define GUARD_SVT_CHANNEL_SV

`define GUARD_SVT_CMD_DEFINES_SVI

`define GUARD_SVT_COMMON_DEFINES_SVI

`define GUARD_SVT_COMPARER_SV

`define GUARD_SVT_COMPONENT_SV

`define GUARD_SVT_COMPOUND_PATTERN_DATA_SV

`define GUARD_SVT_CONFIG_DB_SV

`define GUARD_SVT_CONFIGURATION_SV

`define GUARD_SVT_CONSENSUS_SV

`define GUARD_SVT_CONTROLLED_EVENT_SV

`define GUARD_SVT_DATA_CONVERTER_SV

`define GUARD_SVT_DATA_FSDB_WRITER_SV

`define GUARD_SVT_DATA_ITER_SV

`define GUARD_SVT_DATA_QUEUE_ITER_SV

`define GUARD_SVT_DATA_STREAM_SV

`define GUARD_SVT_DATA_SV

`define GUARD_SVT_DATA_UTIL_SVI

`define GUARD_SVT_DATA_WRITER_SV

`define GUARD_SVT_DEBUG_OPTS_CARRIER_SV

`define GUARD_SVT_DEBUG_OPTS_IMP_PORT_SV

`define GUARD_SVT_DEBUG_OPTS_INTERCEPT_SV

`define GUARD_SVT_DEBUG_OPTS_PORT_SV

`define GUARD_SVT_DEBUG_OPTS_SV

`define GUARD_SVT_DEBUG_VIP_DESCRIPTOR_SV

`define GUARD_SVT_DEFINES_SVI

`define GUARD_SVT_DISPATCH_SEQUENCE_SV

`define GUARD_SVT_DISPATCH_SV

`define GUARD_SVT_DOWNSTREAM_IMP_SV

`define GUARD_SVT_DRIVER_BFM_SHELL_SV

`define GUARD_SVT_DRIVER_SV

`define GUARD_SVT_DYNAMIC_REPORT_OBJECT_SV

`define GUARD_SVT_ENV_SV

`define GUARD_SVT_ERR_CATCHER_SV

`define GUARD_SVT_ERR_CHECK_STATS_COV_SV

`define GUARD_SVT_ERR_CHECK_STATS_SV

`define GUARD_SVT_ERR_CHECK_SV

`define GUARD_SVT_EVENT_CONTROLLER_SV

`define GUARD_SVT_EVENT_POOL_SV

`define GUARD_SVT_EXCEPTION_LIST_SV

`define GUARD_SVT_EXCEPTION_SV

`define GUARD_SVT_EXIT_TIMER_SV

`define GUARD_SVT_FACTORY_1ARG_SV

`define GUARD_SVT_FACTORY_2ARG_SV

`define GUARD_SVT_FACTORY_3ARG_SV

`define GUARD_SVT_FACTORY_SV

`define GUARD_SVT_FIFO_RATE_CONTROL

`define GUARD_SVT_FIFO_RATE_CONTROL_CONFIGURATION_SV

`define GUARD_SVT_FSM_SV

`define GUARD_SVT_FUZZY_REAL_COMPARER_SV

`define GUARD_SVT_GLOBALS_SV

`define GUARD_SVT_IF_UTIL_SVI

`define GUARD_SVT_INTERNAL_XACTOR_SV

`define GUARD_SVT_LOADER_UTIL_SVI

`define GUARD_SVT_LOGGER_SV

`define GUARD_SVT_MEM_ADDRESS_MAPPER_STACK_SV

`define GUARD_SVT_MEM_ADDRESS_MAPPER_SV

`define GUARD_SVT_MEM_BACKDOOR_BASE_SV

`define GUARD_SVT_MEM_BACKDOOR_SV

`define GUARD_SVT_MEM_CATALOG_SV

`define GUARD_SVT_MEM_CATALOG_SVI

`define GUARD_SVT_MEM_COMMON_DEFINES_SVI

`define GUARD_SVT_MEM_CONFIGURATION_SV

`define GUARD_SVT_MEM_CORE_SV

`define GUARD_SVT_MEM_DEFINES_SVI

`define GUARD_SVT_MEM_DPI_SVI

`define GUARD_SVT_MEM_DRIVER_CALLBACK_SV

`define GUARD_SVT_MEM_DRIVER_SV

`define GUARD_SVT_MEM_OVM_PKG

The basic objective of this program is to delave a final block to terminate the SLI license server. Since final blocks cannot exist inside a package, this must be defined external to the SVT package.

This file therefore provides the final block, inside a program, for inclusion in the SVT package files.

`define GUARD_SVT_MEM_RAM_SEQUENCE_SV

`define GUARD_SVT_MEM_SA_CORE_2state_SV

`define GUARD_SVT_MEM_SA_CORE_4state_SV

`define GUARD_SVT_MEM_SA_DEFS_SVI

`define GUARD_SVT_MEM_SA_DPI_SVI

`define GUARD_SVT_MEM_SA_HELPERS_SV

`define GUARD_SVT_MEM_SEQUENCE_SV

`define GUARD_SVT_MEM_SEQUENCER_SV

`define GUARD_SVT_MEM_SOURCE_OVM_SVI

`define GUARD_SVT_MEM_SUITE_CONFIGURATION_SV

`define GUARD_SVT_MEM_SV

`define GUARD_SVT_MEM_SYSTEM_BACKDOOR_SV

`define GUARD_SVT_MEM_TRANSACTION_SV

`define GUARD_SVT_MEM_WORD_SV

`define GUARD_SVT_MESSAGE_MANAGER_SV

`define GUARD_SVT_MONITOR_BFM_SHELL_SV

`define GUARD_SVT_MONITOR_SV

`define GUARD_SVT_NOTIFY_SV

`define GUARD_SVT_NVS_LOADER_UTIL_SVI

`define GUARD_SVT_OBJECT_PATTERN_DATA_SV

`define GUARD_SVT_OVM_OBJECT_WRAPPER_SV

`define GUARD_SVT_OVM_PKG

`define GUARD_SVT_OVM_RESOURCE_DB_SV

`define GUARD_SVT_OVM_UTIL_SVI

`define GUARD_SVT_PA_OBJECT_DATA_SV

`define GUARD_SVT_PACKER_SV

`define GUARD_SVT_PATTERN_DATA_CARRIER_SV

`define GUARD_SVT_PATTERN_DATA_SV

`define GUARD_SVT_PATTERN_SEQUENCE_SV

`define GUARD_SVT_PATTERN_SV

`define GUARD_SVT_PHASE_SV

`define GUARD_SVT_PKG_PRECURSOR_SV

`define GUARD_SVT_RANDOMIZE_ASSISTANT_SV

`define GUARD_SVT_REACTIVE_DRIVER_SV

`define GUARD_SVT_REACTIVE_SEQUENCE_SV

`define GUARD_SVT_REACTIVE_SEQUENCER_SV

`define GUARD_SVT_REPORT_CATCHER_SV

`define GUARD_SVT_SEQUENCE_LIBRARY_SV

`define GUARD_SVT_SEQUENCE_SV

`define GUARD_SVT_SEQUENCER_SV

`define GUARD_SVT_SOURCE_INTERNAL_SVI

`define GUARD_SVT_SOURCE_OVM_SVI

`define GUARD_SVT_STATUS_SV

`define GUARD_SVT_SVC_ERR_CHECK_STATS_SV

`define GUARD_SVT_SVC_ERR_CHECK_SV

`define GUARD_SVT_SVC_MESSAGE_MANAGER_SV

`define GUARD_SVT_SVC_OVM_PKG

`define GUARD_SVT_SVC_SOURCE_OVM_SVI

`define GUARD_SVT_TIMER_SV

`define GUARD_SVT_TOGGLE_COV_BIT_SV

`define GUARD_SVT_TOGGLE_COV_BIT_VECTOR_SV

`define GUARD_SVT_TRAFFIC_ARBITER_SV

`define GUARD_SVT_TRAFFIC_PROFILE_EVENT_SV

`define GUARD_SVT_TRAFFIC_PROFILE_TRANSACTION_SV

`define GUARD_SVT_TRANSACTION_ITER_SV

`define GUARD_SVT_TRANSACTION_REPORT_SV

`define GUARD_SVT_TRANSACTION_SV

`define GUARD_SVT_TRIGGERED_TIMER_SV

`define GUARD_SVT_TYPES_SV

`define GUARD_SVT_VCAP_SV

`define GUARD_SVT_VIP_WRITER_FSDB_UTIL_SV

`define GUARD_SVT_VIP_WRITER_SV

`define GUARD_SVT_VMM_UVM_BRIDGE_OVM_PKG

`define GUARD_SVT_VMM_UVM_BRIDGE_SOURCE_OVM_SVI

`define GUARD_SVT_VOTER_SV

`define GUARD_SVT_XACTOR_CALLBACK_SV

`define GUARD_SVT_XACTOR_SV

`define GUARD_SVT_XML_WRITER_SV

`define M_OVM_FIELD_ARRAY_INT_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i])
              ovm_auto_options_object.packer.pack_field(ARG[i], $bits(ARG[i]));
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              ARG = new[s_];
            end
            foreach(ARG[i])
              ARG[i] = ovm_auto_options_object.packer.unpack_field($bits(ARG[i]));
          end
        end
  endcase

`define M_OVM_FIELD_ARRAY_OBJ_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i]) begin
              ovm_auto_options_object.packer.pack_object(ARG[i]);
            end
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              if(ARG.size() < s_)
                _global_reporter.ovm_report_error("OBJUPK", $psprintf(`"Array ARG cannot support the unpack operation, the unpack requires %0d elements, ARG has only %0d`", s_, ARG.size()), OVM_NONE);
            end
            foreach(ARG[i]) begin
              ovm_auto_options_object.packer.unpack_object(ARG[i]);
              if(ovm_auto_options_object.packer.use_metadata == 0 && ARG[i] == null)
                return;
            end
          end
        end
  endcase

`define M_OVM_FIELD_ARRAY_REAL_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i])
              ovm_auto_options_object.packer.pack_real(ARG[i]);
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              ARG = new[s_];
            end
            foreach(ARG[i])
              ARG[i] = ovm_auto_options_object.packer.unpack_real();
          end
        end
  endcase

`define M_OVM_FIELD_ARRAY_STR_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i])
              ovm_auto_options_object.packer.pack_string(ARG[i]);
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              ARG = new[s_];
            end
            foreach(ARG[i]) begin
              ARG[i] = ovm_auto_options_object.packer.unpack_string(-1);
            end
          end
        end
  endcase

`define M_OVM_FIELD_DATA ( ARG, FLAG )

begin
    int r__;
    if((what__ == OVM_PRINT) && (((FLAG)&OVM_NOPRINT) == 0) && (ovm_radix_enum'((FLAG)&OVM_RADIX) == OVM_ENUM) &&
        (ovm_auto_options_object.printer.knobs.print_fields == 1)) begin
      $swrite(m_sc.stringv, "%0d", ARG);
      ovm_auto_options_object.printer.print_generic(`"ARG`", "enum",
          $bits(ARG), m_sc.stringv);
    end
    else if((what__ == OVM_RECORD) && (((FLAG)&OVM_NORECORD) == 0) && (ovm_radix_enum'((FLAG)&OVM_RADIX) == OVM_ENUM))
    begin
      $swrite(m_sc.stringv, "%0d", ARG);
      ovm_auto_options_object.recorder.record_string(`"ARG`",m_sc.stringv);
    end
    else if(tmp_data__!=null) begin
      if($cast(local_data__, tmp_data__)) begin
        r__ = m_do_data(`"ARG`", ARG, local_data__.ARG, what__, $bits(ARG), FLAG);
      end
    end
    else begin
      if(what__ != OVM_COMPARE && what__ != OVM_COPY) begin
        r__ = m_do_data(`"ARG`", ARG, 0, what__, $bits(ARG), FLAG);
      end
    end
    if((what__ == OVM_COMPARE) && r__) begin
      if(ovm_radix_enum'((FLAG)&OVM_RADIX) == OVM_ENUM) begin
        if(local_data__!=null) begin
          ovm_print_msg_enum(ARG, local_data__.ARG)
        end
        else begin
          ovm_print_msg_enum(ARG, 0)
        end
      end
    end
  end

`define M_OVM_FIELD_DATA_AA_enum_key ( KEY, ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      KEY aa_key;
      case (what__)
        OVM_COMPARE:
           begin
            if(!((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              if(ARG.num() != local_data__.ARG.num()) begin
                 int s1__, s2__;
                 m_sc.stringv = "";
                 s1__ = ARG.num(); s2__ = local_data__.ARG.num();
                 $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d",
                    s1__, s2__);
                 ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
              end
              ovm_auto_options_object.comparer.scope.up(null);
              if(ARG.first(aa_key))
                do begin
                  void'(ovm_auto_options_object.comparer.compare_field_int({`"ARG[`",aa_key.name(),"]"},
                    ARG[aa_key], local_data__.ARG[aa_key], $bits(ARG[aa_key]),
                    ovm_radix_enum'((FLAG)&OVM_RADIX) ));
                end while(ARG.next(aa_key));
              ovm_auto_options_object.comparer.scope.down(`"ARG`",null);
            end
           end
        OVM_COPY:
          begin
            if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              ARG.delete();
              if(local_data__.ARG.first(aa_key))
                do begin
                  ARG[aa_key] = local_data__.ARG[aa_key];
                end while(local_data__.ARG.next(aa_key));
            end
          end
        OVM_PRINT:
          begin
            ovm_printer p__ = ovm_auto_options_object.printer;
            p__.print_array_header (`"ARG`", ARG.num(),`"aa_``KEY`");
            if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
            begin
              if(ARG.first(aa_key))
                do begin
                  ovm_auto_options_object.printer.print_field(
                    {"[",aa_key.name(),"]"}, ARG[aa_key], $bits(ARG[aa_key]),
                    ovm_radix_enum'((FLAG)&OVM_RADIX), "[" );
                end while(ARG.next(aa_key));
            end
            p__.print_array_footer(ARG.num());
            p__.print_footer();
          end
      endcase
    end
  end

`define M_OVM_FIELD_DATA_AA_generic ( TYPE, KEY, ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      case (what__)
        OVM_COMPARE:
           begin
            if(!((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              if(ARG.num() != local_data__.ARG.num()) begin
                 int s1__, s2__;
                 m_sc.stringv = "";
                 s1__ = ARG.num(); s2__ = local_data__.ARG.num();
                 $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d",
                    s1__, s2__);
                 ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
              end
              string_aa_key = "";
              while(ARG.next(string_aa_key)) begin
                ovm_auto_options_object.comparer.scope.set_arg({"[",string_aa_key,"]"});
                void'(m_do_data({`"ARG[`", string_aa_key, "]"},
                    ARG[string_aa_key],
                    local_data__.ARG[string_aa_key], what__,
                    $bits(ARG[string_aa_key]), FLAG));
                ovm_auto_options_object.comparer.scope.unset_arg(string_aa_key);
              end
            end
           end
        OVM_COPY:
          begin
            if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              ARG.delete();
              string_aa_key = "";
              while(local_data__.ARG.next(string_aa_key))
                ARG[string_aa_key] = local_data__.ARG[string_aa_key];
            end
          end
        OVM_PRINT:
          `ovm_print_aa_``KEY``_``TYPE``3(ARG, ovm_radix_enum'((FLAG)&(OVM_RADIX)),
             ovm_auto_options_object.printer)
      endcase
    end
  end

`define M_OVM_FIELD_DATA_AA_int_key ( KEY, ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      KEY aa_key;
      case (what__)
        OVM_COMPARE:
           begin
            if(!((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              if(ARG.num() != local_data__.ARG.num()) begin
                 int s1__, s2__;
                 m_sc.stringv = "";
                 s1__ = ARG.num(); s2__ = local_data__.ARG.num();
                 $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d",
                    s1__, s2__);
                 ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
              end
              ovm_auto_options_object.comparer.scope.up(null);
              if(ARG.first(aa_key))
                do begin
                  $swrite(string_aa_key, "%0d", aa_key);
                  ovm_auto_options_object.comparer.scope.set_arg({"[",string_aa_key,"]"});
                  void'(m_do_data({`"ARG[`", string_aa_key, "]"},
                    ARG[aa_key],
                    local_data__.ARG[aa_key], what__,
                    $bits(ARG[aa_key]), FLAG));
                  ovm_auto_options_object.comparer.scope.unset_arg(string_aa_key);
                end while(ARG.next(aa_key));
              ovm_auto_options_object.comparer.scope.down(`"ARG`",null);
            end
           end
        OVM_COPY:
          begin
            if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              ARG.delete();
              if(local_data__.ARG.first(aa_key))
                do begin
                  ARG[aa_key] = local_data__.ARG[aa_key];
                end while(local_data__.ARG.next(aa_key));
            end
          end
        OVM_PRINT:
          ovm_print_aa_int_key4(KEY,ARG, ovm_radix_enum'((FLAG)&(OVM_RADIX)),
             ovm_auto_options_object.printer)
      endcase
    end
  end

`define M_OVM_FIELD_DATA_AA_int_string ( ARG, FLAG )

M_OVM_FIELD_DATA_AA_generic(int, string, ARG, FLAG)

`define M_OVM_FIELD_DATA_AA_object_int ( ARG, FLAG )

begin
    int key__;
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      case (what__)
        OVM_COMPARE:
           begin
            if(!((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              if(ARG.num() != local_data__.ARG.num()) begin
                 int s1__, s2__;
                 m_sc.stringv = "";
                 s1__ = ARG.num(); s2__ = local_data__.ARG.num();
                 $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d",
                          s1__, s2__);
                 ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
              end
              if(ARG.first(key__)) begin
                do begin
                  ovm_object tmp__;
                  /* Since m_do_data_object is inout, need a ovm_object for */
                  /* assignment compatibility. We must cast back the return. */
                  tmp__ = ARG[key__];
                  $swrite(m_sc.stringv, "[%0d]", key__);
                  ovm_auto_options_object.comparer.scope.down_element(key__,tmp__);
                  void'(m_do_data_object(m_sc.stringv, tmp__,
                      local_data__.ARG[key__], what__, FLAG));
                  ovm_auto_options_object.comparer.scope.up_element(tmp__);
                end while(ARG.next(key__));
              end
            end
          end
        OVM_COPY:
          begin
           if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
           begin
            $cast(local_data__, tmp_data__);
            ARG.delete();
            if(local_data__.ARG.first(key__))
             do begin
               if((FLAG)&OVM_REFERENCE)
                ARG[key__] = local_data__.ARG[key__];
             /*else if((FLAG)&OVM_SHALLOW)*/
             /* ARG[key__] = new local_data__.ARG[key__];*/
               else begin
                 ovm_object tmp_obj;
                 tmp_obj = local_data__.ARG[key__].clone();
                 if(tmp_obj != null)
                   $cast(ARG[key__], tmp_obj);
                 else
                   ARG[key__]=null;
               end
             end while(local_data__.ARG.next(key__));
           end
         end
        OVM_PRINT:
          ovm_print_aa_int_object3(ARG, ovm_auto_options_object.printer,FLAG)
      endcase
    end
  end

`define M_OVM_FIELD_DATA_AA_object_string ( ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      case (what__)
        OVM_COMPARE:
           begin
            if(!((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              if(ARG.num() != local_data__.ARG.num()) begin
                 int s1__, s2__;
                 m_sc.stringv = "";
                 s1__ = ARG.num(); s2__ = local_data__.ARG.num();
                 $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d",
                          s1__, s2__);
                 ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
              end
              string_aa_key = "";
              while(ARG.next(string_aa_key)) begin
                ovm_object tmp;
                /* Since m_do_data_object is inout, need a ovm_object for */
                /* assignment compatibility. We must cast back the return. */
                tmp = ARG[string_aa_key];
                ovm_auto_options_object.comparer.scope.down({"[",string_aa_key,"]"},tmp);
                void'(m_do_data_object({"[", string_aa_key, "]"}, tmp,
                    local_data__.ARG[string_aa_key], what__, FLAG));
                ovm_auto_options_object.comparer.scope.up(tmp,"[");
              end
            end
          end
        OVM_COPY:
          begin
           if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
           begin
            $cast(local_data__, tmp_data__);
            ARG.delete();
            if(local_data__.ARG.first(string_aa_key))
             do
               if((FLAG)&OVM_REFERENCE)
                ARG[string_aa_key] = local_data__.ARG[string_aa_key];
             /*else if((FLAG)&OVM_SHALLOW)*/
             /* ARG[string_aa_key] = new local_data__.ARG[string_aa_key];*/
               else begin
                $cast(ARG[string_aa_key],local_data__.ARG[string_aa_key].clone());
                ARG[string_aa_key].set_name({`"ARG`","[",string_aa_key, "]"});
               end
             while(local_data__.ARG.next(string_aa_key));
           end
          end
        OVM_PRINT:
          ovm_print_aa_string_object3(ARG, ovm_auto_options_object.printer,FLAG)
      endcase
    end
  end

`define M_OVM_FIELD_DATA_AA_string_string ( ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      case (what__)
        OVM_COMPARE:
           begin
            if(!((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) )
            begin
              $cast(local_data__, tmp_data__);
              if(ARG.num() != local_data__.ARG.num()) begin
                 int s1__, s2__;
                 m_sc.stringv = "";
                 s1__ = ARG.num(); s2__ = local_data__.ARG.num();
                 $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d",
                    s1__, s2__);
                 ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
              end
              string_aa_key = "";
              while(ARG.next(string_aa_key)) begin
                ovm_auto_options_object.comparer.scope.set_arg({"[",string_aa_key,"]"});
                void'(m_do_data_string({`"ARG[`", string_aa_key, "]"},
                    ARG[string_aa_key],
                    local_data__.ARG[string_aa_key], what__, FLAG) );
                ovm_auto_options_object.comparer.scope.unset_arg(string_aa_key);
              end
            end
           end
        OVM_COPY:
          begin
            if(!((FLAG)&OVM_NOCOPY) && (local_data__ !=null))
            begin
              ARG.delete();
              string_aa_key = "";
              while(local_data__.ARG.next(string_aa_key))
                ARG[string_aa_key] = local_data__.ARG[string_aa_key];
            end
          end
        OVM_PRINT:
          ovm_print_aa_string_string2(ARG, ovm_auto_options_object.printer)
      endcase
    end
  end

`define M_OVM_FIELD_DATA_ARRAY ( ARG, FLAG )

begin
     case (what__)
       OVM_COMPARE:
         if ( !((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) ) begin
           int i__;
           $cast(local_data__, tmp_data__);
           if(ARG.size() != local_data__.ARG.size()) begin
             int s1__, s2__;
             m_sc.stringv = "";
             s1__ = ARG.size(); s2__ = local_data__.ARG.size();
             $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d", s1__, s2__);
             ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
           end
           for(i__=0; i__<ARG.size() && i__ARG.size(); ++i__) begin
             if(ARG[i__] !== local_data__.``ARG[i__]) begin
               ovm_auto_options_object.comparer.scope.down_element(i__, null);
               case(OVM_RADIX&(FLAG))
                 OVM_BIN: $swrite(m_sc.stringv, "lhs = 'b%0b : rhs = 'b%0b",
                                ARG[i__], local_data__.ARG[i__]);
                 OVM_OCT: $swrite(m_sc.stringv, "lhs = 'o%0o : rhs = 'o%0o",
                                ARG[i__], local_data__.ARG[i__]);
                 OVM_DEC: $swrite(m_sc.stringv, "lhs = %0d : rhs = %0d",
                                ARG[i__], local_data__.ARG[i__]);
                 OVM_UNSIGNED: $swrite(m_sc.stringv, "lhs = %0d : rhs = %0d",
                                ARG[i__], local_data__.ARG[i__]);
                 OVM_HEX: $swrite(m_sc.stringv, "lhs = 'h%0x : rhs = 'h%0x",
                                ARG[i__], local_data__.ARG[i__]);
                 OVM_STRING: $swrite(m_sc.stringv, "lhs = %0s : rhs = %0s",
                                ARG[i__], local_data__.ARG[i__]);
                 OVM_TIME: $swrite(m_sc.stringv, "lhs = %0t : rhs = %0t",
                                ARG[i__], local_data__.ARG[i__]);
                 default: $swrite(m_sc.stringv, "lhs = %0d : rhs = %0d",
                                ARG[i__], local_data__.ARG[i__]);
               endcase
               ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
               ovm_auto_options_object.comparer.scope.up_element(null);
             end
           end
         end
       OVM_COPY:
         if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null))
          begin
           int i__;
           $cast(local_data__, tmp_data__);
           /*Resizing of array is done in ovm_field*/
           for(i__=0; i__ < ARG``.size(); ++i__) begin
             ARG[i__] = local_data__.``ARG[i__] ;
           end
         end
       OVM_PRINT:
         begin
           if(((FLAG)&OVM_NOPRINT) == 0 &&
                          ovm_auto_options_object.printer.knobs.print_fields == 1) begin
             ovm_print_array_int3(ARG, ovm_radix_enum'((FLAG)&(OVM_RADIX)),
                                   ovm_auto_options_object.printer)
           end
         end
       OVM_RECORD:
         begin
           if(((FLAG)&OVM_NORECORD) == 0) begin
             m_ovm_record_array_int(ARG, ovm_radix_enum'((FLAG)&(OVM_RADIX)),
                                   ovm_auto_options_object.recorder)
           end
         end
     endcase
   end

`define M_OVM_FIELD_DATA_ARRAY_OBJECT ( ARG, FLAG )

begin
   if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
     ovm_object this_d__, from_d__;
     case (what__)
       OVM_COMPARE:
         if ( !((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null)) begin
           int i__;
           ovm_recursion_policy_enum orig_policy;
           orig_policy = ovm_auto_options_object.comparer.policy;
           if(((FLAG)&OVM_REFERENCE) != 0) begin
             ovm_auto_options_object.comparer.policy = OVM_REFERENCE;
           end
           $cast(local_data__, tmp_data__);
           if(ARG.size() != local_data__.``ARG.size()) begin
             int s1__, s2__;
             m_sc.stringv = "";
             s1__ = ARG.size(); s2__ = local_data__.ARG.size();
             $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d", s1__, s2__);
             ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
           end
           for(i__=0; i__<ARG.size() && i__ARG.size(); ++i__)
             void'(ovm_auto_options_object.comparer.compare_object($psprintf(`"ARG[%0d]`",i__), ARG[i__], local_data__.ARG[i__]));
           ovm_auto_options_object.comparer.policy = orig_policy;
         end
       OVM_COPY:
         if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
          begin
           int i__;
           $cast(local_data__, tmp_data__);
           /*Resizing of array is done in ovm_field_array* macro*/
           for(i__=0; i__ < ARG``.size(); ++i__) begin
             DOSHALLOWCOPY(ARG[i__], local_data__.ARG[i__], FLAG)
             DODEEPCOPY(ARG[i__], FLAG)
           end
         end
       OVM_PRINT:
           if((((FLAG)&OVM_NOPRINT) == 0) &&
              ovm_auto_options_object.printer.knobs.print_fields == 1)
           begin
             ovm_print_array_object3(ARG, ovm_auto_options_object.printer,FLAG)
           end
       OVM_RECORD:
         begin
           if((((FLAG)&OVM_NORECORD) == 0) && (((FLAG)&OVM_SHALLOW) == 0)) begin
             m_ovm_record_array_object(ARG,ovm_auto_options_object.recorder)
           end
         end
     endcase
   end
   end

`define M_OVM_FIELD_DATA_ARRAY_REAL ( ARG, FLAG )

begin
   if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
     case (what__)
       OVM_COMPARE:
         if ( !((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) ) begin
           int i__;
           $cast(local_data__, tmp_data__);
           if(ARG.size() != local_data__.``ARG.size()) begin
             int s1__, s2__;
             m_sc.stringv = "";
             s1__ = ARG.size(); s2__ = local_data__.ARG.size();
             $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d", s1__, s2__);
             ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
           end
           for(i__=0; i__<ARG.size() && i__ARG.size(); ++i__)
             if(ARG[i__] != local_data__.ARG[i__]) begin
               real ls__, rs__;
               ls__ = ARG[i__]; rs__ = local_data__.ARG[i__];
               ovm_auto_options_object.comparer.scope.down_element(i__, null);
               $swrite(m_sc.stringv, "lhs = %0f : rhs = %0f", ls__, rs__);
               ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
               ovm_auto_options_object.comparer.scope.up_element(null);
             end
         end
       OVM_COPY:
         if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
          begin
           int i__;
           $cast(local_data__, tmp_data__);
           /*Resizing of array is done in ovm_field_array* macro*/
           for(i__=0; i__ < ARG.size(); ++i__)
             ARG[i__] = local_data__.ARG[i__] ;
         end
       OVM_PRINT:
         begin
           if((FLAG)&OVM_NOPRINT != 0 &&
                          ovm_auto_options_object.printer.knobs.print_fields == 1)
             ovm_print_array_real2(ARG, ovm_auto_options_object.printer)
         end
       OVM_RECORD:
         begin
           if(((FLAG)&OVM_NORECORD) == 0 && !m_sc.array_warning_done) begin
             m_ovm_record_array_real(ARG, ovm_auto_options_object.recorder)
           end
         end
     endcase
   end
   end

`define M_OVM_FIELD_DATA_ARRAY_STRING ( ARG, FLAG )

begin
   if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
     case (what__)
       OVM_COMPARE:
         if ( !((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) ) begin
           int i__;
           $cast(local_data__, tmp_data__);
           if(ARG.size() != local_data__.``ARG.size()) begin
             int s1__, s2__;
             m_sc.stringv = "";
             s1__ = ARG.size(); s2__ = local_data__.ARG.size();
             $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d", s1__, s2__);
             ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
           end
           for(i__=0; i__<ARG.size() && i__ARG.size(); ++i__)
             if(ARG[i__] != local_data__.ARG[i__]) begin
               string ls__, rs__;
               ls__ = ARG[i__]; rs__ = local_data__.ARG[i__];
               ovm_auto_options_object.comparer.scope.down_element(i__, null);
               $swrite(m_sc.stringv, "lhs = %0s : rhs = %0s", ls__, rs__);
               ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
               ovm_auto_options_object.comparer.scope.up_element(null);
             end
         end
       OVM_COPY:
         if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
          begin
           int i__;
           $cast(local_data__, tmp_data__);
           /*Resizing of array is done in ovm_field_array* macro*/
           for(i__=0; i__ < ARG.size(); ++i__)
             ARG[i__] = local_data__.ARG[i__] ;
         end
       OVM_PRINT:
         begin
           if((FLAG)&OVM_NOPRINT != 0 &&
                          ovm_auto_options_object.printer.knobs.print_fields == 1)
             ovm_print_array_string2(ARG, ovm_auto_options_object.printer)
         end
       OVM_RECORD:
         begin
           if(((FLAG)&OVM_NORECORD) == 0 && !m_sc.array_warning_done) begin
             m_ovm_record_array_string(ARG, ovm_auto_options_object.recorder)
           end
         end
     endcase
   end
   end

`define M_OVM_FIELD_DATA_EVENT ( ARG, FLAG )

begin
    if(what__ == OVM_PRINT && ( (FLAG)&OVM_NOPRINT != 0) &&
                          ovm_auto_options_object.printer.knobs.print_fields == 1)
       ovm_auto_options_object.printer.print_generic(`"ARG`", "event", -1, "-");
    else if((what__ == OVM_COMPARE) && ( (FLAG)&OVM_NOCOMPARE != 0) &&
            local_data__ && ARG != local_data__.ARG)
    begin
      ovm_auto_options_object.comparer.print_msg("");
    end
    else if((what__ == OVM_COPY) && local_data__ && ( (FLAG)&OVM_NOCOPY != 0 ) )
    begin
      ARG = local_data__.ARG;
    end
  end

`define M_OVM_FIELD_DATA_OBJECT ( ARG, FLAG )

begin
    int r__;
    ovm_object lhs__, rhs__;
    r__ = 0;
    if(ARG == null)
      lhs__ = null;
    else if(!$cast(lhs__,ARG)) begin
      ovm_object::m_sc.scratch1 =
        `"Cast failed for ARG to ovm_object type (ovm_field_object not implemented)`";
      _global_reporter.ovm_report_warning("CSTFLD",ovm_object::m_sc.scratch1, OVM_NONE);
    end
    if(tmp_data__ != null) begin
      if($cast(local_data__, tmp_data__)) begin
        r__ = m_do_data_object(`"ARG`", lhs__, local_data__.ARG, what__, FLAG);
      end
      else if(tmp_data__!=null) begin
        ovm_object::m_sc.scratch1 = `"Type check failed for ARG for copy/compare`";
        _global_reporter.ovm_report_error("TCKFLD", ovm_object::m_sc.scratch1, OVM_NONE);
      end
    end
    else begin
      r__ = m_do_data_object(`"ARG`", lhs__, null, what__, FLAG);
      if (what__ == OVM_UNPACK) begin
        m_sc.scope.up(ARG);
        if (lhs__ == null) ARG = null;
        else if (!$cast(ARG,lhs__)) ARG = null;
        m_sc.scope.down(`"ARG`",ARG);
      end
    end
    /* if return is 1 then upack of the object failed, don't want to continue. */
    if(r__ == 1 && what__ == OVM_UNPACK)
       return;
    if((what__ == OVM_COPY) && (ovm_recursion_policy_enum'(r__) == OVM_SHALLOW)) begin
      ovm_object v__;
      m_sc.scope.up(ARG);
      v__ = ovm_global_copy_map.get(local_data__.ARG);
      if(v__ != null) begin
        $cast(ARG, v__);
      end
      else begin
        /* Can't do shallow copy right now due to */
        /* an issue with abstract classes */
        /* like ovm_object, so do a deep copy instead. */
        if(local_data__.ARG==null) ARG = null;
        else if(ARG!=null) ARG.copy(local_data__.ARG);
        else begin
          ovm_object cobj;
          cobj = local_data__.ARG.clone();
          if(cobj == null) ARG = null;
          else begin
            $cast(ARG, local_data__.ARG.clone());
            ARG.set_name(`"ARG`");
          end
        end
      end
      m_sc.scope.down(`"ARG`",ARG);
    end
    else if((what__ == OVM_COPY) && (ovm_recursion_policy_enum'(r__) == OVM_REFERENCE)) begin
      m_sc.scope.up(ARG);
      if((lhs__ == null)&&(local_data__.ARG != null)) begin
        if(!$cast(ARG,local_data__.ARG)) begin
          ovm_object::m_sc.scratch1 = `"Copy cast failed for ARG`";
          _global_reporter.ovm_report_error("CSTFLD",ovm_object::m_sc.scratch1, OVM_NONE);
        end
      end
      else if(lhs__==null)
        ARG = null;
      else
        $cast(ARG, lhs__);
      m_sc.scope.down(`"ARG`",ARG);
    end
  end

`define M_OVM_FIELD_DATA_QUEUE_REAL ( ARG, FLAG )

`define M_OVM_FIELD_DATA_SARRAY ( ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      if(what__ == OVM_PRINT && ((FLAG)&OVM_NOPRINT) == 0)
        ovm_print_sarray_int3(ARG, ovm_radix_enum'((FLAG)&(OVM_RADIX)),
                                   ovm_auto_options_object.printer)
      else if(tmp_data__!=null) begin
        foreach(ARG[i__])
          if($cast(local_data__, tmp_data__)) begin
            void'(m_do_data($psprintf(`"ARG[%0d]`",i__), ARG[i__], local_data__.ARG[i__], what__, $bits(ARG[i__]), FLAG));
          end
      end
      else begin
        foreach(ARG[i__])
          if($cast(local_data__, tmp_data__)) begin
            void'(m_do_data($psprintf(`"ARG[%0d]`",i__), ARG[i__], 0, what__, $bits(ARG[i__]), FLAG));
          end
      end
    end
  end

`define M_OVM_FIELD_DATA_SARRAY_OBJECT ( ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      ovm_object lhs__;
      if(what__ == OVM_PRINT && ((FLAG)&OVM_NOPRINT) == 0)
        ovm_print_sarray_object3(ARG, ovm_auto_options_object.printer, FLAG)
      else if((what__ == OVM_COPY) && ((FLAG)&OVM_NOCOPY)==0) begin
        $cast(local_data__, tmp_data__);
        foreach(ARG[i__]) begin
          if(local_data__.ARG[i__] == null || (((FLAG)&OVM_REFERENCE) != 0))
            ARG[i__] = local_data__.ARG[i__];
          else if(((FLAG)&OVM_SHALLOW) != 0)
            ARG[i__] = new local_data__.ARG[i__];
          else if(ARG[i__] != null)
            ARG[i__].copy(local_data__.ARG[i__]);
          else
            $cast(ARG[i__],local_data__.ARG[i__].clone());
        end
      end
      else if((what__ != OVM_COPY) && (tmp_data__!=null)) begin
        $cast(local_data__, tmp_data__);
        foreach(ARG[i__]) begin
          lhs__ = ARG[i__];
          if($cast(local_data__, tmp_data__))
            void'(m_do_data_object($psprintf(`"ARG[%0d]`",i__), lhs__, local_data__.ARG[i__], what__, FLAG));
          else
            void'(m_do_data_object($psprintf(`"ARG[%0d]`",i__), lhs__, null, what__, FLAG));
        end
      end
      else if (what__ != OVM_COPY) begin
        foreach(ARG[i__]) begin
          lhs__ = ARG[i__];
          void'(m_do_data_object($psprintf(`"ARG[%0d]`",i__), lhs__, null, what__, FLAG));
        end
      end
    end
  end

`define M_OVM_FIELD_DATA_SARRAY_REAL ( ARG, FLAG )

begin
   if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
     case (what__)
       OVM_COMPARE:
         if ( !((FLAG)&OVM_NOCOMPARE) && (tmp_data__ != null) ) begin
           int i__;
           $cast(local_data__, tmp_data__);
           for(i__=0; i__<$size(ARG) && i__<$size(local_data__.ARG); ++i__)
             if(ARG[i__] != local_data__.ARG[i__]) begin
               real ls__, rs__;
               ls__ = ARG[i__]; rs__ = local_data__.ARG[i__];
               ovm_auto_options_object.comparer.scope.down_element(i__, null);
               $swrite(m_sc.stringv, "lhs = %0f : rhs = %0f", ls__, rs__);
               ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
               ovm_auto_options_object.comparer.scope.up_element(null);
             end
         end
       OVM_COPY:
         if(!((FLAG)&OVM_NOCOPY) && (tmp_data__ != null) )
          begin
           int i__;
           $cast(local_data__, tmp_data__);
           /*Resizing of array is done in ovm_field_array* macro*/
           for(i__=0; i__ < $size(ARG); ++i__)
             ARG[i__] = local_data__.ARG[i__] ;
         end
       OVM_PRINT:
         begin
           if((FLAG)&OVM_NOPRINT != 0 &&
                          ovm_auto_options_object.printer.knobs.print_fields == 1)
             ovm_print_array_real2(ARG, ovm_auto_options_object.printer)
         end
       OVM_RECORD:
         begin
           if(((FLAG)&OVM_NORECORD) == 0 && !m_sc.array_warning_done) begin
             m_ovm_record_sarray_real(ARG, ovm_auto_options_object.recorder)
           end
         end
     endcase
   end
   end

`define M_OVM_FIELD_DATA_SARRAY_STRING ( ARG, FLAG )

begin
    if((what__ & (FLAG)) || (what__ >= OVM_MACRO_EXTRAS)) begin
      if(what__ == OVM_PRINT && ((FLAG)&OVM_NOPRINT) == 0)
        ovm_print_sarray_string2(ARG, ovm_auto_options_object.printer)
      else if(tmp_data__!=null) begin
        foreach(ARG[i__])
          if($cast(local_data__, tmp_data__)) begin
            void'(m_do_data_string($psprintf(`"ARG[%0d]`",i__), ARG[i__], local_data__.ARG[i__], what__, FLAG));
          end
      end
      else begin
        foreach(ARG[i__])
          if($cast(local_data__, tmp_data__)) begin
            void'(m_do_data_string($psprintf(`"ARG[%0d]`",i__), ARG[i__], "", what__, FLAG));
          end
      end
    end
  end

`define M_OVM_FIELD_DATA_STRING ( ARG, FLAG )

begin
    int r__;
    if(local_data__ != null) begin
      if($cast(local_data__, tmp_data__)) begin
        r__ = m_do_data_string(`"ARG`", ARG, local_data__.ARG, what__, FLAG);
      end
    end
    else
      r__ = m_do_data_string(`"ARG`", ARG, "", what__, FLAG);
  end

`define M_OVM_FIELD_ENUM ( T, ARG, FLAG )

begin
    T lh__=ARG, rh__;
    if((what__ == OVM_PRINT) && (((FLAG)&OVM_NOPRINT) == 0) &&
        (ovm_auto_options_object.printer.knobs.print_fields == 1)) begin
      ovm_auto_options_object.printer.print_generic(`"ARG`", `"T`",
          $bits(ARG), lh__.name());
    end
    else if((what__ == OVM_RECORD) && (((FLAG)&OVM_NORECORD) == 0))
    begin
      ovm_auto_options_object.recorder.record_string(`"ARG`",lh__.name());
    end
    else if(tmp_data__!=null) begin
      if($cast(local_data__, tmp_data__)) begin
        case(what__)
          OVM_COPY:
            if(((FLAG)&OVM_NOCOPY) == 0)
               ARG = local_data__.ARG;
          OVM_COMPARE:
            if((((FLAG)&OVM_NOCOMPARE) == 0) && (ARG != local_data__.ARG)) begin
               rh__ = local_data__.ARG;
               ovm_auto_options_object.comparer.print_msg({"lhs = ", lh__.name(), " : rhs = ", rh__.name()});
            end
        endcase
      end
    end
    else begin
      case(what__)
        OVM_PACK:
          if(((FLAG)&OVM_NOPACK) == 0)
            if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
                (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
              ovm_auto_options_object.packer.pack_field_int(int'(ARG), $bits(ARG));
            end
        OVM_UNPACK:
          begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical))
            if(((FLAG)&OVM_NOPACK) == 0) begin
              ARG = T'(ovm_auto_options_object.packer.unpack_field_int($bits(ARG)));
            end
          end
        OVM_SETINT:
          begin
            if(ovm_is_match(str__ ,m_sc.scope.get_arg()) && (((FLAG)&OVM_READONLY) == 0)) begin
               print_field_match("set_int()", str__);
               ARG = T'(ovm_object::m_sc.bitstream);
               ovm_object::m_sc.status = 1;
            end
          end
      endcase
    end
  end

`define M_OVM_FIELD_QUEUE_INT_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i])
              ovm_auto_options_object.packer.pack_field(ARG[i], $bits(ARG[i]));
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              while(ARG.size() < s_) ARG.push_back(0);
              while(ARG.size() > s_) void'(ARG.pop_front());
            end
            foreach(ARG[i])
              ARG[i] = ovm_auto_options_object.packer.unpack_field($bits(ARG[i]));
          end
        end
  endcase

`define M_OVM_FIELD_QUEUE_OBJ_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i]) begin
              ovm_auto_options_object.packer.pack_object(ARG[i]);
            end
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              if(ARG.size() < s_)
                _global_reporter.ovm_report_error("OBJUPK", $psprintf(`"Queue ARG cannot support the unpack operation, the unpack requires %0d elements, ARG has only %0d`", s_, ARG.size()), OVM_NONE);
            end
            foreach(ARG[i]) begin
              ovm_auto_options_object.packer.unpack_object(ARG[i]);
              if(ovm_auto_options_object.packer.use_metadata == 0 && ARG[i] == null)
                return;
            end
          end
        end
  endcase

`define M_OVM_FIELD_QUEUE_REAL_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i])
              ovm_auto_options_object.packer.pack_real(ARG[i]);
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              /* ARG = new[s_]; */
            end
            foreach(ARG[i])
              ARG[i] = ovm_auto_options_object.packer.unpack_real();
          end
        end
  endcase

`define M_OVM_FIELD_QUEUE_STR_PACK ( ARG, FLAG )

case(what__)
      OVM_PACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata == 1)
              ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
            foreach(ARG[i])
              ovm_auto_options_object.packer.pack_string(ARG[i]);
          end
        end
      OVM_UNPACK:
        if(((FLAG)&OVM_NOPACK) == 0)
        begin
          if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
              (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
            if(ovm_auto_options_object.packer.use_metadata) begin
              int s_;
              s_ = ovm_auto_options_object.packer.unpack_field_int(32);
              while(ARG.size() < s_) ARG.push_back("");
              while(ARG.size() > s_) void'(ARG.pop_front());
            end
            foreach(ARG[i]) begin
              ARG[i] = ovm_auto_options_object.packer.unpack_string(-1);
            end
          end
        end
  endcase

`define M_OVM_FIELD_SARRAY_REAL_PACK ( ARG, FLAG )

`define M_OVM_FIELD_SET ( ARG, FLAG )

void'(ovm_object::m_do_set (str__, `"ARG`", ARG, what__, FLAG));

`define M_OVM_FIELD_SET_AA_INT_ENUMTYPE ( INDEX_TYPE, ARRAY_TYPE, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    INDEX_TYPE index__;
    string idx__;
    index__ = INDEX_TYPE'(ovm_get_array_index_int(str__, wildcard_index__));
    if(what__==OVM_SET``ARRAY_TYPE)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          if(ARRAY.first(index__))
          do begin
            $swrite(idx__, m_sc.scope.get_arg(), "[", index__, "]");
            if(ovm_is_match(str__, idx__)) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end while(ARRAY.next(index__));
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_AA_INT_TYPE ( INDEX_TYPE, ARRAY_TYPE, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    INDEX_TYPE index__;
    string idx__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SET``ARRAY_TYPE)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          if(ARRAY.first(index__))
          do begin
            $swrite(idx__, m_sc.scope.get_arg(), "[", index__, "]");
            if(ovm_is_match(str__, idx__)) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end while(ARRAY.next(index__));
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_AA_OBJECT_TYPE ( INDEX_TYPE, ARRAY, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    INDEX_TYPE index__;
    index__ = ovm_get_array_index_``INDEX_TYPE(str__, wildcard_index__);
    if(what__==OVM_SETOBJ)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          if(ARRAY.first(index__))
          do begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)}) ||
               ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0s]", index__)})) begin
              if (m_sc.object != null)
                $cast(ARRAY[index__], m_sc.object);
              m_sc.status = 1;
            end
          end while(ARRAY.next(index__));
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          if (m_sc.object != null)
            $cast(ARRAY[index__], m_sc.object);
          m_sc.status = 1;
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0s]", index__)})) begin
          if (m_sc.object != null)
            $cast(ARRAY[index__], m_sc.object);
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_AA_TYPE ( INDEX_TYPE, ARRAY_TYPE, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    INDEX_TYPE index__;
    index__ = ovm_get_array_index_``INDEX_TYPE(str__, wildcard_index__);
    if(what__==OVM_SET``ARRAY_TYPE)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          if(ARRAY.first(index__))
          do begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)}) ||
               ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0s]", index__)})) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end while(ARRAY.next(index__));
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0s]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_ARRAY_ENUM ( T, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETINT)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          for(int index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              ARRAY[index__] = T'(RHS);
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = T'(RHS);
          m_sc.status = 1;
        end
        else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
          int size__;
          size__ = m_sc.bitstream;
          ARRAY = new[size__](ARRAY);
          m_sc.status = 1;
        end
      end
      else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
        int size__;
        size__ = m_sc.bitstream;
        ARRAY = new[size__](ARRAY);
        m_sc.status = 1;
      end
    end
    else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
     int size__;
     size__ = m_sc.bitstream;
     ARRAY = new[size__](ARRAY);
     m_sc.status = 1;
    end
end

`define M_OVM_FIELD_SET_ARRAY_OBJECT ( ARG, FLAG )

M_OVM_FIELD_SET_ARRAY_OBJECT_TYPE(ARG, FLAG)
  if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    ovm_object obj__;
    for(int index__=0; index__<ARG.size(); ++index__) begin
       if($cast(obj__,ARG[index__]) && (obj__!=null))
          obj__.m_field_automation(null, what__, str__);
    end
  end

`define M_OVM_FIELD_SET_ARRAY_OBJECT_TYPE ( ARRAY, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETOBJ)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          for(int index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              if (m_sc.object != null) begin
                $cast(ARRAY[index__], m_sc.object);
              end
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          if (m_sc.object != null) begin
            $cast(ARRAY[index__], m_sc.object);
          end
          m_sc.status = 1;
        end
      end
    end
    else if(what__==OVM_SET && !ovm_is_array(str__) && ovm_is_match(str__, m_sc.scope.get_arg())) begin
     int size__;
     size__ = m_sc.bitstream;
     ARRAY = new[size__](ARRAY);
     m_sc.status = 1;
    end
end

`define M_OVM_FIELD_SET_ARRAY_REAL ( ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETINT)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          for(int index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$sformatf("[%0d]", index__)})) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$sformatf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
        else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
          int size__;
          size__ = m_sc.bitstream;
          ARRAY = new[size__](ARRAY);
          m_sc.status = 1;
        end
      end
      else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
        int size__;
        size__ = m_sc.bitstream;
        ARRAY = new[size__](ARRAY);
        m_sc.status = 1;
      end
    end
    else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
     int size__;
     size__ = m_sc.bitstream;
     ARRAY = new[size__](ARRAY);
     m_sc.status = 1;
    end
end

`define M_OVM_FIELD_SET_ARRAY_TYPE ( ARRAY_TYPE, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SET``ARRAY_TYPE)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          for(int index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
        else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
          int size__;
          size__ = m_sc.bitstream;
          ARRAY = new[size__](ARRAY);
          m_sc.status = 1;
        end
      end
      else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
        int size__;
        size__ = m_sc.bitstream;
        ARRAY = new[size__](ARRAY);
        m_sc.status = 1;
      end
    end
    else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
     int size__;
     size__ = m_sc.bitstream;
     ARRAY = new[size__](ARRAY);
     m_sc.status = 1;
    end
end

`define M_OVM_FIELD_SET_EVENT ( ARG, FLAG )

/*Not implemented*/

`define M_OVM_FIELD_SET_OBJECT ( ARG, FLAG )

begin
    ovm_object arg_obj__;
    int r__; /*return 1 if get succeeds*/
    if(ARG != null) $cast(arg_obj__, ARG);
    r__ = ovm_object::m_do_set_object(str__, `"ARG`",
        arg_obj__, what__, FLAG);
    /*in case of a set, cast back */
    if(r__ && (what__ == OVM_SETOBJ) && (arg_obj__ != null))
      $cast(ARG, arg_obj__);
    else if(arg_obj__ == null)
      ARG = null;
  end

`define M_OVM_FIELD_SET_QUEUE_ENUM ( T, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    int index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETINT)
    begin
      if(ovm_is_array(str__) && (index__ != -1)) begin
        if(wildcard_index__) begin
          for(index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              ARRAY[index__] = T'(RHS);
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = T'(RHS);
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_QUEUE_OBJECT ( ARG, FLAG )

M_OVM_FIELD_SET_QUEUE_OBJECT_TYPE(ARG, FLAG)
  if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    ovm_object obj__;
    for(int index__=0; index__<ARG.size(); ++index__) begin
       if($cast(obj__,ARG[index__]) && (obj__!=null))
          obj__.m_field_automation(null, what__, str__);
    end
  end

`define M_OVM_FIELD_SET_QUEUE_OBJECT_TYPE ( ARRAY, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    int index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETOBJ)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          for(index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              if (m_sc.object != null)
                $cast(ARRAY[index__], m_sc.object);
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          if (m_sc.object != null)
            $cast(ARRAY[index__], m_sc.object);
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_QUEUE_REAL ( ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETINT)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          foreach(ARRAY[index__]) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$sformatf("[%0d]", index__)})) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$sformatf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
        else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
          /* TODO: Do we need this block. */
          m_sc.status = 1;
        end
      end
      else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
        /* TODO: Do we need this block. */
        m_sc.status = 1;
      end
    end
    else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
     /* TODO: Do we need this block. */
     m_sc.status = 1;
    end
end

`define M_OVM_FIELD_SET_QUEUE_TYPE ( ATYPE, ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    bit wildcard_index__;
    int index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SET``ATYPE)
    begin
      if(ovm_is_array(str__) && (index__ != -1)) begin
        if(wildcard_index__) begin
          for(index__=0; index__<ARRAY.size(); ++index__) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
      end
    end
end

`define M_OVM_FIELD_SET_SARRAY_ENUM ( T, ARRAY, RHS, FLAG )

`define M_OVM_FIELD_SET_SARRAY_OBJECT ( ARG, FLAG )

M_OVM_FIELD_SET_SARRAY_OBJECT_TYPE(ARG, FLAG)
  if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    ovm_object obj__;
    foreach(ARG[index__]) begin
       if($cast(obj__,ARG[index__]) && (obj__!=null))
          obj__.m_field_automation(null, what__, str__);
    end
  end

`define M_OVM_FIELD_SET_SARRAY_OBJECT_TYPE ( ARRAY, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETOBJ)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          foreach(ARRAY[index__]) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
              if (m_sc.object != null) begin
                $cast(ARRAY[index__], m_sc.object);
              end
              else
                ARRAY[index__] = null;
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$psprintf("[%0d]", index__)})) begin
          if (m_sc.object != null) begin
            $cast(ARRAY[index__], m_sc.object);
          end
          else
            ARRAY[index__] = null;
          m_sc.status = 1;
        end
      end
    end
  end

`define M_OVM_FIELD_SET_SARRAY_REAL ( ARRAY, RHS, FLAG )

if((what__ >= OVM_START_FUNCS && what__ <= OVM_END_FUNCS) && (((FLAG)&OVM_READONLY) == 0)) begin
    int index__;
    bit wildcard_index__;
    index__ = ovm_get_array_index_int(str__, wildcard_index__);
    if(what__==OVM_SETINT)
    begin
      if(ovm_is_array(str__) ) begin
        if(wildcard_index__) begin
          foreach(ARRAY[index__]) begin
            if(ovm_is_match(str__, {m_sc.scope.get_arg(),$sformatf("[%0d]", index__)})) begin
              ARRAY[index__] = RHS;
              m_sc.status = 1;
            end
          end
        end
        else if(ovm_is_match(str__, {m_sc.scope.get_arg(),$sformatf("[%0d]", index__)})) begin
          ARRAY[index__] = RHS;
          m_sc.status = 1;
        end
        else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
          /* TODO: Do we need this block. */
          m_sc.status = 1;
        end
      end
      else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
        /* TODO: Do we need this block. */
        m_sc.status = 1;
      end
    end
    else if(what__==OVM_SET && ovm_is_match(str__, m_sc.scope.get_arg())) begin
     /* TODO: Do we need this block. */
     m_sc.status = 1;
    end
end

`define M_OVM_FIELD_SET_SARRAY_TYPE ( ARRAY_TYPE, ARRAY, RHS, FLAG )

`define M_OVM_FIELD_SET_STRING ( ARG, FLAG )

void'(ovm_object::m_do_set_string (str__, `"ARG`", ARG, what__, FLAG));

`define m_ovm_record_any_object ( ARG )

`define m_ovm_record_array_int ( ARG, RADIX, RECORDER )

begin
    if(RECORDER.tr_handle != 0) begin
      if(RADIX == OVM_ENUM) begin
        if(!m_sc.array_warning_done) begin
           m_sc.array_warning_done = 1;
           ovm_object::m_sc.scratch1 =
             `"Recording not supported for array enumerations: ARG`";
           _global_reporter.ovm_report_warning("RCDNTS", ovm_object::m_sc.scratch1, OVM_NONE);
        end
      end
      else begin
        for(int i__=0; i__<ARG.size(); ++i__)
          RECORDER.record_field($psprintf(`"ARG[%0d]`",i__), ARG[i__], $bits(ARG[i__]), ovm_radix_enum'(RADIX));
      end
    end
  end

`define m_ovm_record_array_object ( ARG, RECORDER )

begin
    if(RECORDER.tr_handle != 0) begin
      ovm_object obj__;
      for(int i__=0; i__<ARG.size(); ++i__) begin
        if($cast(obj__, ARG[i__]))
          if(obj__ != null) begin
            m_sc.scope.down_element(i__, null);
            obj__.m_field_automation(null, what__, str__);
            m_sc.scope.up_element(null);
          end
      end
    end
  end

`define m_ovm_record_array_real ( ARG, RECORDER )

begin
    if(RECORDER.tr_handle != 0) begin
      for(int i__=0; i__<ARG.size(); ++i__)
        RECORDER.record_field_real($sformatf(`"ARG[%0d]`", i__), ARG[i__]);
    end
  end

`define m_ovm_record_array_string ( ARG, RECORDER )

begin
    if(RECORDER.tr_handle != 0) begin
      for(int i__=0; i__<ARG.size(); ++i__)
        RECORDER.record_string($psprintf(`"ARG[%0d]`", i__), ARG[i__]);
    end
  end

`define m_ovm_record_int ( ARG, FLAG )

begin
    int radix__;
    ovm_bitstream_t value;
    value = ARG;
    radix__ = ovm_radix_enum'((FLAG)&(OVM_RADIX));
    if(recorder==null)
      recorder=ovm_auto_options_object.recorder;
    recorder.record_field(`"ARG`", ARG, radix__, $bits(ARG);
  end

`define m_ovm_record_object ( ARG, FLAG )

begin
     ovm_object v__;
     if(ARG != null) begin
       if($cast(v__,ARG)) begin
         ovm_record_object__(`"ARG`", v__, recorder);
       end
     end
     else begin
       m_ovm_record_any_object(ARG);
     end
  end

`define m_ovm_record_qda_enum ( T, ARG, RECORDER )

begin
    if(RECORDER.tr_handle != 0) begin
      foreach(ARG[i__]) begin
        T lh__=ARG[i__];
        RECORDER.record_string($psprintf(`"ARG[%0d]`",i__), lh__.name());
      end
    end
  end

`define m_ovm_record_sarray_real ( ARG, RECORDER )

begin
    if(RECORDER.tr_handle != 0) begin
      foreach(ARG[i__])
        RECORDER.record_field_real($sformatf(`"ARG[%0d]`", i__), ARG[i__]);
    end
  end

`define m_ovm_record_string ( ARG )

recorder.record_string(`"ARG`", ARG);

`define M_RESIZE_QUEUE_COPY ( T, ARG, SIZE )

begin
     T tmp__;
     while(ARG.size()>SIZE) void'(ARG.pop_back());
     while(ARG.size() != SIZE) ARG.push_back(tmp__);
   end

`define M_RESIZE_QUEUE_NOCOPY ( T, ARG, SIZE )

begin
     T tmp__;
     while(ARG.size()) void'(ARG.pop_front());
     while(ARG.size() != SIZE) ARG.push_back(tmp__);
   end

`define M_RESIZE_QUEUE_OBJECT_COPY ( ARG, SIZE )

begin
     while(ARG.size()>SIZE) void'(ARG.pop_front());
     while(ARG.size() != SIZE) ARG.push_back(null);
   end

`define M_RESIZE_QUEUE_OBJECT_NOCOPY ( ARG, SIZE )

begin
     while(ARG.size()>SIZE) void'(ARG.pop_front());
     while(ARG.size() != SIZE) ARG.push_back(null);
   end

`define MESSAGE ( VERBOSITY, MESSAGE )

do urm_pkg_msg_imp("DEBUG",MESSAGE,ovm_pkg::OVM_URM_MSG_DEBUG,ovm_pkg::OVM_INFO,VERBOSITY,"",ovm_global_reporter)
while (0)

`define message ( VERBOSITY, MESSAGE )

urm_msg_imp("DEBUG",MESSAGE,OVM_URM_MSG_DEBUG,OVM_INFO,VERBOSITY,get_full_name(),m_get_report_object())

`define NONBLOCKING_GET_IMP ( imp, TYPE, arg )

function bit try_get (output TYPE arg);
    return imp.try_get(arg);
  endfunction
  function bit can_get();
    return imp.can_get();
  endfunction

`define NONBLOCKING_GET_IMP_SFX ( SFX, imp, TYPE, arg )

function bit try_get( output TYPE arg);
    if( !imp.try_get``SFX( arg)) return 0;
    return 1;
  endfunction
  function bit can_get(); return imp.can_get``SFX(); endfunction

`define NONBLOCKING_GET_PEEK_IMP ( imp, TYPE, arg )

NONBLOCKING_GET_IMP(imp, TYPE, arg)
NONBLOCKING_PEEK_IMP(imp, TYPE, arg)

`define NONBLOCKING_PEEK_IMP ( imp, TYPE, arg )

function bit try_peek (output TYPE arg);
    return imp.try_peek(arg);
  endfunction
  function bit can_peek();
    return imp.can_peek();
  endfunction

`define NONBLOCKING_PEEK_IMP_SFX ( SFX, imp, TYPE, arg )

function bit try_peek( output TYPE arg);
    if( !imp.try_peek``SFX( arg)) return 0;
    return 1;
  endfunction
  function bit can_peek(); return imp.can_peek``SFX(); endfunction

`define NONBLOCKING_PUT_IMP ( imp, TYPE, arg )

function bit try_put (TYPE arg);
    return imp.try_put(arg);
  endfunction
  function bit can_put();
    return imp.can_put();
  endfunction

`define NONBLOCKING_PUT_IMP_SFX ( SFX, imp, TYPE, arg )

function bit try_put( input TYPE arg);
    if( !imp.try_put``SFX( arg)) return 0;
    return 1;
  endfunction
  function bit can_put(); return imp.can_put``SFX(); endfunction

`define NONBLOCKING_TRANSPORT_IMP ( imp, REQ, RSP, req_arg, rsp_arg )

function bit nb_transport (REQ req_arg, output RSP rsp_arg);
return imp.nb_transport(req_arg, rsp_arg);
endfunction

`define NONBLOCKING_TRANSPORT_IMP_SFX ( SFX, imp, REQ, RSP, req_arg, rsp_arg )

function bit nb_transport( input REQ req_arg, output RSP rsp_arg);
if(imp) return imp.nb_transport``SFX(req_arg, rsp_arg);
endfunction

`define OVM_AGENT_SVH

`define ovm_analysis_imp_decl ( SFX )

class ovm_analysis_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_ANALYSIS_MASK,`"ovm_analysis_imp``SFX`",IMP)
  function void write( input T t);
    m_imp.write``SFX( t);
  endfunction

endclass

`define OVM_BASE_SVH

`define ovm_blocking_get_imp_decl ( SFX )

class ovm_blocking_get_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_BLOCKING_GET_MASK,`"ovm_blocking_get_imp``SFX`",IMP)
  BLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_blocking_get_peek_imp_decl ( SFX )

class ovm_blocking_get_peek_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_BLOCKING_GET_PEEK_MASK,`"ovm_blocking_get_peek_imp``SFX`",IMP)
  BLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
  BLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_blocking_master_imp_decl ( SFX )

class ovm_blocking_master_imp``SFX #(type REQ=int, type RSP=int, type IMP=int,
                                     type REQ_IMP=IMP, type RSP_IMP=IMP)
  extends ovm_port_base #(tlm_if_base #(REQ, RSP));
  typedef IMP this_imp_type;
  typedef REQ_IMP this_req_type;
  typedef RSP_IMP this_rsp_type;
  OVM_MS_IMP_COMMON(TLM_BLOCKING_MASTER_MASK,`"ovm_blocking_master_imp``SFX`")

  BLOCKING_PUT_IMP_SFX(SFX, m_req_imp, REQ, t)
  BLOCKING_GET_IMP_SFX(SFX, m_rsp_imp, RSP, t) BLOCKING_PEEK_IMP_SFX(SFX, m_rsp_imp, RSP, t)
endclass

`define ovm_blocking_peek_imp_decl ( SFX )

class ovm_blocking_peek_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_BLOCKING_PEEK_MASK,`"ovm_blocking_peek_imp``SFX`",IMP)
  BLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_blocking_put_imp_decl ( SFX )

class ovm_blocking_put_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_BLOCKING_PUT_MASK,`"ovm_blocking_put_imp``SFX`",IMP)
  BLOCKING_PUT_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_blocking_slave_imp_decl ( SFX )

class ovm_blocking_slave_imp``SFX #(type REQ=int, type RSP=int, type IMP=int,
                                    type REQ_IMP=IMP, type RSP_IMP=IMP)
  extends ovm_port_base #(tlm_if_base #(RSP, REQ));
  typedef IMP this_imp_type;
  typedef REQ_IMP this_req_type;
  typedef RSP_IMP this_rsp_type;
  OVM_MS_IMP_COMMON(TLM_BLOCKING_SLAVE_MASK,`"ovm_blocking_slave_imp``SFX`")

  BLOCKING_PUT_IMP_SFX(SFX, m_rsp_imp, RSP, t)
  BLOCKING_GET_IMP_SFX(SFX, m_req_imp, REQ, t) BLOCKING_PEEK_IMP_SFX(SFX, m_req_imp, REQ, t)
endclass

`define ovm_blocking_transport_imp_decl ( SFX )

class ovm_blocking_transport_imp``SFX #(type REQ=int, type RSP=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(REQ, RSP));
  OVM_IMP_COMMON(TLM_BLOCKING_TRANSPORT_MASK,`"ovm_blocking_transport_imp``SFX`",IMP)
  BLOCKING_TRANSPORT_IMP_SFX(SFX, m_imp, REQ, RSP, req, rsp)
endclass

`define OVM_CALLBACK_SVH

`define OVM_CB_MACROS_SVH

`define ovm_cb_trace ( OBJ, CB, OPER )

/* null */

`define ovm_cb_trace_noobj ( CB, OPER )

/* null */

`define ovm_clear_queue ( Q )

Q = '{};

`define OVM_COMPARE_FAILED ( ARG )

begin
  ovm_object::m_sc.scratch1 = `"Compare failed ARG`";
   ovm_auto_options_object.comparer.result++;
   if(ovm_auto_options_object.comparer.result <=
      ovm_auto_options_object.comparer.show_max)
   begin
     ovm_object::m_sc.scratch1 = `"Miscompare for field ARG`";
     _global_reporter.ovm_report_info("MISCMP", ovm_object::m_sc.scratch1, OVM_MEDIUM)
   end
end

`define ovm_component_factory_create_func ( T )

function ovm_component create_component (string name, ovm_component parent);
     T tmp;
     tmp = new(.name(name), .parent(parent));
     return tmp;
   endfunction

   static function T create(string name, ovm_component parent, string contxt="");
     ovm_factory f;
     f = ovm_factory::get();
     if (contxt == "" && parent != null)
       contxt = parent.get_full_name();
     if(!$cast(create,f.create_component_by_type(get(),contxt,name,parent)))
        ovm_top.ovm_report_fatal("FACTFL", {"Factory did not return a component of type, ",type_name}, OVM_NONE);
   endfunction

`define ovm_component_new_func

ovm_new_func

`define ovm_component_param_utils ( T )

ovm_component_registry_param(T)

`define ovm_component_param_utils_begin ( T )

ovm_component_registry_param(T)
ovm_field_utils_begin(T)

`define ovm_component_registry ( T, S )

typedef ovm_component_registry #(T,S) type_id;
   static function type_id get_type();
     return type_id::get();
   endfunction
   virtual function ovm_object_wrapper get_object_type();
     return type_id::get();
   endfunction

`define ovm_component_registry_internal ( T, S )

typedef ovm_component_registry #(T,`"S`") type_id;
   static function type_id get_type();
     return type_id::get();
   endfunction
   virtual function ovm_object_wrapper get_object_type();
     return type_id::get();
   endfunction

`define ovm_component_registry_param ( T )

typedef ovm_component_registry #(T) type_id;
   static function type_id get_type();
     return type_id::get();
   endfunction
   virtual function ovm_object_wrapper get_object_type();
     return type_id::get();
   endfunction

`define OVM_COMPONENT_SVH

`define ovm_component_utils ( T )

ovm_component_registry_internal(T,T)
ovm_get_type_name_func(T)

`define ovm_component_utils_begin ( T )

ovm_component_registry_internal(T,T)
ovm_get_type_name_func(T)
ovm_field_utils_begin(T)

`define ovm_component_utils_end

end
endfunction

`define OVM_CONFIG_SVH

`define ovm_create ( OVM_SEQUENCE_ITEM )

begin
  ovm_object_wrapper w_; w_ = OVM_SEQUENCE_ITEM.get_type();
  $cast(OVM_SEQUENCE_ITEM , create_item(w_, m_sequencer, `"OVM_SEQUENCE_ITEM`"));
  end

`define ovm_create_on ( OVM_SEQUENCE_ITEM, SEQUENCER_REF )

begin
  ovm_object_wrapper w_; w_ = OVM_SEQUENCE_ITEM.get_type();
  $cast(OVM_SEQUENCE_ITEM , create_item(w_, SEQUENCER_REF, `"OVM_SEQUENCE_ITEM`"));
  end

`define ovm_create_seq ( OVM_SEQ, SEQR_CONS_IF )

begin
ovm_create_on(OVM_SEQ, SEQR_CONS_IF.consumer_seqr)
end

`define ovm_declare_p_sequencer ( SEQUENCER )

SEQUENCER p_sequencer;
  virtual function void m_set_p_sequencer();
    super.m_set_p_sequencer();
    if( !$cast(p_sequencer, m_sequencer))
        ovm_report_fatal("DCLPSQ",
        $psprintf("%m %s Error casting p_sequencer, please verify that this sequence/sequence item is intended to execute on this type of sequencer", get_full_name()), OVM_NONE);
  endfunction

`define ovm_declare_sequence_lib

protected bit m_set_sequences_called = 1;
  static protected string m_static_sequences[$];
  static protected string m_static_remove_sequences[$];
  static function bit add_typewide_sequence(string type_name);
    m_static_sequences.push_back(type_name);
    return 1;
  endfunction
  static function bit remove_typewide_sequence(string type_name);
    m_static_remove_sequences.push_back(type_name);
    for (int i = 0; i < m_static_sequences.size(); i++) begin
      if (m_static_sequences[i] == type_name)
        m_static_sequences.delete(i);
    end
    return 1;
  endfunction
  function void ovm_update_sequence_lib();
    if(this.m_set_sequences_called) begin
      set_sequences_queue(m_static_sequences);
      this.m_set_sequences_called = 0;
    end
    for (int i = 0; i < m_static_remove_sequences.size(); i++) begin
      remove_sequence(m_static_remove_sequences[i]);
    end
  endfunction

`define OVM_DEFAULT_TIMEOUT

9200s

`define ovm_do ( OVM_SEQUENCE_ITEM )

begin
  ovm_create(OVM_SEQUENCE_ITEM)
  start_item(OVM_SEQUENCE_ITEM);
  if(!OVM_SEQUENCE_ITEM.randomize()) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do action");
  end
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define ovm_do_callbacks ( CB, T, METHOD_CALL )

ovm_do_obj_callbacks(CB,T,this,METHOD_CALL)

`define ovm_do_callbacks_exit_on ( CB, T, METHOD_CALL, VAL )

ovm_do_obj_callbacks_exit_on(CB,T,this,METHOD_CALL,VAL)

`define ovm_do_obj_callbacks ( CB, T, OBJ, METHOD_CALL )

begin
     ovm_callbacks #(T,CB) cbs = ovm_callbacks #(T,CB)::get_global_cbs();
     ovm_queue #(CB) cbq;
     if (cbs.exists(OBJ)) begin
     /* Make a copy of the queue in case the user tries changing the queue */
     /* inside the callback. For example, for a one-shot callback. */
     cbq = cbs.get(OBJ);
     cbq = new cbq;
     for (int i=0; i        CB cb = cbq.get(i);
       if (cb.is_enabled())
         cb.METHOD_CALL;
     end
     end
   end

`define ovm_do_obj_callbacks_exit_on ( CB, T, OBJ, METHOD_CALL, VAL )

begin
     ovm_callbacks #(T,CB) cbs = ovm_callbacks #(T,CB)::get_global_cbs();
     ovm_queue #(CB) cbq;
     if (cbs == null || !cbs.exists(OBJ))
       return 1-VAL;
     cbq = cbs.get(OBJ);
     cbq = new cbq;
     for (int i=0; i        CB cb = cbq.get(i);
       if (cb.is_enabled() && cb.METHOD_CALL == VAL)
         return VAL;
     end
     return 1-VAL;
   end

`define ovm_do_obj_task_callbacks ( CB, T, OBJ, METHOD_CALL )

begin
     ovm_callbacks #(T,CB) cbs = ovm_callbacks #(T,CB)::get_global_cbs();
     ovm_queue #(CB) cbq;
     cbq = new cbq;
     if (cbs.exists(OBJ)) begin
       cbq = cbs.get(OBJ);
       fork begin
         for (int i=0; i            CB cb = cbq.get(i);
           if (cb.is_enabled()) begin
             fork begin
               ovm_cb_trace(cb,OBJ,`"fork/join_none METHOD_CALL`")
               cb.METHOD_CALL;
             end join_none
           end
         end
         wait fork;
       end join
     end
   end

`define ovm_do_on ( OVM_SEQUENCE_ITEM, SEQUENCER_REF )

begin
  ovm_create_on(OVM_SEQUENCE_ITEM, SEQUENCER_REF)
  start_item(OVM_SEQUENCE_ITEM);
  if (!OVM_SEQUENCE_ITEM.randomize()) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do action");
  end
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define ovm_do_on_pri ( OVM_SEQUENCE_ITEM, SEQUENCER_REF, PRIORITY )

begin
  ovm_create_on(OVM_SEQUENCE_ITEM, SEQUENCER_REF)
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  if (!OVM_SEQUENCE_ITEM.randomize()) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do action");
  end
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define ovm_do_on_pri_with ( OVM_SEQUENCE_ITEM, SEQUENCER_REF, PRIORITY, CONSTRAINTS )

begin
  ovm_create_on(OVM_SEQUENCE_ITEM, SEQUENCER_REF)
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  if (!OVM_SEQUENCE_ITEM.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do_with action");
  end
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define ovm_do_on_with ( OVM_SEQUENCE_ITEM, SEQUENCER_REF, CONSTRAINTS )

begin
  ovm_create_on(OVM_SEQUENCE_ITEM, SEQUENCER_REF)
  start_item(OVM_SEQUENCE_ITEM);
  if (!OVM_SEQUENCE_ITEM.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do_with action");
  end
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define ovm_do_pri ( OVM_SEQUENCE_ITEM, PRIORITY )

begin
  ovm_create(OVM_SEQUENCE_ITEM)
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  if (!OVM_SEQUENCE_ITEM.randomize()) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do action");
  end
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define ovm_do_pri_with ( OVM_SEQUENCE_ITEM, PRIORITY, CONSTRAINTS )

begin
  ovm_create(OVM_SEQUENCE_ITEM)
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  if(!OVM_SEQUENCE_ITEM.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do_with action");
  end
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define ovm_do_seq ( OVM_SEQ, SEQR_CONS_IF )

begin
ovm_do_on(OVM_SEQ, SEQR_CONS_IF.consumer_seqr)
end

`define ovm_do_seq_with ( OVM_SEQ, SEQR_CONS_IF, CONSTRAINTS )

begin
ovm_do_on_with(OVM_SEQ, SEQR_CONS_IF.consumer_seqr, CONSTRAINTS)
end

`define ovm_do_task_callbacks ( CB, T, METHOD_CALL )

ovm_do_obj_task_callbacks(CB,T,this,METHOD_CALL)

`define ovm_do_with ( OVM_SEQUENCE_ITEM, CONSTRAINTS )

begin
  ovm_create(OVM_SEQUENCE_ITEM)
  start_item(OVM_SEQUENCE_ITEM);
  if(!OVM_SEQUENCE_ITEM.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_do_with action");
  end
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define ovm_end_package

endpackage

`define ovm_error ( ID, MSG )

begin
     if (ovm_report_enabled(OVM_NONE,OVM_ERROR,ID))
       ovm_report_error (ID, MSG, OVM_NONE, ovm_file, ovm_line);
   end

`define OVM_EXPORT_COMMON ( MASK, TYPE_NAME )

function new (string name, ovm_component parent,
                int min_size=1, int max_size=1);
    super.new (name, parent, OVM_EXPORT, min_size, max_size);
    m_if_mask = MASK;
  endfunction
  TLM_GET_TYPE_NAME(TYPE_NAME)

`define OVM_EXTERN_REPORT_SERVER_SVH

`define ovm_factory_override_func

`define OVM_FACTORY_SVH

`define ovm_fatal ( ID, MSG )

begin
     if (ovm_report_enabled(OVM_NONE,OVM_FATAL,ID))
       ovm_report_fatal (ID, MSG, OVM_NONE, ovm_file, ovm_line);
   end

`define ovm_field_aa_int_byte ( ARG, FLAG )

ovm_field_aa_int_key(byte, ARG, FLAG)

`define ovm_field_aa_int_byte_unsigned ( ARG, FLAG )

ovm_field_aa_int_key(byte unsigned, ARG, FLAG)

`define ovm_field_aa_int_enumkey ( KEY, ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_AA_enum_key(KEY,ARG,FLAG)
  M_OVM_FIELD_SET_AA_INT_ENUMTYPE(KEY, INT, ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_aa_int_int ( ARG, FLAG )

ovm_field_aa_int_key(int, ARG, FLAG)

`define ovm_field_aa_int_int_unsigned ( ARG, FLAG )

ovm_field_aa_int_key(int unsigned, ARG, FLAG)

`define ovm_field_aa_int_integer ( ARG, FLAG )

ovm_field_aa_int_key(integer, ARG, FLAG)

`define ovm_field_aa_int_integer_unsigned ( ARG, FLAG )

ovm_field_aa_int_key(integer unsigned, ARG, FLAG)

`define ovm_field_aa_int_key ( KEY, ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_AA_int_key(KEY,ARG,FLAG)
  M_OVM_FIELD_SET_AA_INT_TYPE(KEY, INT, ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_aa_int_longint ( ARG, FLAG )

ovm_field_aa_int_key(longint, ARG, FLAG)

`define ovm_field_aa_int_longint_unsigned ( ARG, FLAG )

ovm_field_aa_int_key(longint unsigned, ARG, FLAG)

`define ovm_field_aa_int_shortint ( ARG, FLAG )

ovm_field_aa_int_key(shortint, ARG, FLAG)

`define ovm_field_aa_int_shortint_unsigned ( ARG, FLAG )

ovm_field_aa_int_key(shortint unsigned, ARG, FLAG)

`define ovm_field_aa_int_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_AA_int_string(ARG,FLAG)
  M_OVM_FIELD_SET_AA_TYPE(string, INT, ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_aa_object_int ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_AA_object_int(ARG,FLAG)
  M_OVM_FIELD_SET_AA_OBJECT_TYPE(int, ARG, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_aa_object_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_AA_object_string(ARG,FLAG)
  M_OVM_FIELD_SET_AA_OBJECT_TYPE(string, ARG, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_aa_string_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_AA_string_string(ARG,FLAG)
  M_OVM_FIELD_SET_AA_TYPE(string, STR, ARG, m_sc.stringv, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_array_enum ( T, ARG, FLAG )

begin
    ovm_field_qda_enum(T,ARG,FLAG)
    ovm_unpack_array_enum(T,ARG,FLAG)
    M_OVM_FIELD_SET_ARRAY_ENUM(T, ARG, m_sc.bitstream, FLAG)
  end

`define ovm_field_array_int ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
    if(local_data__!=null) begin
      ARG = new [local_data__.ARG.size()](local_data__.ARG);
    end
    else begin
      ARG.delete();
    end
  end
  M_OVM_FIELD_DATA_ARRAY(ARG,FLAG)
  M_OVM_FIELD_ARRAY_INT_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_ARRAY_TYPE(INT, ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_array_object ( ARG, FLAG )

begin
    if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
    m_sc.scope.down(`"ARG`", null);
    if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
      if(local_data__!=null) begin
         if(ARG.size() != local_data__.ARG.size())
           ARG = new[local_data__.ARG.size()](ARG);
      end
      else begin
        ARG.delete();
      end
    end
    M_OVM_FIELD_DATA_ARRAY_OBJECT(ARG,FLAG)
    M_OVM_FIELD_ARRAY_OBJ_PACK(ARG,FLAG)
    M_OVM_FIELD_SET_ARRAY_OBJECT(ARG,FLAG)
    m_sc.scope.up(null);
  end

`define ovm_field_array_real ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
    if(local_data__!=null) begin
      ARG = new [local_data__.ARG.size()](local_data__.ARG);
    end
    else begin
      ARG.delete();
    end
  end
  M_OVM_FIELD_DATA_ARRAY_REAL(ARG,FLAG)
  M_OVM_FIELD_ARRAY_REAL_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_ARRAY_REAL(ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_array_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
    if(local_data__!=null) begin
       ARG = new[local_data__.ARG.size()];
    end
    else begin
      ARG.delete();
    end
  end
  M_OVM_FIELD_DATA_ARRAY_STRING(ARG,FLAG)
  M_OVM_FIELD_ARRAY_STR_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_ARRAY_TYPE(STR, ARG, m_sc.stringv, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_enum ( T, ARG, FLAG )

begin
  m_sc.scope.set_arg(`"ARG`");
  M_OVM_FIELD_ENUM(T,ARG,FLAG)
  m_sc.scope.unset_arg(`"ARG`");
  end

`define ovm_field_event ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_EVENT(ARG,FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_int ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.set_arg(`"ARG`");
  M_OVM_FIELD_DATA(ARG,FLAG)
  M_OVM_FIELD_SET(ARG,FLAG)
  m_sc.scope.unset_arg(`"ARG`");
  end

`define ovm_field_object ( ARG, FLAG )

if((ARG==null) || !m_sc.scope.in_hierarchy(ARG)) begin
    if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
    m_sc.scope.down(`"ARG`", ARG);
    M_OVM_FIELD_DATA_OBJECT(ARG,FLAG)
    M_OVM_FIELD_SET_OBJECT(ARG,FLAG)
    m_sc.scope.up(ARG);
  end

`define ovm_field_qda_enum ( T, ARG, FLAG )

begin
    T lh__, rh__;
    if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
    m_sc.scope.down(`"ARG`",null);
    if((what__ == OVM_PRINT) && !(OVM_NOPRINT&(FLAG)))
      ovm_print_qda_enum(ARG, ovm_auto_options_object.printer, array, T)
    else if((what__ == OVM_RECORD) && !(OVM_NORECORD&(FLAG)))
      m_ovm_record_qda_enum(T,ARG, ovm_auto_options_object.recorder)
    else if((what__ == OVM_COMPARE) && !(OVM_NOCOMPARE&(FLAG))) begin
      $cast(local_data__, tmp_data__);
      if(ARG.size() != local_data__.ARG.size()) begin
        int s1__, s2__;
        m_sc.stringv = "";
        s1__ = ARG.size(); s2__ = local_data__.ARG.size();
        $swrite(m_sc.stringv, "lhs size = %0d : rhs size = %0d", s1__, s2__);
        ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
      end
      for(int i__=0; i__<ARG.size() && i__ARG.size(); ++i__)
        if(ARG[i__] !== local_data__.ARG[i__]) begin
          lh__ = ARG[i__];
          rh__ = local_data__.ARG[i__];
          ovm_auto_options_object.comparer.scope.down_element(i__, null);
          $swrite(m_sc.stringv, "lhs = %0s : rhs = %0s",
            lh__.name(), rh__.name());
          ovm_auto_options_object.comparer.print_msg(m_sc.stringv);
          ovm_auto_options_object.comparer.scope.up_element(null);
        end
    end
    if((what__ == OVM_COPY) && !(OVM_NOCOPY&(FLAG))) begin
      $cast(local_data__, tmp_data__);
      if(local_data__ != null) ARG = local_data__.ARG;
    end
    else if((what__ == OVM_PACK) && !(OVM_NOPACK&(FLAG))) begin
      if(ovm_auto_options_object.packer.use_metadata == 1)
        ovm_auto_options_object.packer.pack_field_int(ARG.size(), 32);
      foreach(ARG[i])
        ovm_auto_options_object.packer.pack_field(int'(ARG[i]), $bits(ARG[i]));
    end
    m_sc.scope.up(null);
  end

`define ovm_field_queue_enum ( T, ARG, FLAG )

begin
    ovm_field_qda_enum(T,ARG,FLAG)
    ovm_unpack_queue_enum(T,ARG,FLAG)
    M_OVM_FIELD_SET_QUEUE_ENUM(T, ARG, m_sc.bitstream, FLAG)
  end

`define ovm_field_queue_int ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
    if(local_data__!=null) begin
      M_RESIZE_QUEUE_NOCOPY(ovm_bitstream_t, ARG, local_data__.ARG.size())
    end
    else begin
      M_RESIZE_QUEUE_NOCOPY(ovm_bitstream_t, ARG, 0)
    end
  end
  M_OVM_FIELD_DATA_ARRAY(ARG,FLAG)
  M_OVM_FIELD_QUEUE_INT_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_QUEUE_TYPE(INT, ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_queue_object ( ARG, FLAG )

begin
    if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
    m_sc.scope.down(`"ARG`", null);
    if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
      if(local_data__!=null) begin
        M_RESIZE_QUEUE_OBJECT_NOCOPY(ARG, local_data__.ARG.size())
      end
      else begin
        M_RESIZE_QUEUE_OBJECT_NOCOPY(ARG, 0)
      end
    end
    M_OVM_FIELD_DATA_ARRAY_OBJECT(ARG,FLAG)
    M_OVM_FIELD_QUEUE_OBJ_PACK(ARG,FLAG)
    M_OVM_FIELD_SET_QUEUE_OBJECT(ARG,FLAG)
    m_sc.scope.up(null);
  end

`define ovm_field_queue_real ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  M_OVM_FIELD_DATA_QUEUE_REAL(ARG,FLAG)
  M_OVM_FIELD_QUEUE_REAL_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_QUEUE_REAL(ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_queue_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  if(what__==OVM_COPY && !((FLAG)&OVM_NOCOPY)) begin
    if(local_data__!=null) begin
      M_RESIZE_QUEUE_NOCOPY(string, ARG, local_data__.ARG.size())
    end
    else begin
      M_RESIZE_QUEUE_NOCOPY(string, ARG, 0)
    end
  end
  M_OVM_FIELD_DATA_ARRAY_STRING(ARG,FLAG)
  M_OVM_FIELD_QUEUE_STR_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_QUEUE_TYPE(STR, ARG, m_sc.stringv, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_real ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.set_arg(`"ARG`");
  if((local_data__ != null) && $cast(local_data__, tmp_data__))
    void'(m_do_data_real(`"ARG`", ARG, local_data__.ARG, what__, FLAG));
  else
    void'(m_do_data_real(`"ARG`", ARG, 0, what__, FLAG));
  m_sc.scope.unset_arg(`"ARG`");
  end

`define ovm_field_sarray_enum ( T, ARG, FLAG )

`define ovm_field_sarray_int ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  M_OVM_FIELD_DATA_SARRAY(ARG,FLAG)
  M_OVM_FIELD_SET_SARRAY_TYPE(INT,ARG,m_sc.bitstream,FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_sarray_object ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  M_OVM_FIELD_DATA_SARRAY_OBJECT(ARG,FLAG)
  M_OVM_FIELD_SET_SARRAY_OBJECT(ARG,FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_sarray_real ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  M_OVM_FIELD_DATA_SARRAY_REAL(ARG,FLAG)
  M_OVM_FIELD_SARRAY_REAL_PACK(ARG,FLAG)
  M_OVM_FIELD_SET_SARRAY_REAL(ARG, m_sc.bitstream, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_sarray_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`", null);
  M_OVM_FIELD_DATA_SARRAY_STRING(ARG,FLAG)
  M_OVM_FIELD_SET_SARRAY_TYPE(STR, ARG, m_sc.stringv, FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_string ( ARG, FLAG )

begin
  if(what__==OVM_CHECK_FIELDS) m_do_field_check(`"ARG`");
  m_sc.scope.down(`"ARG`",null);
  M_OVM_FIELD_DATA_STRING(ARG,FLAG)
  M_OVM_FIELD_SET_STRING(ARG,FLAG)
  m_sc.scope.up(null);
  end

`define ovm_field_utils

`define ovm_field_utils_begin ( T )

static bit m_fields_checked = 0;
   function void m_field_automation (ovm_object tmp_data__,
                                     int what__,
                                     string str__);
   begin
     T local_data__; /* Used for copy and compare */
     typedef T ___local_type____;
     string string_aa_key; /* Used for associative array lookups */
     /* Check the fields if not already checked */
     if(what__ == OVM_CHECK_FIELDS) begin
       if(! ___local_type____``::m_fields_checked)
         ___local_type____``::m_fields_checked=1;
       else
         return;
     end
     if(ovm_auto_options_object.recorder != null) begin
       ovm_auto_options_object.recorder.scope = m_sc.scope;
     end
     /* Type is verified by ovm_object::compare() */
     super.m_field_automation(tmp_data__, what__, str__);
     if(tmp_data__ != null)
       /* Allow objects in same hierarchy to be copied/compared */
       if(!$cast(local_data__, tmp_data__)) return;
     if(what__ == OVM_CHECK_FIELDS) begin
       super.m_delete_field_array();
     end

`define ovm_field_utils_end

end
endfunction

`define ovm_file

`__FILE__

`define OVM_FIX_REV

`define OVM_FIX_REV_2

`define ovm_get_imp_decl ( SFX )

class ovm_get_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_GET_MASK,`"ovm_get_imp``SFX`",IMP)
  BLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
  NONBLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_get_peek_imp_decl ( SFX )

class ovm_get_peek_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_GET_PEEK_MASK,`"ovm_get_peek_imp``SFX`",IMP)
  BLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
  NONBLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
  BLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
  NONBLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_get_type_name_func ( T )

const static string type_name = `"T`";
   virtual function string get_type_name ();
     return type_name;
   endfunction

`define ovm_global_reporter

ovm_pkg::_global_reporter

`define ovm_global_urm_report_server

ovm_pkg::ovm_global_urm_report_server

`define OVM_IMP_COMMON ( MASK, TYPE_NAME, IMP )

local IMP m_imp;
  function new (string name, IMP imp);
    super.new (name, imp, OVM_IMPLEMENTATION, 1, 1);
    m_imp = imp;
    m_if_mask = MASK;
  endfunction
  TLM_GET_TYPE_NAME(TYPE_NAME)

`define ovm_info ( ID, MSG, VERBOSITY )

begin
     if (ovm_report_enabled(VERBOSITY,OVM_INFO,ID))
       ovm_report_info (ID, MSG, VERBOSITY, ovm_file, ovm_line);
   end

`define OVM_LAYERED_STIMULUS

`define ovm_line

`__LINE__

`define OVM_LINE_WIDTH

120

`define OVM_MACROS_SVH

`define OVM_MAJOR_REV

`define OVM_MAJOR_REV_2

`define OVM_MAJOR_VERSION_2_0

`define ovm_master_imp_decl ( SFX )

class ovm_master_imp``SFX #(type REQ=int, type RSP=int, type IMP=int,
                            type REQ_IMP=IMP, type RSP_IMP=IMP)
  extends ovm_port_base #(tlm_if_base #(REQ, RSP));
  typedef IMP this_imp_type;
  typedef REQ_IMP this_req_type;
  typedef RSP_IMP this_rsp_type;
  OVM_MS_IMP_COMMON(TLM_MASTER_MASK,`"ovm_master_imp``SFX`")

  BLOCKING_PUT_IMP_SFX(SFX, m_req_imp, REQ, t) NONBLOCKING_PUT_IMP_SFX(SFX, m_req_imp, REQ, t)
  BLOCKING_GET_IMP_SFX(SFX, m_rsp_imp, RSP, t) BLOCKING_PEEK_IMP_SFX(SFX, m_rsp_imp, RSP, t) NONBLOCKING_GET_IMP_SFX(SFX, m_rsp_imp, RSP, t) NONBLOCKING_PEEK_IMP_SFX(SFX, m_rsp_imp, RSP, t)
endclass

`define OVM_MAX_STREAMBITS

4096

`define OVM_MESSAGE_DEFINES_SVH

`define OVM_METH_DEFINES_SVH

`define OVM_METH_SVH

`define OVM_MINOR_REV

`define OVM_MINOR_REV_1

`define OVM_MISC_SVH

`define OVM_MONITOR_SVH

`define OVM_MS_IMP_COMMON ( MASK, TYPE_NAME )

local this_req_type m_req_imp;
  local this_rsp_type m_rsp_imp;
  function new (string name, this_imp_type imp,
                this_req_type req_imp = null, this_rsp_type rsp_imp = null);
    super.new (name, imp, OVM_IMPLEMENTATION, 1, 1);
    if(req_imp==null) $cast(req_imp, imp);
    if(rsp_imp==null) $cast(rsp_imp, imp);
    m_req_imp = req_imp;
    m_rsp_imp = rsp_imp;
    m_if_mask = MASK;
  endfunction
  TLM_GET_TYPE_NAME(TYPE_NAME)

`define ovm_msg_detail ( L )

urm_msg_detail(L)

`define OVM_NAME

OVM

`define ovm_named_object_create_func ( T )

function ovm_named_object create_named_object (string name, ovm_named_object parent);
     T tmp;
     tmp = new(.name(name), .parent(parent));
     return tmp;
   endfunction

`define ovm_named_object_factory_create_func ( T )

ovm_named_object_create_func(T)

`define ovm_named_object_new_func

function new (string name, ovm_component parent);
super.new(name, parent);
endfunction

`define ovm_new_func

function new (string name, ovm_component parent);
super.new(name, parent);
endfunction

`define ovm_new_func_data

function new (string name="");
super.new(name);
endfunction

`define ovm_non_blocking_transport_imp_decl ( SFX )

ovm_nonblocking_transport_imp_decl(SFX)

`define ovm_nonblocking_get_imp_decl ( SFX )

class ovm_nonblocking_get_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_NONBLOCKING_GET_MASK,`"ovm_nonblocking_get_imp``SFX`",IMP)
  NONBLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_nonblocking_get_peek_imp_decl ( SFX )

class ovm_nonblocking_get_peek_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_NONBLOCKING_GET_PEEK_MASK,`"ovm_nonblocking_get_peek_imp``SFX`",IMP)
  NONBLOCKING_GET_IMP_SFX(SFX, m_imp, T, t)
  NONBLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_nonblocking_master_imp_decl ( SFX )

class ovm_nonblocking_master_imp``SFX #(type REQ=int, type RSP=int, type IMP=int,
                                   type REQ_IMP=IMP, type RSP_IMP=IMP)
  extends ovm_port_base #(tlm_if_base #(REQ, RSP));
  typedef IMP this_imp_type;
  typedef REQ_IMP this_req_type;
  typedef RSP_IMP this_rsp_type;
  OVM_MS_IMP_COMMON(TLM_NONBLOCKING_MASTER_MASK,`"ovm_nonblocking_master_imp``SFX`")

  NONBLOCKING_PUT_IMP_SFX(SFX, m_req_imp, REQ, t)
  NONBLOCKING_GET_IMP_SFX(SFX, m_rsp_imp, RSP, t) NONBLOCKING_PEEK_IMP_SFX(SFX, m_rsp_imp, RSP, t)
endclass

`define ovm_nonblocking_peek_imp_decl ( SFX )

class ovm_nonblocking_peek_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_NONBLOCKING_PEEK_MASK,`"ovm_nonblocking_peek_imp``SFX`",IMP)
  NONBLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_nonblocking_put_imp_decl ( SFX )

class ovm_nonblocking_put_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_NONBLOCKING_PUT_MASK,`"ovm_nonblocking_put_imp``SFX`",IMP)
  NONBLOCKING_PUT_IMP_SFX( SFX, m_imp, T, t)
endclass

`define ovm_nonblocking_slave_imp_decl ( SFX )

class ovm_nonblocking_slave_imp``SFX #(type REQ=int, type RSP=int, type IMP=int,
                                       type REQ_IMP=IMP, type RSP_IMP=IMP)
  extends ovm_port_base #(tlm_if_base #(RSP, REQ));
  typedef IMP this_imp_type;
  typedef REQ_IMP this_req_type;
  typedef RSP_IMP this_rsp_type;
  OVM_MS_IMP_COMMON(TLM_NONBLOCKING_SLAVE_MASK,`"ovm_nonblocking_slave_imp``SFX`")

  NONBLOCKING_PUT_IMP_SFX(SFX, m_rsp_imp, RSP, t)
  NONBLOCKING_GET_IMP_SFX(SFX, m_req_imp, REQ, t) NONBLOCKING_PEEK_IMP_SFX(SFX, m_req_imp, REQ, t)
endclass

`define ovm_nonblocking_transport_imp_decl ( SFX )

class ovm_nonblocking_transport_imp``SFX #(type REQ=int, type RSP=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(REQ, RSP));
  OVM_IMP_COMMON(TLM_NONBLOCKING_TRANSPORT_MASK,`"ovm_nonblocking_transport_imp``SFX`",IMP)
  NONBLOCKING_TRANSPORT_IMP_SFX(SFX, m_imp, REQ, RSP, req, rsp)
endclass

`define OVM_NUM_LINES

120

`define ovm_object_create_func ( T )

function ovm_object create (string name="");
     T tmp;
     tmp = new();
     if (name!="")
       tmp.set_name(name);
     return tmp;
   endfunction

`define OVM_OBJECT_DEFINES_SVH

`define ovm_object_factory_create_func ( T )

function ovm_object create_object (string name="");
     T tmp;
     tmp = new();
     if (name!="")
       tmp.set_name(name);
     return tmp;
   endfunction

   static function T create(string name="", ovm_component parent=null, string contxt="");
     ovm_factory f;
     f = ovm_factory::get();
     if (contxt == "" && parent != null)
       contxt = parent.get_full_name();
     if(!$cast(create,f.create_object_by_type(get(),contxt,name)))
        ovm_top.ovm_report_fatal("FACTFL", {"Factory did not return an object of type, ",type_name}, OVM_NONE);
   endfunction

`define ovm_object_new_func

ovm_new_func_data

`define ovm_object_param_utils ( T )

ovm_object_param_utils_begin(T)
ovm_object_utils_end

`define ovm_object_param_utils_begin ( T )

ovm_object_registry_param(T)
ovm_object_create_func(T)
ovm_field_utils_begin(T)

`define ovm_object_registry ( T, S )

typedef ovm_object_registry#(T,S) type_id;
   static function type_id get_type();
     return type_id::get();
   endfunction
   virtual function ovm_object_wrapper get_object_type();
     return type_id::get();
   endfunction

`define ovm_object_registry_internal ( T, S )

typedef ovm_object_registry#(T,`"S`") type_id;
   static function type_id get_type();
     return type_id::get();
   endfunction
   virtual function ovm_object_wrapper get_object_type();
     return type_id::get();
   endfunction

`define ovm_object_registry_param ( T )

typedef ovm_object_registry #(T) type_id;
   static function type_id get_type();
     return type_id::get();
   endfunction
   virtual function ovm_object_wrapper get_object_type();
     return type_id::get();
   endfunction

`define OVM_OBJECT_SVH

`define ovm_object_utils ( T )

ovm_object_utils_begin(T)
ovm_object_utils_end

`define ovm_object_utils_begin ( T )

ovm_object_registry_internal(T,T)
   ovm_object_create_func(T)
   ovm_get_type_name_func(T)
   ovm_field_utils_begin(T)

`define ovm_object_utils_end

end
endfunction

`define OVM_OBJECTION_SVH

`define ovm_pack_unpack_sarray_enum ( T, ARG, FLAG )

if((what__ == OVM_PACK) && !(OVM_NOPACK&(FLAG))) begin
    if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
        (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical))
      foreach(ARG[i])
        ovm_auto_options_object.packer.pack_field(ARG[i],$bits(ARG[i]));
  end
  else if((what__ == OVM_UNPACK) && !(OVM_NOPACK&(FLAG))) begin
    if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
        (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical))
      foreach(ARG[i])
        ARG[i] = T'(ovm_auto_options_object.packer.unpack_field($bits(ARG[i])));
  end

`define ovm_package ( PKG )

package PKG;
class ovm_bogus_class extends ovm::ovm_sequence;
endclass

`define OVM_PACKER_MAX_BYTES

OVM_STREAMBITS

`define OVM_PACKER_SVH

`define OVM_PAIR_SVH

`define ovm_peek_imp_decl ( SFX )

class ovm_peek_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_PEEK_MASK,`"ovm_peek_imp``SFX`",IMP)
  BLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
  NONBLOCKING_PEEK_IMP_SFX(SFX, m_imp, T, t)
endclass

`define ovm_phase_func_bottomup_decl ( NAME )

ovm_phase_func_decl(NAME,0)

`define ovm_phase_func_decl ( NAME, TOP_DOWN )

class NAME``_phase #(type PARENT=int) extends ovm_phase;
    function new();
      super.new(`"NAME`",TOP_DOWN,0);
    endfunction
    ovm_phase_type_name_decl(NAME)
    virtual function void call_func(ovm_component parent);
      PARENT m_parent;
      super.call_func(parent);
      if($cast(m_parent,parent)) begin
        if(has_executed(parent)) begin
          parent.ovm_report_warning("PHSEXEC", { "The phase ", get_name(),
            " has already executed. Either the phase was not reset, or there",
            " there is an invalid phase alias for this phase."});
          return;
        end
        set_executed(parent);
        m_parent.NAME();
      end
    endfunction
  endclass

`define ovm_phase_func_topdown_decl ( NAME )

ovm_phase_func_decl(NAME,1)

`define ovm_phase_task_bottomup_decl ( NAME )

ovm_phase_task_decl(NAME,0)

`define ovm_phase_task_decl ( NAME, TOP_DOWN )

class NAME``_phase #(type PARENT=int) extends ovm_phase;
    function new();
      super.new(`"NAME`",TOP_DOWN,1);
    endfunction
    ovm_phase_type_name_decl(NAME)
    virtual task call_task(ovm_component parent);
      PARENT m_parent;
      super.call_task(parent);
      if($cast(m_parent,parent)) begin
        if(has_executed(parent)) begin
          parent.ovm_report_warning("PHSEXEC", { "The phase ", get_name(),
            " has already executed. Either the phase was not reset, or there",
            " there is an invalid phase alias for this phase."});
          return;
        end
        set_executed(parent);
        m_parent.NAME();
      end
    endtask
  endclass

`define ovm_phase_task_topdown_decl ( NAME )

ovm_phase_task_decl(NAME,1)

`define ovm_phase_type_name_decl ( NAME )

virtual function string get_type_name ();
return `"NAME``_phase #(PARENT)`";
endfunction

`define OVM_PHASES_SVH

`define OVM_PKG_SV

`define OVM_POLICIES_SVH

`define OVM_PORT_COMMON ( MASK, TYPE_NAME )

function new (string name, ovm_component parent,
                int min_size=1, int max_size=1);
    super.new (name, parent, OVM_PORT, min_size, max_size);
    m_if_mask = MASK;
  endfunction
  TLM_GET_TYPE_NAME(TYPE_NAME)

`define ovm_print_aa_int_key4 ( KEY, F, R, P )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    m_sc.stringv = "aa(int,int)";
    for(int i=0; i       if(m_sc.stringv[i] == " ")
        m_sc.stringv[i] = "_";
    p__.print_array_header (`"F`", F.num(), m_sc.stringv);
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[aa_key]) begin
          print_integral_field(F[aa_key], R,
                                {"[", $psprintf("%0d",aa_key), "]"}, p__)
      end
    end
    p__.print_array_footer(F.num());
    p__.print_footer();
  end

`define ovm_print_aa_int_object ( F, FLAG )

`ovm_print_aa_int_object_3(F, ovm_default_printer,FLAG)

`define ovm_print_aa_int_object3 ( F, P, FLAG )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    ovm_object u__;
    int key;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    p__.print_array_header (`"F`", F.num(), "aa(object,int)");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[key]) begin
          $swrite(m_sc.stringv, "[%0d]", key);
          if(((FLAG)&OVM_REFERENCE)==0)
            p__.print_object(m_sc.stringv, F[key], "[");
          else
            p__.print_object_header(m_sc.stringv, F[key], "[");
      end
    end
    p__.print_array_footer(F.num());
    p__.print_footer();
  end

`define ovm_print_aa_string_int ( F )

ovm_print_aa_string_int3(F, R, ovm_default_printer)

`define ovm_print_aa_string_int3 ( F, R, P )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    p__.print_array_header (`"F`", F.num(), "aa(int,string)");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[string_aa_key])
          print_integral_field(F[string_aa_key], R,
                                {"[", string_aa_key, "]"}, p__)
    end
    p__.print_array_footer(F.num());
    p__.print_footer();
  end

`define ovm_print_aa_string_object ( F, FLAG )

`ovm_print_aa_string_object_3(F, ovm_default_printer,FLAG)

`define ovm_print_aa_string_object3 ( F, P, FLAG )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    ovm_object u__;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    p__.print_array_header (`"F`", F.num(), "aa(object,string)");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[string_aa_key]) begin
          if(((FLAG)&OVM_REFERENCE)==0)
            p__.print_object({"[", string_aa_key, "]"}, F[string_aa_key], "[");
          else
            p__.print_object_header({"[", string_aa_key, "]"}, F[string_aa_key], "[");
      end
    end
    p__.print_array_footer(F.num());
    p__.print_footer();
  end

`define ovm_print_aa_string_string ( F )

`ovm_print_aa_string_string_2(F, ovm_default_printer)

`define ovm_print_aa_string_string2 ( F, P )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    p__.print_array_header (`"F`", F.num(), "aa(string,string)");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[string_aa_key])
          p__.print_string({"[", string_aa_key, "]"}, F[string_aa_key], "[");
    end
    p__.print_array_footer(F.num());
    p__.print_footer();
  end

`define ovm_print_array_int ( F, R )

ovm_print_array_int3(F, R, ovm_default_printer)

`define ovm_print_array_int3 ( F, R, P )

ovm_print_qda_int4(F, R, P, da)

`define ovm_print_array_object ( F, FLAG )

ovm_print_array_object3(F, ovm_default_printer,FLAG)

`define ovm_print_array_object3 ( F, P, FLAG )

ovm_print_object_qda4(F, P, da,FLAG)

`define ovm_print_array_real ( F )

ovm_print_array_real2(F, ovm_default_printer)

`define ovm_print_array_real2 ( F, P )

ovm_print_qda_real3(F, P, da)

`define ovm_print_array_string ( F )

ovm_print_array_string2(F, ovm_default_printer)

`define ovm_print_array_string2 ( F, P )

ovm_print_string_qda3(F, P, da)

`define ovm_print_int ( F, R )

ovm_print_int3(F, R, ovm_default_printer)

`define ovm_print_int3 ( F, R, P )

do begin
     ovm_printer p__;
     if(P!=null) p__ = P;
     else p__ = ovm_default_printer;
     print_integral_field(F, R, `"F`", p__)
   end while(0);

`define ovm_print_msg_enum ( LHS, RHS )

begin
    ovm_comparer comparer;
    comparer = ovm_auto_options_object.comparer;
    if(comparer==null) comparer = ovm_default_comparer;
    comparer.result++;
/* $swrite(comparer.miscompares,"%s%s: lhs = %s : rhs = %s\n",*/
/* comparer.miscompares, comparer.scope.get_arg(), LHS, RHS );*/
    $swrite(comparer.miscompares,"%s%s: lhs = %0d : rhs = %0d\n",
       comparer.miscompares, comparer.scope.get_arg(), LHS, RHS );
  end

`define ovm_print_object ( F )

ovm_print_object2(F, ovm_default_printer)

`define ovm_print_object2 ( F, P )

do begin
     ovm_printer p__;
     if(P!=null) p__ = P;
     else p__ = ovm_default_printer;
     p__.print_object(`"F`", F, "[");
   end while(0);

`define ovm_print_object_qda4 ( F, P, T, FLAG )

do begin
    int curr, max__;
    ovm_printer p__;
    max__=0; curr=0;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    foreach(F[i__]) max__++;

    p__.print_header();

    p__.m_scope.set_arg(`"F`");
    p__.print_array_header(`"F`", max__, `"T``(object)`");
    if((p__.knobs.depth == -1) || (p__.knobs.depth+1 > p__.m_scope.depth()))
    begin
      for(curr=0; curr          p__.knobs.end_elements == -1 || curr         if(((FLAG)&OVM_REFERENCE) == 0)
          p__.print_object(p__.index_string(curr), F[curr], "[");
        else
          p__.print_object_header(p__.index_string(curr), F[curr], "[");
      end
      if(curr         curr = max__-p__.knobs.end_elements;
        if(curr         else begin
          p__.print_array_range(p__.knobs.begin_elements, curr-1);
        end
        for(curr=curr; curr           if(((FLAG)&OVM_REFERENCE) == 0)
            p__.print_object(p__.index_string(curr), F[curr], "[");
          else
            p__.print_object_header(p__.index_string(curr), F[curr], "[");
        end
      end
    end

    p__.print_array_footer(max__);
    p__.print_footer();
  end while(0);

`define ovm_print_object_queue ( F, FLAG )

ovm_print_object_queue3(F, ovm_default_printer,FLAG)

`define ovm_print_object_queue3 ( F, P, FLAG )

do begin
ovm_print_object_qda4(F,P, queue,FLAG);
end while(0);

`define ovm_print_qda_enum ( F, P, T, ET )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    int curr, max__; max__=0; curr=0;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    foreach(F[i__]) max__++;
    p__.print_array_header (`"F`", max__,`"T``(``ET``)`");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[i__]) begin
        if(k__.begin_elements == -1 || k__.end_elements == -1 || curr < k__.begin_elements ) begin
          print_enum_field(ET, F[curr], p__.index_string(curr), p__)
        end
        else break;
        curr++;
      end
      if(curr         if((max__-k__.end_elements) > curr) curr = max__-k__.end_elements;
        if(curr         else begin
          p__.print_array_range(k__.begin_elements, curr-1);
        end
        for(curr=curr; curr           print_enum_field(ET, F[curr], p__.index_string(curr), p__)
        end
      end
    end
    p__.print_array_footer(max__);
    p__.print_footer();
  end

`define ovm_print_qda_int4 ( F, R, P, T )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    int curr, max__; max__=0; curr=0;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    foreach(F[i__]) max__++;
    p__.print_array_header (`"F`", max__,`"T``(integral)`");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[i__]) begin
        if(k__.begin_elements == -1 || k__.end_elements == -1 || curr < k__.begin_elements ) begin
          print_integral_field(F[curr], R, p__.index_string(curr), p__)
        end
        else break;
        curr++;
      end
      if(curr         if((max__-k__.end_elements) > curr) curr = max__-k__.end_elements;
        if(curr         else begin
          p__.print_array_range(k__.begin_elements, curr-1);
        end
        for(curr=curr; curr           print_integral_field(F[curr], R, p__.index_string(curr), p__)
        end
      end
    end
    p__.print_array_footer(max__);
    p__.print_footer();
  end

`define ovm_print_qda_real3 ( F, P, T )

begin
    ovm_printer p__;
    ovm_printer_knobs k__;
    int curr, max__; max__=0; curr=0;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;
    foreach(F[i__]) max__++;
    p__.print_array_header (`"F`", max__,`"T``(integral)`");
    k__ = p__.knobs;
    if((p__.knobs.depth == -1) || (p__.m_scope.depth() < p__.knobs.depth+1))
    begin
      foreach(F[i__]) begin
        if(k__.begin_elements == -1 || k__.end_elements == -1 || curr < k__.begin_elements ) begin
          p__.print_field_real(p__.index_string(curr), F[curr], "[");
        end
        else break;
        curr++;
      end
      if(curr         if((max__-k__.end_elements) > curr) curr = max__-k__.end_elements;
        if(curr         else begin
          p__.print_array_range(k__.begin_elements, curr-1);
        end
        for(curr=curr; curr           p__.print_field_real(p__.index_string(curr), F[curr], "[");
        end
      end
    end
    p__.print_array_footer(max__);
    p__.print_footer();
  end

`define ovm_print_queue_int ( F, R )

ovm_print_queue_int3(F, R, ovm_default_printer)

`define ovm_print_queue_int3 ( F, R, P )

`ovm_print_qda_int3(F, R, P, queue)

`define ovm_print_sarray_int3 ( F, R, P )

ovm_print_qda_int4(F, R, P, sa)

`define ovm_print_sarray_object ( F, FLAG )

ovm_print_sarray_object3(F, ovm_default_printer,FLAG)

`define ovm_print_sarray_object3 ( F, P, FLAG )

ovm_print_object_qda4(F, P, sa,FLAG)

`define ovm_print_sarray_string2 ( F, P )

ovm_print_string_qda3(F, P, sa)

`define ovm_print_string ( F )

ovm_print_string2(F, ovm_default_printer)

`define ovm_print_string2 ( F, P )

do begin
     ovm_printer p__;
     if(P!=null) p__ = P;
     else p__ = ovm_default_printer;
     p__.print_string(`"F`", F, "[");
   end while(0);

`define ovm_print_string_qda3 ( F, P, T )

do begin
    int curr, max__;
    ovm_printer p__;
    max__=0; curr=0;
    foreach(F[i__]) max__++;
    if(P!=null) p__ = P;
    else p__ = ovm_default_printer;

    p__.print_header();

    p__.m_scope.set_arg(`"F`");
    p__.print_array_header(`"F`", max__, `"T``(string)`");
    if((p__.knobs.depth == -1) || (p__.knobs.depth+1 > p__.m_scope.depth()))
    begin
      for(curr=0; curr         p__.print_string(p__.index_string(curr), F[curr], "[");
      end
      if(curr         curr = max__-p__.knobs.end_elements;
        if(curr         else begin
          p__.print_array_range(p__.knobs.begin_elements, curr-1);
        end
        for(curr=curr; curr           p__.print_string(p__.index_string(curr), F[curr], "[");
        end
      end
    end

    p__.print_array_footer(max__);
    p__.print_footer();
  end while(0);

`define ovm_print_string_queue ( F )

ovm_print_string_queue2(F, ovm_default_printer)

`define ovm_print_string_queue2 ( F, P )

do begin
ovm_print_string_qda3(F,P, queue);
end while(0);

`define OVM_PRINTER_DEFINES_SVH

`define OVM_PRINTER_SVH

`define ovm_put_imp_decl ( SFX )

class ovm_put_imp``SFX #(type T=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(T,T));
  OVM_IMP_COMMON(TLM_PUT_MASK,`"ovm_put_imp``SFX`",IMP)
  BLOCKING_PUT_IMP_SFX(SFX, m_imp, T, t)
  NONBLOCKING_PUT_IMP_SFX(SFX, m_imp, T, t)
endclass

`define OVM_QUEUE_SVH

`define ovm_rand_send ( OVM_SEQUENCE_ITEM )

begin
  start_item(OVM_SEQUENCE_ITEM);
  if (!OVM_SEQUENCE_ITEM.randomize()) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_rand_send action");
  end
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define ovm_rand_send_pri ( OVM_SEQUENCE_ITEM, PRIORITY )

begin
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  if (!OVM_SEQUENCE_ITEM.randomize()) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_rand_send action");
  end
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define ovm_rand_send_pri_with ( OVM_SEQUENCE_ITEM, PRIORITY, CONSTRAINTS )

begin
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  if (!OVM_SEQUENCE_ITEM.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_rand_send_with action");
  end
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define ovm_rand_send_with ( OVM_SEQUENCE_ITEM, CONSTRAINTS )

begin
  start_item(OVM_SEQUENCE_ITEM);
  if (!OVM_SEQUENCE_ITEM.randomize() with CONSTRAINTS ) begin
    ovm_report_warning("RNDFLD", "Randomization failed in ovm_rand_send_with action");
  end
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define OVM_RECORD_INTERFACE

`define ovm_register_self_func ( T )

`define ovm_register_sequence ( TYPE_NAME, SEQUENCER )

static bit is_registered_with_sequencer = SEQUENCER``::add_typewide_sequence(`"TYPE_NAME`");

`define OVM_REGISTRY_SVH

`define OVM_REPORT_CLIENT_SVH

`define OVM_REPORT_ERROR ( ID, MSG )

ovm_report_error(ID,MSG,OVM_LOW,ovm_file,ovm_line)

`define OVM_REPORT_FATAL ( ID, MSG )

ovm_report_fatal(ID,MSG,OVM_NONE,ovm_file,ovm_line)

`define OVM_REPORT_HANDLER_SVH

`define OVM_REPORT_INFO ( ID, MSG )

ovm_report_info(ID,MSG,OVM_MEDIUM,ovm_file,ovm_line)

`define OVM_REPORT_SERVER_SVH

`define OVM_REPORT_WARNING ( ID, MSG )

ovm_report_warning(ID,MSG,OVM_MEDIUM,ovm_file,ovm_line)

`define OVM_ROOT_SVH

`define ovm_send ( OVM_SEQUENCE_ITEM )

begin
  start_item(OVM_SEQUENCE_ITEM);
  finish_item(OVM_SEQUENCE_ITEM);
  end

`define ovm_send_pri ( OVM_SEQUENCE_ITEM, PRIORITY )

begin
  start_item(OVM_SEQUENCE_ITEM, PRIORITY);
  finish_item(OVM_SEQUENCE_ITEM, PRIORITY);
  end

`define OVM_SEQ_PORT ( MASK, TYPE_NAME )

function new (string name, ovm_component parent,
                int min_size=0, int max_size=1);
    super.new (name, parent, OVM_PORT, min_size, max_size);
    m_if_mask = MASK;
  endfunction
  TLM_GET_TYPE_NAME(TYPE_NAME)

`define OVM_SEQUENCE_BUILTIN_SVH

`define OVM_SEQUENCE_ITEM_SVH

`define ovm_sequence_library_package ( PKG_NAME )

import PKG_NAME``::*;
PKG_NAME``::ovm_bogus_class M_``PKG_NAME``ovm_bogus_class

`define ovm_sequence_utils ( TYPE_NAME, SEQUENCER )

ovm_sequence_utils_begin(TYPE_NAME,SEQUENCER)
ovm_sequence_utils_end

`define ovm_sequence_utils_begin ( TYPE_NAME, SEQUENCER )

ovm_register_sequence(TYPE_NAME, SEQUENCER)
ovm_declare_p_sequencer(SEQUENCER)
ovm_object_utils_begin(TYPE_NAME)

`define ovm_sequence_utils_end

ovm_object_utils_end

`define ovm_sequencer_param_utils ( TYPE_NAME )

ovm_sequencer_param_utils_begin(TYPE_NAME)
ovm_sequencer_utils_end

`define ovm_sequencer_param_utils_begin ( TYPE_NAME )

ovm_declare_sequence_lib
ovm_component_param_utils_begin(TYPE_NAME)

`define ovm_sequencer_utils ( TYPE_NAME )

ovm_sequencer_utils_begin(TYPE_NAME)
ovm_sequencer_utils_end

`define ovm_sequencer_utils_begin ( TYPE_NAME )

ovm_declare_sequence_lib
ovm_component_utils_begin(TYPE_NAME)

`define ovm_sequencer_utils_end

ovm_component_utils_end

`define ovm_set_flags ( ARG, FLAG )

begin
   if(what__ == OVM_FLAGS) begin
   end
  end

`define ovm_slave_imp_decl ( SFX )

class ovm_slave_imp``SFX #(type REQ=int, type RSP=int, type IMP=int,
                           type REQ_IMP=IMP, type RSP_IMP=IMP)
  extends ovm_port_base #(tlm_if_base #(RSP, REQ));
  typedef IMP this_imp_type;
  typedef REQ_IMP this_req_type;
  typedef RSP_IMP this_rsp_type;
  OVM_MS_IMP_COMMON(TLM_SLAVE_MASK,`"ovm_slave_imp``SFX`")

  BLOCKING_PUT_IMP_SFX(SFX, m_rsp_imp, RSP, t) NONBLOCKING_PUT_IMP_SFX(SFX, m_rsp_imp, RSP, t)
  BLOCKING_GET_IMP_SFX(SFX, m_req_imp, REQ, t) BLOCKING_PEEK_IMP_SFX(SFX, m_req_imp, REQ, t) NONBLOCKING_GET_IMP_SFX(SFX, m_req_imp, REQ, t) NONBLOCKING_PEEK_IMP_SFX(SFX, m_req_imp, REQ, t)
endclass

`define OVM_SVH

`define OVM_TRANSACTION_SVH

`define ovm_transport_imp_decl ( SFX )

class ovm_transport_imp``SFX #(type REQ=int, type RSP=int, type IMP=int)
  extends ovm_port_base #(tlm_if_base #(REQ, RSP));
  OVM_IMP_COMMON(TLM_TRANSPORT_MASK,`"ovm_transport_imp``SFX`",IMP)
  BLOCKING_TRANSPORT_IMP_SFX(SFX, m_imp, REQ, RSP, req, rsp)
  NONBLOCKING_TRANSPORT_IMP_SFX(SFX, m_imp, REQ, RSP, req, rsp)
endclass

`define ovm_unpack_array_enum ( T, ARG, FLAG )

if((what__ == OVM_UNPACK) && !(OVM_NOPACK&(FLAG))) begin
    if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
        (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
      if(ovm_auto_options_object.packer.use_metadata) begin
        int s_;
        s_ = ovm_auto_options_object.packer.unpack_field_int(32);
        ARG = new[s_];
      end
      foreach(ARG[i])
        ARG[i] = T'(ovm_auto_options_object.packer.unpack_field($bits(ARG[i])));
    end
  end

`define ovm_unpack_queue_enum ( T, ARG, FLAG )

if((what__ == OVM_UNPACK) && !(OVM_NOPACK&(FLAG))) begin
    if((((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.abstract) ||
        (!((FLAG)&OVM_ABSTRACT) && ovm_auto_options_object.packer.physical)) begin
      if(ovm_auto_options_object.packer.use_metadata) begin
        int s_;
        s_ = ovm_auto_options_object.packer.unpack_field_int(32);
        while(ARG.size() > s_) void'(ARG.pop_front());
        while(ARG.size() < s_) ARG.push_back(T'(0));
      end
      foreach(ARG[i])
        ARG[i] = T'(ovm_auto_options_object.packer.unpack_field($bits(ARG[i])));
    end
  end

`define ovm_update_sequence_lib

m_add_builtin_seqs(0);
ovm_update_sequence_lib();

`define ovm_update_sequence_lib_and_item ( USER_ITEM )

factory.set_inst_override_by_type(
    ovm_sequence_item::get_type(), USER_ITEM::get_type(),
    {get_full_name(), "*.item"});
  m_add_builtin_seqs(1);
  ovm_update_sequence_lib();

`define ovm_urm_message

ovm_pkg::ovm_urm_message

`define OVM_URM_MESSAGE_DEFINES_SVH

`define OVM_URM_MESSAGE_SVH

`define ovm_urm_report_server

ovm_pkg::ovm_urm_report_server

`define ovm_urm_tmp_str

ovm_pkg::ovm_urm_tmp_str

`define OVM_VERSION_2_1

`define OVM_VERSION_DEFINES_SVH

`define OVM_VERSION_STRING

`"OVM_NAME``-``OVM_MAJOR_REV``.``OVM_MINOR_REV``.``OVM_FIX_REV`"

`define OVM_VERSION_SVH

`define ovm_warning ( ID, MSG )

begin
     if (ovm_report_enabled(OVM_NONE,OVM_WARNING,ID))
       ovm_report_warning (ID, MSG, OVM_NONE, ovm_file, ovm_line);
   end

`define PEEK_IMP ( imp, TYPE, arg )

BLOCKING_PEEK_IMP(imp, TYPE, arg)
NONBLOCKING_PEEK_IMP(imp, TYPE, arg)

`define print_enum_field ( T, F, NM, P )

P.print_generic(NM, `"T`", $bits(F), F.name(), "[");

`define print_integral_field ( F, R, NM, P )

P.print_field(NM, F, $bits(F), R, "[");

`define PUT_IMP ( imp, TYPE, arg )

BLOCKING_PUT_IMP(imp, TYPE, arg)
NONBLOCKING_PUT_IMP(imp, TYPE, arg)

`define SEQ_ITEM_FUNCTION_ERROR

"Sequencer interface function not implemented"

`define SEQ_ITEM_GET_MASK

(1<<7)

`define SEQ_ITEM_GET_NEXT_ITEM_MASK

(1<<0)

`define SEQ_ITEM_HAS_DO_AVAILABLE_MASK

(1<<3)

`define SEQ_ITEM_ITEM_DONE_MASK

(1<<2)

`define SEQ_ITEM_PEEK_MASK

(1<<8)

`define SEQ_ITEM_PULL_IMP ( imp, REQ, RSP, req_arg, rsp_arg )

task get_next_item(output REQ req_arg); imp.get_next_item(req_arg); endtask
  task try_next_item(output REQ req_arg); imp.try_next_item(req_arg); endtask
  function void item_done(input RSP rsp_arg = null); imp.item_done(rsp_arg); endfunction
  task wait_for_sequences(); imp.wait_for_sequences(); endtask
  function bit has_do_available(); return imp.has_do_available(); endfunction
  function void put_response(input RSP rsp_arg); imp.put_response(rsp_arg); endfunction
  task get(output REQ req_arg); imp.get(req_arg); endtask
  task peek(output REQ req_arg); imp.peek(req_arg); endtask
  task put(input RSP rsp_arg); imp.put(rsp_arg); endtask

`define SEQ_ITEM_PULL_IMP ( imp, REQ, RSP, req_arg, rsp_arg )

`define SEQ_ITEM_PULL_MASK

`define SEQ_ITEM_PUSH_MASK

(SEQ_ITEM_PUT_MASK)

`define SEQ_ITEM_PUT_MASK

(1<<6)

`define SEQ_ITEM_PUT_RESPONSE_MASK

(1<<5)

`define SEQ_ITEM_TASK_ERROR

"Sequencer interface task not implemented"

`define SEQ_ITEM_TRY_NEXT_ITEM_MASK

(1<<1)

`define SEQ_ITEM_UNI_PULL_MASK

`define SEQ_ITEM_WAIT_FOR_SEQUENCES_MASK

(1<<4)

`define START_ITEM_SEQ

item

Determine which prototype the UVM start_item task has * UVM 1.0ea was the first to use the new prototype

`define static_dut_error ( MESSAGE )

urm_msg_imp("DUT",MESSAGE,OVM_URM_MSG_DUT,OVM_ERROR,OVM_NONE,"",_global_reporter)

`define static_message ( VERBOSITY, MESSAGE )

urm_msg_imp("DEBUG",MESSAGE,OVM_URM_MSG_DEBUG,OVM_INFO,VERBOSITY,"",_global_reporter)

`define SVT_ABSTRACT

(1<<14)

`define SVT_ADD_CB

add_cb

`define svt_add_to_seq_lib ( TYPE, LIBTYPE )

static bit add_``TYPE``_to_seq_lib_``LIBTYPE =
LIBTYPE::m_add_typewide_sequence(TYPE::get_type());

`define SVT_ALL_ON

'b000010101010101

`define SVT_BATHTUB_DIST ( minimum, maximum, lowerwt, middlewt, upperwt, sidewallpercent )

[ SVT_BATHTUB_LOWER_WT_DIST(minimum,maximum,sidewallpercent) ] :/ lowerwt,
[ SVT_BATHTUB_MIDDLE_WT_DIST(minimum,maximum,sidewallpercent) ] :/ middlewt,
[ SVT_BATHTUB_UPPER_WT_DIST(minimum,maximum,sidewallpercent) ] :/ upperwt

Creates a 'bathtub' shaped distribution with 'x'% of the (max-min) range as the width of the walls of the bathtub and (100 - 2'x')% of the width of the bottom of the tub; where 'x' equals the value of sidewallpercent (expressed as an integer).

Note: no checks are performed to make sure the bathtub sidewalls do not overlap.

`define SVT_BATHTUB_LOWER_WT_DIST ( minimum, maximum, sidewallpercent )

minimum : (minimum + (maximum - minimum)/sidewallpercent)

Defines the 'lower' portion of a bathtub constraint.

`define SVT_BATHTUB_MIDDLE_WT_DIST ( minimum, maximum, sidewallpercent )

(minimum + ((maximum - minimum)/sidewallpercent)) : (maximum - ((maximum - minimum)/sidewallpercent))

Defines the 'middle' portion of a bathtub constraint.

`define SVT_BATHTUB_UPPER_WT_DIST ( minimum, maximum, sidewallpercent )

(maximum - ((maximum - minimum)/sidewallpercent)) : maximum

Defines the 'upper' portion of a bathtub constraint.

`define SVT_BIAS_DIST ( minimum, maximum, lowerwt, upperwt, biasdivisor )

[ SVT_BIAS_LOWER_WT_DIST(minimum,maximum,biasdivisor) ] :/ lowerwt,
[ SVT_BIAS_UPPER_WT_DIST(minimum,maximum,biasdivisor) ] :/ upperwt

Creates a 'biased' distribution with 1/biasdivisor of the overall range making up the lower portion of the range and the remainder making up the upper portion of the range.

`define SVT_BIAS_LOWER_WT_DIST ( minimum, maximum, biasdivisor )

minimum : (minimum + (maximum - minimum)/biasdivisor)

Defines the 'lower' portion of a bias constraint.

`define SVT_BIAS_UPPER_WT_DIST ( minimum, maximum, biasdivisor )

(minimum + (maximum - minimum)/biasdivisor) : maximum

Defines the 'upper' portion of a bias constraint.

`define SVT_BIN

'h1000000

`define svt_callback_utils ( T )

`define SVT_CHANNEL_BASE_TYPE

svt_channel

If not using VMM technology then create equivalent channel functionality, but assuming sequence_items

`define SVT_CMD_CALLBACKS_RESET_TIMEOUT

500

`define SVT_CMD_CLEAR_SEVERITY

1007

`define SVT_CMD_DEBUG_SEVERITY

1005

`define SVT_CMD_DEBUG_VERBOSITY

1011

`define SVT_CMD_ERROR_SEVERITY

1001

`define SVT_CMD_FATAL_SEVERITY

1000

Values (constants) used as arguments for commands utilizing a severity argument

`define SVT_CMD_FIRM

`define SVT_CMD_FIRM_RST

`define SVT_CMD_HARD

`define SVT_CMD_HARD_RST

`define SVT_CMD_NONE_VERBOSITY

1008

Values (constants) used as arguments for commands utilizing a verbosity argument

`define SVT_CMD_NORMAL_SEVERITY

1003

`define SVT_CMD_NORMAL_VERBOSITY

1009

`define SVT_CMD_NULL_HANDLE

-1

Null handle which can be used to indicate that a data search should take place at the top level object, and not a contained object

`define SVT_CMD_PROTOCOL_RST

`define SVT_CMD_RESET_HANDLE

-2

Reset handle which can be used to indicate that a reset has taken place and that the testbench should update in accordance with this event.

`define SVT_CMD_SOFT

`define SVT_CMD_SOFT_RST

`define SVT_CMD_TRACE_SEVERITY

1004

`define SVT_CMD_TRACE_VERBOSITY

1010

`define SVT_CMD_VERBOSE_SEVERITY

1006

`define SVT_CMD_VERBOSE_VERBOSITY

1012

`define SVT_CMD_WARNING_SEVERITY

1002

`define SVT_CMD_XACT_STATUS_ABORTED

`define SVT_CMD_XACT_STATUS_ACCEPT

`define SVT_CMD_XACT_STATUS_ACTIVE

`define SVT_CMD_XACT_STATUS_CANCELLED

`define SVT_CMD_XACT_STATUS_DISABLED

`define SVT_CMD_XACT_STATUS_INITIAL

`define SVT_CMD_XACT_STATUS_PARTIAL_ACCEPT

`define SVT_CMD_XACT_STATUS_RETRY

`define SVT_COMPLETE

`define SVT_CONSENSUS_BASE_TYPE

svt_consensus

`define SVT_CONTROL_TYPE_STR

"SV"

`define svt_create_event ( evname, evtype )

/* Just drop the evtype */
evname = new(SVT_DATA_UTIL_ARG_TO_STRING(evname));

Macro used to create a notification event instance for the current methodology

`define svt_create_named_event ( evowner, evname, evtype )

evowner.evname = evowner.event_pool.get(SVT_DATA_UTIL_ARG_TO_STRING(evname));

Macro used to create a named notification event instance for the current methodology

`define svt_create_pool_event ( evpool, evname, evtype )

/* Just drop the evtype */
evname = evpool.get(SVT_DATA_UTIL_ARG_TO_STRING(evname));

Macro used to create a notification event instance in the indicated pool for the current methodology

`define SVT_DATA_BASE_OBJECT_TYPE

ovm_object

`define SVT_DATA_BASE_TYPE

ovm_sequence_item

`define SVT_DATA_BYTE_PACK

pack

`define SVT_DATA_BYTE_UNPACK

unpack

`define SVT_DATA_COPY

clone

`define SVT_DATA_DISPLAY ( prefix )

print()

`define SVT_DATA_DISPLAY_KEYWORD

`define SVT_DATA_GET_OBJECT_HIERNAME

get_full_name

`define SVT_DATA_GET_OBJECT_TYPENAME

get_type_name

`define SVT_DATA_ITER_TYPE

svt_sequence_item_base_iter

`define SVT_DATA_LOG_KEYWORD

reporter

`define svt_data_member_begin ( class_type )

/** @cond SVDOC */
ovm_object_utils_begin(class_type)

`define svt_data_member_end ( class_type )

ovm_object_utils_end
/** @endcond */

`define SVT_DATA_METHODOLOGY_KEYWORD

ovm

`define SVT_DATA_METHODOLOGY_KEYWORD_UC

OVM

`define svt_data_param_member_begin ( class_type )

/** @cond SVDOC */
ovm_object_param_utils_begin(class_type)

`define svt_data_param_member_w_type_name_begin ( class_type, class_type_no_params )

/** @cond SVDOC */
  ovm_object_registry_internal(class_type_no_params,class_type_no_params)
  ovm_object_create_func(class_type)
  ovm_get_type_name_func(class_type)
  ovm_field_utils_begin(class_type)

Macro combining the ovm_object_utils_begin and ovm_object_param_utils_begin macro features. Mostly modeled after ovm_object_utils_begin but also designed to provide a 'non-parameterized' type name when registering the object with the factory. This type name, and the type it is associated with, corresponds to the 'default' parameterized object.

`define SVT_DATA_PSDISPLAY ( prefix )

sprint()

`define SVT_DATA_PSDISPLAY_KEYWORD

sprint

`define SVT_DATA_QUEUE_ITER_NOTIFY

event_pool

`define SVT_DATA_QUEUE_ITER_NOTIFY_TYPE

svt_event_pool

`define SVT_DATA_QUEUE_ITER_TYPE

svt_sequence_item_base_queue_iter

`define SVT_DATA_QUEUE_TYPE

svt_sequence_item_base_queue

`define SVT_DATA_SAFE_GETENV

`define SVT_DATA_TYPE

svt_sequence_item_base

`define SVT_DATA_UTIL_ARG_TO_STRING ( str )

`"str`"

`define SVT_DATA_UTIL_BITS_PER_BYTE

`define SVT_DATA_UTIL_BITS_PER_INT

(SVT_DATA_UTIL_BYTES_PER_INT*SVT_DATA_UTIL_BITS_PER_BYTE)

`define SVT_DATA_UTIL_BYTES_PER_ENUM

`define SVT_DATA_UTIL_BYTES_PER_INT

`define SVT_DATA_UTIL_BYTES_PER_LONGINT

`define SVT_DATA_UTIL_BYTES_PER_REAL

`define SVT_DATA_UTIL_BYTES_PER_REALTIME

`define SVT_DATA_UTIL_BYTES_PER_TIME

`define SVT_DATA_UTIL_UNSPECIFIED

`define svt_debug ( id, msg )

do
    if (reporter.ovm_report_enabled(OVM_HIGH,OVM_INFO,id))
      reporter.ovm_report_info(id, msg, OVM_HIGH, ovm_file, ovm_line);
  while (0)

`define svt_debug_context ( id, msg, clientfile, clientline )

`ifdef ovm_info_context
  do
    if ((clientfile != "") || (clientline != 0)) begin
`ifdef OVM_REPORT_DISABLE_FILE
      clientfile = "";
`endif
`ifdef OVM_REPORT_DISABLE_LINE
      clientline = 0;
`endif
      if (reporter.ovm_report_enabled(OVM_HIGH,OVM_INFO,id))
        reporter.ovm_report_info(id, msg, OVM_HIGH, clientfile, clientline);
    end else
      `ovm_info_context(id, msg, OVM_HIGH, reporter)
  while (0)
`else
  svt_debug(id, msg)
`endif

`define SVT_DEBUG_EFFECT

`define SVT_DEBUG_FAIL_EFFECT

SVT_DEBUG_EFFECT

`define SVT_DEBUG_OPTS_CARRIER_CB_UTIL ( T, CB, compinst )

int current_method_triggered_counter[string];

  function bit has_user_cb();
`ifdef SVT_VMM_TECHNOLOGY
    for (int i = 0; (!has_user_cb && (i < compinst.callbacks.size())); i++) begin
      svt_xactor_callback svt_cb;
      if ($cast(svt_cb, compinst.callbacks[i]))
        has_user_cb = compinst.is_user_cb(svt_cb.get_name());
      else
        /* Its not a SNPS callback, so must be a user callback. */
        has_user_cb = 1;
    end
`elsif SVT_UVM_TECHNOLOGY
    uvm_callback_iter#(T, CB) cb_iter = new(compinst);
    CB cb = cb_iter.first();
    has_user_cb = 0;
    while (!has_user_cb && (cb != null)) begin
      has_user_cb = compinst.is_user_cb(cb.get_type_name());
      cb = cb_iter.next();
    end
`elsif SVT_OVM_TECHNOLOGY
    ovm_callbacks#(T, CB) cbs = ovm_callbacks #(T,CB)::get_global_cbs();
    ovm_queue#(CB) cbq = cbs.get(compinst);
    has_user_cb = 0;
    for (int i = 0; !has_user_cb && (cbq != null) && (i < cbq.size()); i++) begin
      CB cb = cbq.get(i);
      has_user_cb = compinst.is_user_cb(cb.get_type_name());
    end
`endif
  endfunction

  function string get_debug_opts_full_name();
    get_debug_opts_full_name = compinst.SVT_DATA_GET_OBJECT_HIERNAME();
  endfunction

  function bit is_debug_enabled();
    is_debug_enabled = compinst.get_is_debug_enabled();
  endfunction

This macro needs to be called by all classes that do callback logging in order to support logging. It should be called within the class declaration, so that the method is available to all cb_exec methods which are implemented within the class.

T -- The component type that the callbacks are registered with. CB -- The callback type that is registered with the component. compinst -- The component instance which the callbacks will be directed through, and which contains a valid 'is_user_cb' (i.e., typically inherited from the SVT component classes) implementation.

`define SVT_DEBUG_OPTS_FILENAME

"svt_debug.out"

`define SVT_DEBUG_OPTS_FSDB_FILE_NAME

"svt_model_log.fsdb"

`define SVT_DEBUG_OPTS_IMP_PORT ( PTYPE, T, IMP )

svt_debug_opts_``PTYPE``_imp_port#(T, IMP, SVT_XVM(PTYPE``_imp)#(T, IMP))

Macro used to create simple imp ports. Used when there is just one imp port of the given type on a component and suffixes are not necessary.

`define SVT_DEBUG_OPTS_IMP_PORT_INTERCEPT_DECL ( PTYPE, IMP, ETYPE )

/** Object used to intercept and log sequence items going through the report when enabled. */
local svt_debug_opts_intercept_``PTYPE#(T,IMP,ETYPE) m_intercept;

Macro used to define the common fields in the imp port intercept objects.

`define SVT_DEBUG_OPTS_IMP_PORT_SFX ( PTYPE, SFX, T, IMP )

svt_debug_opts_``PTYPE``_imp_port#(T, IMP, SVT_XVM(PTYPE``_imp``SFX)#(T, IMP))

Macro used to create imp ports for exports with suffixes. Used when there are multiple imp ports of the same type on a component and the suffix is used to differentiate them.

`define SVT_DEBUG_OPTS_TRANSCRIPT_FILENAME

"svt_debug.transcript"

`define SVT_DEBUG_VERBOSITY

OVM_HIGH

`define SVT_DEC

'h2000000

`define svt_decl_event ( evname )

ovm_event evname;

Macro used to declare a notification event instance for the current methodology

`define SVT_DEEP

'h400

`define SVT_DEEP_RECURSION

Values (constants) representing levels of recursion.

`define SVT_DEFAULT

'b000000101010101

`define SVT_DEFAULT_EFFECT

`define SVT_DEFAULT_FAIL_EFFECT

SVT_DEFAULT_EFFECT

`define SVT_DEFAULT_FUZZY_COMPARE_PRECISION

0.000001

`define SVT_DEFINE_LOG_IN_PORT ( port_number, name, width, in_signal_type, in_skew, ifName, clkName )

begin
  integer sig_depth = 0;
  $fwrite(mcd_log_file, "# P %0d I %0d name %0d %0d %0d %s %s\n",
          port_number, width, in_signal_type, in_skew, sig_depth, ifName, clkName);
end

`define SVT_DEFINE_LOG_INOUT_PORT ( port_number, name, width, in_signal_type, in_skew, out_signal_type, out_skew, ifName, clkName )

begin
  integer sig_depth = 0;
  integer xTime = 0;
  $fwrite(mcd_log_file, "# P %0d X %0d name %0d %0d %0d %0d %0d %0d %s %s\n",
          port_number, width, in_signal_type, out_signal_type, in_skew, out_skew, xTime, sig_depth, ifName, clkName);
end

`define SVT_DEFINE_LOG_OUT_PORT ( port_number, name, width, out_signal_type, out_skew, ifName, clkName )

begin
  integer sig_depth = 0;
  $fwrite(mcd_log_file, "# P %0d O %0d name %0d %0d %0d %s %s\n",
          port_number, width, out_signal_type, out_skew, sig_depth, ifName, clkName);
end

`define SVT_DEFINE_NDRIVE

`define SVT_DEFINE_NSAMPLE

Logging support: Used to log input port changes

`define SVT_DEFINE_PDRIVE

`define SVT_DEFINE_PSAMPLE

`define SVT_DELETE_CB

delete_cb

`define svt_do_callbacks ( T, CB, METHOD )

svt_xvm_do_callbacks(T,CB,METHOD)

`define svt_do_obj_callbacks ( T, CB, OBJ, METHOD )

svt_xvm_do_obj_callbacks(T,CB,OBJ,METHOD)

`define SVT_ENUM

'h8000000

`define SVT_ERR_CHECK_EXECUTE ( errchk, chkstats, testpass, failmsg,faileffect = 5 )

if (testpass) errchk.pass(chkstats);
else errchk.fail(chkstats,failmsg,faileffect);

Macro that can be used to execute a check, but allows for the deferral of the formatting of 'failmsg'

`define SVT_ERR_CHECK_EXECUTE_STATS ( errchk, chkstats, testpass,failmsg = )

SVT_ERR_CHECK_EXECUTE(errchk,chkstats,testpass,failmsg,svt_err_check_stats::DEFAULT)

`define SVT_ERR_CHECK_STATS_COV_EXTENDED_CLASS_DECL ( statsname )

SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_DECL(svt,statsname)

This macro is provided for backwards compatibility. Clients should now use the SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_DECL macro to avoid class name conflicts.

`define SVT_ERR_CHECK_STATS_COV_EXTENDED_CLASS_OVERRIDE ( statsname )

SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE(svt,statsname)

This macro is provided for backwards compatibility. Clients should now use the SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE macro to avoid class name conflicts.

`define SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_DECL ( suiteprefix, statsname )

/** Class declaration of error check stats coverage instance for the protocol check statsname */
    class suiteprefix``_err_check_stats_cov_``statsname extends svt_err_check_stats_cov;
`ifdef SVT_VMM_TECHNOLOGY
`ifndef SVT_PRE_VMM_12
    `vmm_typename(suiteprefix``_err_check_stats_cov_``statsname)
`endif
`endif

`ifndef SVT_ERR_CHECK_STATS_COV_EXCLUDE_STATUS_CG
    covergroup status;
      option.per_instance = 1;
      option.goal = 100;
      pass : coverpoint status_bit iff (enable_pass_cov) {
        bins pass = {1};
`ifdef SVT_MULTI_SIM_IGNORE_BINS
`ifndef SVT_ERR_CHECK_STATS_COV_DISABLE_IGNORE_BINS
        ignore_bins pass_i = {(enable_pass_cov == 1'b0) ? 1'b1 : 1'b0};
`endif
`else
        ignore_bins pass_i = {1} iff (!enable_pass_cov);
`endif
      }
      fail : coverpoint !status_bit iff (enable_fail_cov) {
        bins fail = {1};
`ifdef SVT_MULTI_SIM_IGNORE_BINS
`ifndef SVT_ERR_CHECK_STATS_COV_DISABLE_IGNORE_BINS
        ignore_bins fail_i = {(enable_fail_cov == 1'b0) ? 1'b1 : 1'b0};
`endif
`else
        ignore_bins fail_i = {1} iff (!enable_fail_cov);
`endif
      }
    endgroup
`endif

    extern function new(string name = "");
`ifndef SVT_VMM_TECHNOLOGY
    svt_xvm_object_utils(suiteprefix``_err_check_stats_cov_``statsname)
`endif

`ifdef SVT_VMM_TECHNOLOGY
`ifndef SVT_PRE_VMM_12
    extern virtual function suiteprefix``_err_check_stats_cov_``statsname allocate();

    extern virtual function suiteprefix``_err_check_stats_cov_``statsname copy();
`endif
`endif

    extern virtual function void sample_status(bit status_bit, string message = "");

    extern virtual function void set_unique_id(string unique_id);

    extern static function void override(string inst_path);

    extern static function void direct_override(svt_err_check_stats stats);
`ifdef SVT_VMM_TECHNOLOGY
`ifndef SVT_PRE_VMM_12
    `vmm_class_factory(suiteprefix``_err_check_stats_cov_``statsname)
`endif
`endif
  endclass

  function suiteprefix``_err_check_stats_cov_``statsname::new(string name = "");
    super.new(name, 0);
    /* If client has disabled pass/fail coverage, then don't create the covergroup */
    if ((svt_err_check_stats_cov::initial_enable_pass_cov != 0) || (svt_err_check_stats_cov::initial_enable_fail_cov != 0)) begin
`ifndef SVT_ERR_CHECK_STATS_COV_EXCLUDE_STATUS_CG
      status = new();
`ifdef SVT_ERR_CHECK_STATS_COV_DISABLE_IGNORE_BINS
      /* NOTE: Some older versions of Incisive (i.e., prior to 12.10.005) require the goal to */
      /* be a constant if it is set in the covergroup definition. So set it here instead. */
      status.option.goal = 50*(enable_pass_cov+enable_fail_cov);
`endif
`endif
`ifndef SVT_MULTI_SIM_COVERAGE_IFF_SHAPING
      shape_cov();
`endif
    end

  endfunction

`ifdef SVT_VMM_TECHNOLOGY
`ifndef SVT_PRE_VMM_12
  function suiteprefix``_err_check_stats_cov_``statsname suiteprefix``_err_check_stats_cov_``statsname::allocate();
    allocate = new(this.get_object_name());
  endfunction

  function suiteprefix``_err_check_stats_cov_``statsname suiteprefix``_err_check_stats_cov_``statsname::copy();
    copy = new(this.get_object_name());
    copy.set_enable_pass_cov(this.enable_pass_cov);
    copy.set_enable_fail_cov(this.enable_fail_cov);
  endfunction

`endif
`endif

  function void suiteprefix``_err_check_stats_cov_``statsname::sample_status(bit status_bit, string message = "");
    this.status_bit = status_bit;
`ifndef SVT_ERR_CHECK_STATS_COV_EXCLUDE_STATUS_CG
    status.sample();
`endif
  endfunction

  function void suiteprefix``_err_check_stats_cov_``statsname::set_unique_id(string unique_id);
`ifndef SVT_ERR_CHECK_STATS_COV_EXCLUDE_STATUS_CG
    /* Make sure the unique_id doesn't have any spaces in it -- otherwise get warnings */
    `SVT_DATA_UTIL_REPLACE_PATTERN(unique_id," ", "_");
    status.set_inst_name({unique_id,"_status"});
`endif
  endfunction

  function void suiteprefix``_err_check_stats_cov_``statsname::override(string inst_path);
`ifdef SVT_VMM_TECHNOLOGY
`ifndef SVT_PRE_VMM_12
    /* Set initial pass/fail cov values to 0, since VMM is going to create a dummy instance and we don't want a dummy covergroup */
    svt_err_check_stats_cov::initial_enable_pass_cov = 0;
    svt_err_check_stats_cov::initial_enable_fail_cov = 0;
    svt_err_check_stats_cov::override_with_new(inst_path, suiteprefix``_err_check_stats_cov_``statsname::this_type(),shared_log);
    svt_err_check_stats_cov::override_with_copy(inst_path, suiteprefix``_err_check_stats_cov_``statsname::this_type(),shared_log);
    /* Restore the initial pass/fail cov values to their favored defaults */
    svt_err_check_stats_cov::initial_enable_pass_cov = 0;
    svt_err_check_stats_cov::initial_enable_fail_cov = 1;
`endif
`else
    svt_err_check_stats_cov::type_id::set_inst_override(suiteprefix``_err_check_stats_cov_``statsname::get_type(),inst_path);
`endif
  endfunction

  function void suiteprefix``_err_check_stats_cov_``statsname::direct_override(svt_err_check_stats stats);
`ifdef SVT_VMM_TECHNOLOGY
`ifndef SVT_PRE_VMM_12
    suiteprefix``_err_check_stats_cov_``statsname factory = null;
    /* Set initial pass/fail cov values to 0, since VMM is going to create a dummy instance and we don't want a dummy covergroup */
    svt_err_check_stats_cov::initial_enable_pass_cov = 0;
    svt_err_check_stats_cov::initial_enable_fail_cov = 0;
    factory = new();
    stats.register_cov_override(factory);
    /* Restore the initial pass/fail cov values to their favored defaults */
    svt_err_check_stats_cov::initial_enable_pass_cov = 0;
    svt_err_check_stats_cov::initial_enable_fail_cov = 1;
`endif
`else
    stats.register_cov_override(suiteprefix``_err_check_stats_cov_``statsname::get_type());
`endif
  endfunction

This macro declares a class by the name _err_check_stats_cov_. 'suiteprefix' should be the suite prefix (e.g., 'svt_pcie') or a more specific component prefix (e.g., 'svt_pcie_tl'). 'statsname' should to the check_id_str value assigned to the stats instance by the developer.

The resulting class is extended from the svt_err_check_stats_cov.sv class.

This class includes its own base class covergroup definition, as well as "allocate", "copy", "sample_status", and "set_unique_id" methods, which pertain to the "status" covergroup.

It relies on an additional "override" strategy which involves a call to svt_err_check_stats :: register_cov_override. This call establishes an object wrapper for the svt_err_check_stats_cov class extension so that it can be used to create the new class type coverage is added to the svt_err_check_stats instance.

Usage of the "override" method:

1. User creates the svt_err_check_stats class instance. 2. Calls the "register_check" method for the check. 3. Call the svt_err_check_stats :: register_cov_override method with an object wrapper for the svt_err_check_stats_cov class instance which provides the overide.

Note that the override should normally be done by using the SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE macro.

`define SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_OVERRIDE ( suiteprefix, statsname )

suiteprefix``_err_check_stats_cov_``statsname::direct_override(statsname);

Macro that can be used to setup the class override for a specific svt_err_check_stats class instance, identified by statsname, to use the corredponding coverage class defined using the SVT_ERR_CHECK_STATS_COV_PREFIX_EXTENDED_CLASS_DECL macro. Note that this macro relies on the statsname being used for both the 'check_id_str' provided to the original svt_err_check_stats constructor, as well as the name given to the svt_err_check_stats instance in the local scope.

`define SVT_ERR_CHECK_STATS_ENABLE_EXTENDED_BASE_NAME

`define svt_error ( id, msg )

do
    begin
      if (reporter.ovm_report_enabled(OVM_NONE,OVM_ERROR,id))
        reporter.ovm_report_error(id, msg, OVM_NONE, ovm_file, ovm_line);
    end
  while (0)

`define svt_error_context ( id, msg, clientfile, clientline )

`ifdef ovm_error_context
  do
    if ((clientfile != "") || (clientline != 0)) begin
`ifdef OVM_REPORT_DISABLE_FILE
      clientfile = "";
`endif
`ifdef OVM_REPORT_DISABLE_LINE
      clientline = 0;
`endif
      if (reporter.ovm_report_enabled(OVM_NONE,OVM_ERROR,id))
        reporter.ovm_report_error(id, msg, OVM_NONE, clientfile, clientline);
    end else
      `ovm_error_context(id, msg, reporter)
  while (0)
`else
  svt_error(id, msg)
`endif

`define SVT_ERROR_EFFECT

`define SVT_ERROR_FAIL_EFFECT

SVT_ERROR_EFFECT

`define SVT_ERROR_VERBOSITY

OVM_NONE

`define svt_event_is_on ( evowner, evname )

evowner.evname.is_on()

Macro used to check the is_on state for a notification event in the current methodology.

`define svt_event_status ( evowner, evname )

evowner.evname.get_trigger_data()

Macro used to use the notification event accessor function for the current methodology to retrieve the status for the notification event

`define SVT_EXCEPTION_LIST_COMBINE_NOT_OK ( excep_list1, except_list2 )

((excep_list1 != null) &&
   (excep_list1.num_exceptions != 0) &&
   (!excep_list1.enable_combine) &&
   (except_list2 != null) &&
   (!except_list2.enable_combine))

Does the appropriate logical compares to determine if 2 exception lists are NOT allowed to be merged/combined. Expected 'general' usage is shown below.

excep_list1 is .exception_list
excep_list2 is the randomized_*_exception_list factory

if (excep2_list == null)
`svt_verbose("randomize_*_exception_list", "is null, no exceptions will be generated.");
else if `SVT_EXCEPTION_LIST_COMBINE_NOT_OK(excep_list1,except_list2) begin
`svt_verbose("randomize_*_exception_list", "cannot be combined with .exception_list.");
end else begin
// Logic to do the randomization of the exceptions to be added
// and then combine the two lists.
//
// If one list has (enable_combine == 1) then the final exception_list
// is to have (enable_combine == 1) also.
end

`define SVT_EXCEPTION_LIST_UNSAFE_ARRAY_DO_COPY

The EA and 1.0 version of UVM include an array 'copy' issue that we need to workaround. Set a flag to indicate whether this workaround is needed

`define SVT_EXPECTED_EFFECT

`define SVT_EXPECTED_FAIL_EFFECT

SVT_EXPECTED_EFFECT

`define svt_fatal ( id, msg )

do
    if (reporter.ovm_report_enabled(OVM_NONE,OVM_FATAL,id))
      reporter.ovm_report_fatal(id, msg, OVM_NONE, ovm_file, ovm_line);
  while (0)

`define svt_fatal_context ( id, msg, clientfile, clientline )

`ifdef ovm_fatal_context
  do
    if ((clientfile != "") || (clientline != 0)) begin
`ifdef OVM_REPORT_DISABLE_FILE
      clientfile = "";
`endif
`ifdef OVM_REPORT_DISABLE_LINE
      clientline = 0;
`endif
      if (reporter.ovm_report_enabled(OVM_NONE,OVM_FATAL,id))
        reporter.ovm_report_fatal(id, msg, OVM_NONE, clientfile, clientline);
    end else
      `ovm_fatal_context(id, msg, reporter)
  while (0)
`else
  svt_fatal(id, msg)
`endif

`define SVT_FATAL_VERBOSITY

OVM_NONE

`define svt_field_aa_int_byte ( ARG, FLAG )

ovm_field_aa_int_byte(ARG, FLAG)

`define svt_field_aa_int_byte_unsigned ( ARG, FLAG )

ovm_field_aa_int_byte_unsigned(ARG, FLAG)

`define svt_field_aa_int_int ( ARG, FLAG )

ovm_field_aa_int_int(ARG, FLAG)

`define svt_field_aa_int_int_unsigned ( ARG, FLAG )

ovm_field_aa_int_int_unsigned(ARG, FLAG)

`define svt_field_aa_int_integer ( ARG, FLAG )

ovm_field_aa_int_integer(ARG, FLAG)

`define svt_field_aa_int_integer_unsigned ( ARG, FLAG )

ovm_field_aa_int_integer_unsigned(ARG, FLAG)

`define svt_field_aa_int_key ( KEY, ARG, FLAG )

ovm_field_aa_int_key(KEY, ARG, FLAG)

`define svt_field_aa_int_longint ( ARG, FLAG )

ovm_field_aa_int_longint(ARG, FLAG)

`define svt_field_aa_int_longint_unsigned ( ARG, FLAG )

`ovm_field_aa_string_int(ARG, FLAG)

`define svt_field_aa_int_shortint ( ARG, FLAG )

ovm_field_aa_int_shortint(ARG, FLAG)

`define svt_field_aa_int_shortint_unsigned ( ARG, FLAG )

ovm_field_aa_int_shortint_unsigned(ARG, FLAG)

`define svt_field_aa_int_string ( ARG, FLAG )

ovm_field_aa_int_string(ARG,FLAG)

`define svt_field_aa_object_int ( ARG, FLAG, HOW )

ovm_field_aa_object_int(ARG, FLAG)

`define svt_field_aa_object_string ( ARG, FLAG, HOW )

ovm_field_aa_object_string(ARG,FLAG)

`define svt_field_aa_string_int ( ARG, FLAG )

`ovm_field_aa_string_int(ARG, FLAG)

`define svt_field_aa_string_string ( ARG, FLAG )

ovm_field_aa_string_string(ARG,FLAG)

`define svt_field_array_enum ( T, ARG, FLAG )

ovm_field_array_enum(T,ARG,FLAG)

`define svt_field_array_int ( ARG, FLAG )

ovm_field_array_int(ARG,FLAG)

`define svt_field_array_object ( ARG, FLAG, HOW )

ovm_field_array_object(ARG,FLAG)

`define svt_field_array_real ( ARG, FLAG )

ovm_field_array_real(ARG,FLAG)

`define svt_field_array_string ( ARG, FLAG )

ovm_field_array_string(ARG,FLAG)

`define svt_field_enum ( T, ARG, FLAG )

ovm_field_enum(T,ARG,FLAG)

`define svt_field_event ( ARG, FLAG )

ovm_field_event(ARG,FLAG)

`define svt_field_handle ( ARG, FLAG )

ovm_field_object(ARG,FLAG|OVM_REFERENCE)

`define svt_field_handle_aa_int ( ARG, FLAG )

ovm_field_aa_object_int(ARG, FLAG|OVM_REFERENCE)

`define svt_field_handle_aa_string ( ARG, FLAG )

ovm_field_aa_object_string(ARG, FLAG|OVM_REFERENCE)

`define svt_field_handle_array ( ARG, FLAG )

ovm_field_array_object(ARG,FLAG|OVM_REFERENCE)

`define svt_field_handle_sarray ( ARG, FLAG )

ovm_field_sarray_object(ARG,FLAG|OVM_REFERENCE)

`define svt_field_int ( ARG, FLAG )

ovm_field_int(ARG,FLAG)

`define svt_field_object ( ARG, FLAG, HOW )

ovm_field_object(ARG,FLAG)

`define svt_field_queue_enum ( T, ARG, FLAG )

ovm_field_queue_enum(T,ARG,FLAG)

`define svt_field_queue_handle ( ARG, FLAG )

ovm_field_queue_object(ARG, FLAG|OVM_REFERENCE)

`define svt_field_queue_int ( ARG, FLAG )

ovm_field_queue_int(ARG,FLAG)

`define svt_field_queue_object ( ARG, FLAG, HOW )

ovm_field_queue_object(ARG,FLAG)

`define svt_field_queue_real ( ARG, FLAG )

ovm_field_queue_real(ARG,FLAG)

`define svt_field_queue_string ( ARG, FLAG )

ovm_field_queue_string(ARG,FLAG)

`define svt_field_real ( ARG, FLAG )

svt_field_real_begin
ovm_field_real(ARG,FLAG)
svt_field_real_end

`define svt_field_real_begin

`ifdef SVT_MULTI_SIM_REAL_COMPARE_TOO_PRECISE
  if (what__ == OVM_COMPARE) begin
    svt_sequence_item_base seq_item_base;
    if ($cast(seq_item_base, this)) begin
      seq_item_base.substitute_fuzzy_real_comparer(ovm_auto_options_object);
    end
  end
`endif

`define svt_field_real_end

`ifdef SVT_MULTI_SIM_REAL_COMPARE_TOO_PRECISE
  if (what__ == OVM_COMPARE) begin
    svt_sequence_item_base seq_item_base;
    if ($cast(seq_item_base, this)) begin
      seq_item_base.restore_real_comparer(ovm_auto_options_object);
    end
  end
`endif

`define svt_field_sarray_enum ( T, ARG, FLAG )

ovm_field_sarray_enum(T,ARG,FLAG)

`define svt_field_sarray_int ( ARG, FLAG )

ovm_field_sarray_int(ARG,FLAG)

`define svt_field_sarray_object ( ARG, FLAG, HOW )

ovm_field_sarray_object(ARG,FLAG)

`define svt_field_sarray_real ( ARG, FLAG )

ovm_field_sarray_real(ARG,FLAG)

`define svt_field_sarray_string ( ARG, FLAG )

ovm_field_sarray_string(ARG,FLAG)

`define svt_field_string ( ARG, FLAG )

ovm_field_string(ARG,FLAG)

`define SVT_FIFO_ADD_TO_ACTIVE

`define SVT_FIFO_EMPTY_ON_START

`define SVT_FIFO_FULL_ON_START

`define SVT_FIFO_MAX_FULL_LEVEL

256

`define SVT_FIFO_MAX_RATE

256

`define SVT_FIFO_READ

`define SVT_FIFO_REMOVE_FROM_ACTIVE

`define SVT_FIFO_WRITE

`define svt_fsm_create_fsm ( T, _fsm, _name )

begin
$cast(_fsm, create_fsm(T::__type::get(), _name));
end

Create a sub-FSM of the specified type with the specified name in the specified variable. Must be used in the svt_fsm :: build method.

`define svt_fsm_create_state ( T, _st )

begin
$cast(_st, m_create_state(T::__type::get()));
_st.set_fsm(this);
end

Create a state of the specified type in the specified variable. Must be used in the svt_fsm :: build method.

`define svt_fsm_from_states ( _st )

protected virtual function void m_incoming_states(ref svt_fsm_state_base state_q[$]);
  svt_fsm_state_base new_q[$] = _st;
  super.m_incoming_states(state_q);
  state_q = {state_q, new_q};
endfunction

Short-hand macro for defining the set of states than can transition into this state. Simply appends the specified array litteral of states to the list of incoming states specified by the base class. Must be specified within the state definition class, instead of explicitly implementing the svt_fsm_state_base :: m_incoming_states method.

`define svt_fsm_state_utils ( __T )

`svt_type_factory_item(__T, svt_fsm_state_base)
virtual function string get_class_name(); return SVT_DATA_UTIL_ARG_TO_STRING(__T); endfunction

Automatically include the required support code for the specified FSM state type. Must be called in the FSM state class.

`define SVT_FSM_TRANSITION_OPTIONS_EXIST

The following define is provided to let clients know that this version of the FSM implementation includes support for different transition options, as defined by svt_fsm_state_base :: state_transition_options_enum. Prior to these options being available the only supported transition choice was svt_fsm_state_base :: EXTERNAL_INTERRUPT_NEXT.

With the addition of these options VIPs can improve their performance by updating to support and utilize the svt_fsm_state_base :: INTERNAL_INTERRUPT_NEXT transition choice.

`define svt_fsm_utils ( __T )

`svt_type_factory_item(__T, svt_fsm)

Automatically include the required support code for the specified FSM type. Must be called in the FSM class.

`define svt_get_event_status ( evowner, evname, evstatus )

evstatus = svt_event_status(evowner,evname);

Macro used to get the notification event status

`define SVT_GET_GLOBAL_CBS

get_global_cbs

`define svt_get_named_event_is_on ( evowner, evname, ison )

ison = svt_event_pool::get_event_is_on(evowner.event_pool, SVT_DATA_UTIL_ARG_TO_STRING(evname));

Macro used to check the is_on state for a named notification event in the current methodology.

`define svt_get_named_event_status ( evowner, evname, evstatus )

evstatus = svt_event_pool::get_event_trigger_data(evowner.event_pool, SVT_DATA_UTIL_ARG_TO_STRING(evname));

Macro used to get the named notification event status

`define SVT_HEX

'h5000000

`define SVT_HOW_DEEP

'h024

`define SVT_HOW_DEEPCOMPARE

'h020

`define SVT_HOW_DEEPCOPY

'h004

`define SVT_HOW_NOCOMPARE

'h008

`define SVT_HOW_NOCOPY

'h001

`define SVT_HOW_NONE

'h009

`define SVT_HOW_REF

'h012

`define SVT_HOW_REFCOMPARE

'h010

`define SVT_HOW_REFCOPY

'h002

`define SVT_HOW_TO_COMPARE

'h038

`define SVT_HOW_TO_COPY

'h007

`define SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING ( depth )

SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_DECL
SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_IMPL(,depth)

Executing this macro in an interface provides an interface accessible method that can be used to enable fsdb dumping of the interface.

The 'depth' argument can be used to define the depth of dumping which is to be enabled. The expectation is '1' for interfaces without any hierarchy. Hierarchical interfaces should provide a value corresponding to the overall interface depth.

`define SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_DECL

`ifdef SVT_FSDB_ENABLE
  bit enable_signal_log = 0;

  function void set_enable_signal_log();
    enable_signal_log = 1;
  endfunction
`else
  function void set_enable_signal_log();
    /** Provide a no-op that clients can call safely when FSDB not enabled. */
  endfunction
`endif

Calling this macro in an interface or module declares a variable and a method for controlling whether FSDB dumping is enabled. Modules should call this macro directly. Interfaces use will call this macro indirectly when they use call SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING.

`define SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_IMPL ( triggerpath, depth )

/** Full path to this interface or module instance */
  string full_name;
  initial full_name = $sformatf("%m");

  /** Simple method for getting the full path for an interface or module. */
  function string get_full_name();
    get_full_name = full_name;
  endfunction

  SVT_IF_UTIL_WAIT_ENABLE_SIGNAL_LOG(triggerpath,depth)

Calling this macro in a module or interface adds an initial block that will enable fsdb dumping of the module or interface when the enable_signal_log variable in the object indicated by 'triggerpath' is set. Modules should call this macro directly, in concert with SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_DECL. Interfaces use this macro indirectly when they call SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING.

The client must set the enable_signal_log value in the object indicated by 'triggerpath' by calling the 'set_enable_signal_log' method on the object when it knows the module or interface dumping is desired. The 'depth' argument can be used to define the depth of dumping which is to be enabled. The expectation is that it will be '1' for all modules and for any interfaces without any hierarchy. Hierarchical interfaces should provide a value corresponding to the overall interface depth.

`define SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_VLOG_2001_IMPL ( triggerpath )

/** Full path to this interface or module instance */
  reg [80*8:1] full_name;
  initial full_name = $sformatf("%m");

  /** Simple method for getting the full path for an interface or module. */
  function reg [80*8:1] get_full_name();
    get_full_name = full_name;
  endfunction

  SVT_IF_UTIL_WAIT_ENABLE_SIGNAL_LOG(triggerpath,1)

NOTE: The following macro is the same as SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_IMPL, but has been designed to be acceptable in a VLOG module where verilog2001 syntax is being enforced for all VLOG modules. Note that on Questa we actually just defer to the base SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_IMPL macro.

Calling this macro in a module adds an initial block that will enable fsdb dumping of the module or interface when the enable_signal_log variable in the object indicated by 'triggerpath' is set. Modules should call this macro directly, in concert with SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_DECL.

Note that unlike SVT_IF_UTIL_SUPPORT_SIGNAL_LOGGING_IMPL, since this macro is aimed at modules, it does not support a 'depth' option.

`define SVT_IF_UTIL_WAIT_ENABLE_SIGNAL_LOG ( triggerpath, depth )

`ifdef SVT_FSDB_ENABLE
  initial begin
`ifdef QUESTA
    /* On questa accessing the concatenated string directly results in an 'argument is invalid' message. */
    /* So we put '{"+fsdbfile+",SVT_DEBUG_OPTS_FSDB_FILE_NAME}' into a local 'fsdbfile_plus_filename' variable to avoid the error. */
    static reg [80*8:1] fsdbfile_plus_filename = {"+fsdbfile+",SVT_DEBUG_OPTS_FSDB_FILE_NAME};
`endif
    wait(triggerpath``enable_signal_log == 1);
`ifdef SVT_IF_UTIL_DISABLE_DEFAULT_FSDB
    /* Use the 'no_default' switch, available with Verdi 2016.06, to */
    /* identify that the DEBUG_OPTS FSDB file should not become the */
    /* default for all signal storage. This reserves the file for our */
    /* interface/module signal information, and ensures that the user */
    /* signal information is excluded. */
    $fsdbDumpfile(SVT_DEBUG_OPTS_FSDB_FILE_NAME, "+no_default");
`endif
`ifdef QUESTA
    $fsdbDumpvars(depth,$sformatf("%m"),"+all",fsdbfile_plus_filename);
`else
    $fsdbDumpvars(depth,$sformatf("%m"),"+all",{"+fsdbfile+",SVT_DEBUG_OPTS_FSDB_FILE_NAME});
`endif
  end
`endif

Utility macro used to setup an initial block to initiate FSDB signal logging once the client specified trigger has been fired. Acts as a no-op if FSDB support not enabled.

`define SVT_IGNORE_EFFECT

Constants used to indicate the pass or fail effect for a check..

`define SVT_IGNORE_FAIL_EFFECT

SVT_IGNORE_EFFECT

DEPRECATED: The original error check constants, stated in terms of fail, but used for both pass and fail.

`define svt_insuppressible_note ( id, msg )

do
    /* The check to see if the report is enabled is skipped because we always want to generate this message. */
    reporter.ovm_report_info(id, msg, OVM_NONE, ovm_file, ovm_line);
  while (0)

`define svt_internal_error ( id, msg )

`ifdef SVT_INTERNAL_MESSAGING
svt_error(id, msg)
`else
svt_verbose(id, msg)
`endif

This macro is used to flag issues which we want to catch during internal development, but which we are willing to live with at the customer site. In these situations its an 'error' internally, but just a verbose message externally.

`define SVT_INTERNAL_MESSAGING

`define svt_internal_warning ( id, msg )

`ifdef SVT_INTERNAL_MESSAGING
svt_warning(id, msg)
`else
svt_verbose(id, msg)
`endif

This macro is used to flag issues which we want to catch during internal development, but which we are willing to live with at the customer site. In these situations its a 'warning' internally, but just a verbose message externally.

`define SVT_LOADER_USE_ABS_PATH

`define SVT_MAP_TO_VMM_AUTOMATION_FLAGS ( value )

(DO_ALL &
  (((value) & SVT_NOPRINT) ? ~DO_PRINT : DO_ALL) &
  (((value) & SVT_NOCOPY) ? ~DO_COPY : DO_ALL) &
  (((value) & SVT_NOCOMPARE) ? ~DO_COMPARE : DO_ALL) &
  (((value) & SVT_NOPACK) ? ~(DO_PACK|DO_UNPACK) : DO_ALL))

`define SVT_MAX_ARRAY_ELEM_DISPLAY_DEFAULT

1024

`define SVT_MAX_DELAY

real'('hFFFF_FFFF)

`define SVT_MAX_DOWNSTREAM_IMP_Q_SIZE

`define SVT_MCD_FORMAT_VERSION

`define SVT_MEM_ACTION_CREATE_PATTERN

`define SVT_MEM_ACTION_FILE_DATA

`define SVT_MEM_ACTION_LOAD_FILE

`define SVT_MEM_ACTION_PEEK

`define SVT_MEM_ACTION_POKE

`define SVT_MEM_ACTION_READ

`define SVT_MEM_ACTION_TYPE_COUNT

`define SVT_MEM_ACTION_UNLOAD

`define SVT_MEM_ACTION_UNLOAD_ALL

`define SVT_MEM_ACTION_WRITE

`define SVT_MEM_ACTION_WRITE_MASKED

`define SVT_MEM_ATTRIBUTE_ACC_LOCK

'h8

`define SVT_MEM_ATTRIBUTE_INIT

'h2

`define SVT_MEM_ATTRIBUTE_LAST_RD

'h3

`define SVT_MEM_ATTRIBUTE_LAST_WR

'h1

`define SVT_MEM_ATTRIBUTE_OP_MASK

'h80

`define SVT_MEM_ATTRIBUTE_OR

Indicates that the attribute operation should 'OR' values.

`define SVT_MEM_ATTRIBUTE_UNINIT

'h0

`define SVT_MEM_ATTRIBUTE_WR_PROT

'h4

`define SVT_MEM_BD_SVR_DO_E ( R )

mem_core.get_is_4state()?mem_core.svr_4state.R:mem_core.svr_2state.R

`define SVT_MEM_BD_SVR_DO_LR ( L, R )

if (mem_core.get_is_4state()) L=mem_core.svr_4state.R; else L=mem_core.svr_2state.R

`define SVT_MEM_BD_SVR_DO_S ( R )

if (mem_core.get_is_4state()) mem_core.svr_4state.R; else mem_core.svr_2state.R

`define SVT_MEM_COMPARE_INTERSECT

`define SVT_MEM_COMPARE_OP_MASK

'h40

`define SVT_MEM_COMPARE_STRICT

`define SVT_MEM_COMPARE_SUBSET

Constants for the compare options supported by backdoor classes

`define SVT_MEM_COMPARE_SUPERSET

`define SVT_MEM_CORE_2STATE

1'b0

`define SVT_MEM_CORE_4STATE

1'b1

`define SVT_MEM_CORE_READ

1'b0

`define SVT_MEM_CORE_WRITE

1'b1

`define svt_mem_debug ( id, msg )

`ifdef SVT_MEM_ENABLE_INTERNAL_MESSAGING
svt_debug(id,msg)
`else
do begin end while(0)
`endif

svt_mem class can use this macro to insure the debug messages they produce are filtered based on the 'SVT_MEM_ENABLE_INTERNAL_MESSAGING' define.

`define SVT_MEM_DEPTH_128GB

`define SVT_MEM_DEPTH_128KB

`define SVT_MEM_DEPTH_128MB

`define SVT_MEM_DEPTH_12GB

`define SVT_MEM_DEPTH_1536MB

`define SVT_MEM_DEPTH_16GB

`define SVT_MEM_DEPTH_16KB

`define SVT_MEM_DEPTH_16MB

`define SVT_MEM_DEPTH_192GB

`define SVT_MEM_DEPTH_192MB

`define SVT_MEM_DEPTH_1_5GB

`define SVT_MEM_DEPTH_1GB

`define SVT_MEM_DEPTH_1MB

`define SVT_MEM_DEPTH_24GB

`define SVT_MEM_DEPTH_24MB

`define SVT_MEM_DEPTH_256GB

`define SVT_MEM_DEPTH_256KB

`define SVT_MEM_DEPTH_256MB

`define SVT_MEM_DEPTH_2GB

`define SVT_MEM_DEPTH_2KB

`define SVT_MEM_DEPTH_2MB

`define SVT_MEM_DEPTH_32GB

`define SVT_MEM_DEPTH_32KB

`define SVT_MEM_DEPTH_32MB

`define SVT_MEM_DEPTH_384MB

`define SVT_MEM_DEPTH_3GB

`define SVT_MEM_DEPTH_48GB

`define SVT_MEM_DEPTH_48MB

`define SVT_MEM_DEPTH_4_5GB

`define SVT_MEM_DEPTH_4GB

`define SVT_MEM_DEPTH_4KB

`define SVT_MEM_DEPTH_4MB

`define SVT_MEM_DEPTH_512KB

`define SVT_MEM_DEPTH_512MB

`define SVT_MEM_DEPTH_64GB

`define SVT_MEM_DEPTH_64KB

`define SVT_MEM_DEPTH_64MB

`define SVT_MEM_DEPTH_6GB

`define SVT_MEM_DEPTH_768MB

`define SVT_MEM_DEPTH_8_5GB

`define SVT_MEM_DEPTH_8GB

`define SVT_MEM_DEPTH_8KB

`define SVT_MEM_DEPTH_8MB

`define SVT_MEM_DEPTH_96GB

`define SVT_MEM_DEPTH_9GB

`define SVT_MEM_DUMP_ALL

'h1

Dump ALL locations in the address range. When not set only the written (i.e., via the bus, a poke, or a load) values will be included in the dump output.

`define SVT_MEM_DUMP_APPEND

'h10

Append the contents to the existing file if found. For internal use only.

`define SVT_MEM_DUMP_NO_BEGIN

'h4

Exclude the BEGIN from the file output. Used with append when BEGIN not required.

`define SVT_MEM_DUMP_NO_END

'h8

Exclude the END from the file output. Used with append when END not required.

`define SVT_MEM_DUMP_NO_HEADER

'h2

Exclude the dump file text header. Note that with MIF this will exclude WIDTH and other settings.

`define SVT_MEM_DUMP_OP_MASK

'h8

`define SVT_MEM_FREE_OP_MASK

'h10

`define SVT_MEM_INIT_ADDRESS

`define SVT_MEM_INIT_DECR

`define SVT_MEM_INIT_INCR

`define SVT_MEM_INIT_ONES

`define SVT_MEM_INIT_RANDOM

`define SVT_MEM_INIT_UNKNOWNS

`define SVT_MEM_INIT_USER_PATTERN

`define SVT_MEM_INIT_VALUE

`define SVT_MEM_INIT_ZEROES

`define SVT_MEM_INITIALIZE_CONST

Constants for the initialize options supported by backdoor classes

`define SVT_MEM_INITIALIZE_DECR

`define SVT_MEM_INITIALIZE_INCR

`define SVT_MEM_INITIALIZE_ODD_EVEN_CONST

`define SVT_MEM_INITIALIZE_OP_MASK

'h20

`define SVT_MEM_INITIALIZE_RAND

`define SVT_MEM_INITIALIZE_WALK_LEFT

`define SVT_MEM_INITIALIZE_WALK_RIGHT

`define SVT_MEM_LOAD_OP_MASK

'h4

`define SVT_MEM_LOAD_PROTECT

'h1

Write protect the memory locations in the load file

`define SVT_MEM_MAX_ADDR_REGION_WIDTH

`define SVT_MEM_MAX_ADDR_WDTH

SVT_MEM_MAX_ADDR_WIDTH

`define SVT_MEM_MAX_ADDR_WIDTH

`define SVT_MEM_MAX_ATTR_WIDTH

`define SVT_MEM_MAX_DATA_SIZE

1024

`define SVT_MEM_MAX_DATA_WDTH

SVT_MEM_MAX_DATA_WIDTH

`define SVT_MEM_MAX_DATA_WIDTH

1024

`define SVT_MEM_MAX_PATTERN_WIDTH

`define SVT_MEM_MSG_TYPE_DEBUG

'h10

`define SVT_MEM_MSG_TYPE_ERROR

'h02

`define SVT_MEM_MSG_TYPE_FATAL

'h01

`define SVT_MEM_MSG_TYPE_INFO

'h08

`define SVT_MEM_MSG_TYPE_VERBOSE

'h20

`define SVT_MEM_MSG_TYPE_WARN

'h04

`define SVT_MEM_PEEK_OP_MASK

'h1

Mask values for to the currently defined system memory manager operations.

`define SVT_MEM_POKE_OP_MASK

'h2

`define SVT_MEM_SA_2STATE

`define SVT_MEM_SA_4STATE

`define SVT_MEM_SA_ACCESS_READ_MODE

'h0

`define SVT_MEM_SA_ACCESS_STATUS

'h0003

`define SVT_MEM_SA_ACCESS_STATUS_INIT

SVT_MEM_ATTRIBUTE_INIT

`define SVT_MEM_SA_ACCESS_STATUS_LAST_RD

SVT_MEM_ATTRIBUTE_LAST_RD

`define SVT_MEM_SA_ACCESS_STATUS_LAST_WR

SVT_MEM_ATTRIBUTE_LAST_WR

`define SVT_MEM_SA_ACCESS_STATUS_MASK

'hfffffffc

`define SVT_MEM_SA_ACCESS_STATUS_UNINIT

SVT_MEM_ATTRIBUTE_UNINIT

`define SVT_MEM_SA_ACCESS_WRITE_MODE

'h1

`define SVT_MEM_SA_BREAK_EVENT_TYPE_RD

'h0002

`define SVT_MEM_SA_BREAK_EVENT_TYPE_RD_B4_WR

'h0003

`define SVT_MEM_SA_BREAK_EVENT_TYPE_RD_RD_NO_WR

'h0004

`define SVT_MEM_SA_BREAK_EVENT_TYPE_WR

'h0001

`define SVT_MEM_SA_BREAK_EVENT_TYPE_WR_LOST

'h0007

`define SVT_MEM_SA_BREAK_EVENT_TYPE_WR_PROT

'h0008

`define SVT_MEM_SA_BREAK_EVENT_TYPE_WR_SAME

'h0006

`define SVT_MEM_SA_BREAK_EVENT_TYPE_WR_WR

'h0005

`define SVT_MEM_SA_BREAK_FLAG_CMP_ADR

32'h00000010

`define SVT_MEM_SA_BREAK_FLAG_CMP_ATTRS

32'h00000040

`define SVT_MEM_SA_BREAK_FLAG_CMP_DATA

32'h00000020

`define SVT_MEM_SA_BREAK_FLAG_CMP_RD

32'h00000001

`define SVT_MEM_SA_BREAK_FLAG_CMP_WR

32'h00000002

`define SVT_MEM_SA_BREAK_FLAG_ENA_ADR_MASKING

32'h00000100

`define SVT_MEM_SA_BREAK_FLAG_ENA_DATA_MASKING

32'h00000200

`define SVT_MEM_SA_BREAK_FLAG_MASK_CMP_ADR_OUT

32'h00080000

`define SVT_MEM_SA_BREAK_FLAG_MASK_CMP_DATA_RANGE

32'h00070000

`define SVT_MEM_SA_BREAK_FLAG_MASK_DATA_CMP_MASK

32'h00070000

`define SVT_MEM_SA_BREAK_FLAG_MASK_EQ

32'h00010000

`define SVT_MEM_SA_BREAK_FLAG_MASK_GT

32'h00030000

`define SVT_MEM_SA_BREAK_FLAG_MASK_GTE

32'h00050000

`define SVT_MEM_SA_BREAK_FLAG_MASK_LT

32'h00040000

`define SVT_MEM_SA_BREAK_FLAG_MASK_LTE

32'h00060000

`define SVT_MEM_SA_BREAK_FLAG_MASK_NE

32'h00020000

`define SVT_MEM_SA_BREAK_FLAG_NO_STOP

32'h00100000

`define SVT_MEM_SA_BREAK_FLAG_ONESHOT

32'h00020000

`define SVT_MEM_SA_BREAK_FLAG_RD_B4_WR

32'h00002000

`define SVT_MEM_SA_BREAK_FLAG_SELF_DELETING

32'h00040000

`define SVT_MEM_SA_BREAK_FLAG_TEXT

32'h00200000

`define SVT_MEM_SA_BREAK_FLAG_WPE

32'h00001000

`define SVT_MEM_SA_BREAK_FLAG_WR_LOSS

32'h00010000

`define SVT_MEM_SA_BREAK_FLAG_WR_SAME

32'h00008000

`define SVT_MEM_SA_BREAK_FLAG_WR_WR

32'h00004000

`define SVT_MEM_SA_CHECK_ACCESS_ERROR

SVT_MEM_SA_STATUS_ACCESS_ERROR

`define SVT_MEM_SA_CHECK_ACCESS_LOCKED

SVT_MEM_SA_STATUS_ACCESS_LOCKED

`define SVT_MEM_SA_CHECK_ADR_ERR

SVT_MEM_SA_STATUS_ADR_ERR

`define SVT_MEM_SA_CHECK_ALL

`define SVT_MEM_SA_CHECK_DATA_ERR

SVT_MEM_SA_STATUS_DATA_ERR

`define SVT_MEM_SA_CHECK_MISCOMPARE

SVT_MEM_SA_STATUS_MISCOMPARE

`define SVT_MEM_SA_CHECK_PARTIAL_RD

SVT_MEM_SA_STATUS_PARTIAL_RD

`define SVT_MEM_SA_CHECK_RD_B4_WR

SVT_MEM_SA_STATUS_RD_B4_WR

`define SVT_MEM_SA_CHECK_RD_RD_NO_WR

SVT_MEM_SA_STATUS_RD_RD_NO_WR

`define SVT_MEM_SA_CHECK_STD

(SVT_MEM_SA_STATUS_RD_B4_WR |
                                           SVT_MEM_SA_STATUS_PARTIAL_RD |
                                           SVT_MEM_SA_STATUS_ADR_ERR |
                                           SVT_MEM_SA_STATUS_DATA_ERR )

`define SVT_MEM_SA_CHECK_WR_LOSS

SVT_MEM_SA_STATUS_WR_LOSS

`define SVT_MEM_SA_CHECK_WR_PROT

SVT_MEM_SA_STATUS_WR_PROT

`define SVT_MEM_SA_CHECK_WR_SAME

SVT_MEM_SA_STATUS_WR_SAME

`define SVT_MEM_SA_CHECK_WR_WR

SVT_MEM_SA_STATUS_WR_WR

`define SVT_MEM_SA_COMPARE_INTERSECT

'h3

`define SVT_MEM_SA_COMPARE_MAX_FILE_COMPARE_ERRORS

200

`define SVT_MEM_SA_COMPARE_MISCOMPARE

'h1

`define SVT_MEM_SA_COMPARE_MODES

'h3

`define SVT_MEM_SA_COMPARE_NOT_IN_CORE

'h2

`define SVT_MEM_SA_COMPARE_NOT_IN_DEST

'h4

`define SVT_MEM_SA_COMPARE_NOT_IN_FILE

'h3

`define SVT_MEM_SA_COMPARE_NOT_IN_SRC

'h5

`define SVT_MEM_SA_COMPARE_STRICT

'h1

`define SVT_MEM_SA_COMPARE_SUBSET

'h0

`define SVT_MEM_SA_COMPARE_SUPERSET

'h2

`define SVT_MEM_SA_CORE_ADDR_BITS

`define SVT_MEM_SA_CORE_PHYSICAL_DIMENSIONS_MAX

Maximum number of physical addressing dimensions the memserver System Verilog component will handle Set to the maximum currently required by all known memserver clients

`define SVT_MEM_SA_DATAARRAY32

`define SVT_MEM_SA_DATAARRAY8

`define SVT_MEM_SA_DATAARRAYPACKED

`define SVT_MEM_SA_DATAARRAYS64

`define SVT_MEM_SA_DUMP_ALL

SVT_MEM_DUMP_ALL

`define SVT_MEM_SA_DUMP_APPEND

SVT_MEM_DUMP_APPEND

`define SVT_MEM_SA_DUMP_NO_HEADER

SVT_MEM_DUMP_NO_HEADER

`define SVT_MEM_SA_LOAD_NO_PROTECT

'h0

`define SVT_MEM_SA_LOAD_PROTECT

SVT_MEM_LOAD_PROTECT

`define SVT_MEM_SA_MODE_COHERENCE_GET ( m )

(((m)&SVT_MEM_SA_MODE_COHERENCE_MASK)>>6)

`define SVT_MEM_SA_MODE_COHERENCE_MASK

'h000000c0

`define SVT_MEM_SA_MODE_COHERENCE_SET ( val )

(((val)&'h3)<<6)

`define SVT_MEM_SA_MODE_NO_ACCESS_ATTR

'h00000004

`define SVT_MEM_SA_MODE_NO_WPE_ATTR

'h00000002

`define SVT_MEM_SA_MODE_OPT_SPACE_GET ( m )

(((m)&SVT_MEM_SA_MODE_SPACE_MASK)>>4)

`define SVT_MEM_SA_MODE_OPT_SPACE_SET ( val )

(((val)&'h3)<<4)

`define SVT_MEM_SA_MODE_QUIET

'h00000008

`define SVT_MEM_SA_MODE_READ_ONLY

'h00000001

`define SVT_MEM_SA_MODE_SIM_SIZE_GET ( m )

(((m)&SVT_MEM_SA_MODE_SIM_SIZE_MASK)>>8)

`define SVT_MEM_SA_MODE_SIM_SIZE_MASK

'h00000300

`define SVT_MEM_SA_MODE_SIM_SIZE_SET ( val )

(((val)&'h3)<<8)

`define SVT_MEM_SA_MODE_SPACE_MASK

'h00000030

`define SVT_MEM_SA_PATTERN_NON_VIRTUAL

`define SVT_MEM_SA_PATTERN_TYPE_CONST

`define SVT_MEM_SA_PATTERN_TYPE_DECR

`define SVT_MEM_SA_PATTERN_TYPE_INCR

`define SVT_MEM_SA_PATTERN_TYPE_MASK

'h1f

`define SVT_MEM_SA_PATTERN_TYPE_ODD_EVEN_CONST

`define SVT_MEM_SA_PATTERN_TYPE_RAND_DATA

`define SVT_MEM_SA_PATTERN_TYPE_USE_BASE_ADR

'h80

`define SVT_MEM_SA_PATTERN_TYPE_WALK_LEFT

`define SVT_MEM_SA_PATTERN_TYPE_WALK_RIGHT

`define SVT_MEM_SA_PATTERN_VIRTUAL

`define SVT_MEM_SA_PHYSICAL_ADDRESS ( ADDR )

int unsigned ADDR [SVT_MEM_SA_CORE_PHYSICAL_DIMENSIONS_MAX]

`define SVT_MEM_SA_STATUS_ACCESS_ERROR

32'h00000200

`define SVT_MEM_SA_STATUS_ACCESS_LOCKED

32'h00000100

`define SVT_MEM_SA_STATUS_ADR_ERR

32'h00000040

`define SVT_MEM_SA_STATUS_BREAK

32'h20000000

`define SVT_MEM_SA_STATUS_DATA_ERR

32'h00000080

`define SVT_MEM_SA_STATUS_ENABLE_ALL

`define SVT_MEM_SA_STATUS_ERROR

32'h40000000

`define SVT_MEM_SA_STATUS_FORMAT_ERR

32'h00000400

`define SVT_MEM_SA_STATUS_INTERNAL

32'h80000000

`define SVT_MEM_SA_STATUS_IO_ERROR

32'h00002000

`define SVT_MEM_SA_STATUS_MISCOMPARE

32'h00004000

`define SVT_MEM_SA_STATUS_OK

32'h00000000

`define SVT_MEM_SA_STATUS_OPEN_FAILED

32'h00001000

`define SVT_MEM_SA_STATUS_PARTIAL_RD

32'h00000800

`define SVT_MEM_SA_STATUS_RD_B4_WR

32'h00000010

`define SVT_MEM_SA_STATUS_RD_RD_NO_WR

32'h00000001

`define SVT_MEM_SA_STATUS_WR_LOSS

32'h00000002

`define SVT_MEM_SA_STATUS_WR_PROT

32'h00000020

`define SVT_MEM_SA_STATUS_WR_SAME

32'h00000004

`define SVT_MEM_SA_STATUS_WR_WR

32'h00000008

`define SVT_MEM_SA_STATUS_WR_WR_COMPARE

(SVT_MEM_SA_STATUS_WR_LOSS|SVT_MEM_SA_STATUS_WR_SAME)

`define SVT_MEM_SHORTHAND_CUST_COMPARE

`ifdef SVT_VMM_TECHNOLOGY
  if (do_what == DO_COMPARE) begin
    if (!svt_mem_compare_hook(this.__vmm_rhs, this.__vmm_image)) begin
      this.__vmm_status = 0;
    end
  end
`endif

Add some customized logic to compare the actual memory elements

`define SVT_MEM_SHORTHAND_CUST_COPY

`ifdef SVT_VMM_TECHNOLOGY
  if (do_what == DO_COPY) begin
    svt_mem_copy_hook(this.__vmm_rhs);
  end
`endif

Add some customized logic to copy the actual memory elements

`define SVT_MEM_SYSTEM_BACKDOOR_ENABLE_FACTORY

`define svt_mem_vendor_catalog_begin ( __suite, __name )

`define svt___current_suite __suite
`define svt___current_vendor __name

Short-hand macro to define a suite-specific, vendor-specific catalog class and start populating part entries. May be used multiple times to create multiple catalog "pages".

Assumes the existence of a catalog class named svt__vendor_catalog and of a catalog entry class named svt__vendor_part.

`define svt_mem_vendor_catalog_end

`undef svt___current_suite
`undef svt___current_vendor

Short-hand macro for closing a vendor part catalog "page".

`define svt_mem_vendor_part ( __name, __descr, __depth, __width, __speed, __cfg )

svt_mem_vendor_part2(`svt___current_suite, `svt___current_vendor, __name, __descr, __depth, __width, __speed, __cfg)

Short-hand macro for defining a vendor part catalog entry. Must be used between `svt_mem_vendor_catalog_begin and

`undef svt___current_suite `undef svt___current_vendor macros

`define svt_mem_vendor_part2 ( __suite, __vendor, __name, __descr, __depth, __width, __speed, __cfg )

svt_``__suite``_vendor_part __name``__in__``__suite``_``__vendor``_catalog
= new(svt_``__suite``_vendor_catalog::get_vendor(`"__vendor`"), `"__name`", __descr,
SVT_MEM_``__depth, SVT_MEM_``__width, SVT_MEM_``__speed, __cfg);

`define svt_mem_verbose ( id, msg )

`ifdef SVT_MEM_ENABLE_INTERNAL_MESSAGING
svt_verbose(id,msg)
`else
do begin end while(0)
`endif

svt_mem class can use this macro to insure the verbose messages they produce are filtered based on the 'SVT_MEM_ENABLE_INTERNAL_MESSAGING' define.

`define SVT_MESSAGE_MANAGER_ERROR_SEVERITY

SVT_XVM_UC(ERROR)

`define SVT_MESSAGE_MANAGER_FATAL_SEVERITY

SVT_XVM_UC(FATAL)

Simple defines to make it easier to write portable FATAL/ERROR/WARNING requests.

`define SVT_MESSAGE_MANAGER_GET_CLIENT_VERBOSITY_LEVEL ( prefmgrid, defmgrid )

svt_message_manager::facilitate_get_client_verbosity_level(prefmgrid,defmgrid)

Macro used to get the verbosity for the associated message manager.

`define SVT_MESSAGE_MANAGER_NOTE_SEVERITY

SVT_XVM_UC(WARNING)

`define SVT_NO_REGPACK

`define SVT_NOCOMPARE

(1<<3)

`define SVT_NOCOPY

(1<<1)

`define SVT_NODEFPRINT

(1<<16)

`define SVT_NOPACK

(1<<9)

`define SVT_NOPRINT

(1<<5)

`define SVT_NORECORD

(1<<7)

`define SVT_NORMAL_VERBOSITY

OVM_LOW

`define svt_note ( id, msg )

do
    if (reporter.ovm_report_enabled(OVM_LOW,OVM_INFO,id))
      reporter.ovm_report_info(id, msg, OVM_LOW, ovm_file, ovm_line);
  while (0)

`define svt_note_context ( id, msg, clientfile, clientline )

`ifdef ovm_info_context
  do
    if ((clientfile != "") || (clientline != 0)) begin
`ifdef OVM_REPORT_DISABLE_FILE
      clientfile = "";
`endif
`ifdef OVM_REPORT_DISABLE_LINE
      clientline = 0;
`endif
      if (reporter.ovm_report_enabled(OVM_LOW,OVM_INFO,id))
        reporter.ovm_report_info(id, msg, OVM_LOW, clientfile, clientline);
    end else
      `ovm_info_context(id, msg, OVM_LOW, reporter)
  while (0)
`else
  svt_note(id, msg)
`endif

`define SVT_NOTE_EFFECT

`define SVT_NOTE_FAIL_EFFECT

SVT_NOTE_EFFECT

`define SVT_NOTIFY_BASE_TYPE

svt_notify

`define SVT_NOTIFY_CONFIGURE ( methodname, stateclass, notifyname, notifykind )

if (stateclass.notifyname == 0) begin
    stateclass.notifyname = stateclass.notify.configure(, notifykind);
  end else begin
    svt_fatal(SVT_DATA_UTIL_ARG_TO_STRING(methodname), $sformatf("Attempted to configure notify '%0s' twice. Unable to continue.", SVT_DATA_UTIL_ARG_TO_STRING(notifyname)));
  end

This macro can be used to configure a basic notification, independent of the base technology.

`define SVT_NULL_RECURSION

`define SVT_NVS_SOURCE_MAP_SUITE_COMMON_H ( suite, version, common )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/common.h)

`define SVT_NVS_SOURCE_MAP_SUITE_COMMON_SVH ( suite, version, common )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/common.svh)

`define SVT_NVS_SOURCE_MAP_SUITE_COMMON_VI ( suite, version, common )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/common.vi)

`define SVT_NVS_SOURCE_MAP_SUITE_COMMON_VIH ( suite, version, common )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/common.vih)

`define SVT_NVS_SOURCE_MAP_SUITE_COMP_COMMON_VI ( suite, model, version, common )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/model/bfm/include/common.vi)

`define SVT_NVS_SOURCE_MAP_SUITE_COMP_MODULE_V ( suite, model, version, module )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/model/bfm/include/module.v)

`define SVT_NVS_SOURCE_MAP_SUITE_INTERFACE_SV ( suite, version, interface )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/interface.sv)

`define SVT_NVS_SOURCE_MAP_SUITE_LIB_MODULE_V ( suite, version, module )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/module.v)

`define SVT_NVS_SOURCE_MAP_SUITE_MODULE_INCLUDE_V ( suite, version, module )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/verilog/module.v)

`define SVT_NVS_SOURCE_MAP_SUITE_MODULE_INCLUDE_VIH ( suite, version, module )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/include/verilog/module.vih)

`define SVT_NVS_SOURCE_MAP_SUITE_MODULE_V ( suite, version, module )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(suite/src/verilog/module.v)

`define SVT_OCT

'h4000000

`define SVT_PACKER_MAX_BYTES

OVM_PACKER_MAX_BYTES

`define SVT_PHYSICAL

(1<<13)

`define SVT_POUND_ZERO_COUNT

The use of variables on the left-hand side in non-blocking assignments can be problematic for global methods unless they are included in packages or modules. For example if the 'svt_wait_for_nba_region' method is simply loaded in the top level testbench, outside a module or package, VCS will generate the following error:

Error-[DTNBA] Dynamic type in non-blocking assignment..."nba"...Dynamic type (Automatic variable in this case) cannot be used on the left-hand side of non blocking assignment.

As some SVT VIPs have committed to support the use of their VMM versions outside of a package, and since the 'svt_wait_for_nba_region' is not currently required to provide VMM support for any of the SVT VIPs, this method has been excluded in the VMM version of SVT.

Since this feature has been identified as a necessity in UVM/OVM, and since we require that the VIP be loaded via package in these domains, this feature is fully supported in UVM/OVM.

`define SVT_PRE_VMM_11

`define SVT_PRE_VMM_12

`define SVT_READONLY

(1<<16)

`define SVT_REFERENCE

'h1000

`define SVT_REGPACK_ALPHA

`define SVT_RELEVANT

-1

Constants used with operations such as byte_pack, compare, etc., to select the completeness of the action. RELEVANT for protocol specific fields, COMPLETE for all fields.

`define SVT_REPORT_CATCHER_ACTION

action

`define SVT_REPORT_CATCHER_SEVERITY

severity

`define svt_reset_event ( evowner, evname )

/* Only request the wakeup if the event is currently on */
evowner.evname.reset(evowner.evname.is_on());

Macro used to reset a notification event in the current methodology

`define svt_reset_named_event ( evowner, evname )

svt_event_pool::reset_event(evowner.event_pool, SVT_DATA_UTIL_ARG_TO_STRING(evname));

Macro used to reset a named notification event in the current methodology

`define SVT_SEQUENCE_LIBRARY_DECL ( ITEM )

/** Sequence library for ITEM transaction. */
class ITEM``_sequence_library extends svt_sequence_library#(ITEM);
`ifdef SVT_UVM_TECHNOLOGY
  `uvm_object_utils(ITEM``_sequence_library)
  `uvm_sequence_library_utils(ITEM``_sequence_library)
`else
  ovm_object_utils(ITEM``_sequence_library)
`endif
  extern function new (string name = SVT_DATA_UTIL_ARG_TO_STRING(ITEM``_sequence_library));
endclass

THIS MACRO IS BEING DEPRECATED !!!

Clients should instead create sequence libraries manually, using the SVT_SEQUENCE_LIBRARY_SAFE_ADD_SEQUENCE macro to populate the library.

`define SVT_SEQUENCE_LIBRARY_IMP ( ITEM, SUITE )

function ITEM``_sequence_library::new(string name = SVT_DATA_UTIL_ARG_TO_STRING(ITEM``_sequence_library));
super.new(name, SVT_DATA_UTIL_ARG_TO_STRING(SUITE));
`ifdef SVT_UVM_TECHNOLOGY
init_sequence_library();
`endif
endfunction

THIS MACRO IS BEING DEPRECATED !!!

Clients should instead create sequence libraries manually, using the SVT_SEQUENCE_LIBRARY_SAFE_ADD_SEQUENCE macro to populate the library.

`define SVT_SEQUENCE_LIBRARY_SAFE_ADD_SEQUENCE ( seqtype, count )

begin
  seqtype seq = new();
  if (seq.is_applicable(cfg)) begin
    this.add_sequence(seqtype::get_type());
    count++;
  end
end

Macro which can be used to add a sequence to a sequence library, after checking to make sure the sequence is valid relative to the sequence library cfg. When a sequence is added successfully the count variable provided by the caller is incremented to indicate the successful addition.

`define svt_sequence_library_utils ( TYPE )

static protected ovm_object_wrapper m_typewide_sequences[$];

   function void init_sequence_library();
     foreach (TYPE::m_typewide_sequences[i])
       sequences.push_back(TYPE::m_typewide_sequences[i]);
   endfunction

   static function void add_typewide_sequence(ovm_object_wrapper seq_type);
     if (m_static_check(seq_type))
       TYPE::m_typewide_sequences.push_back(seq_type);
   endfunction

   static function bit m_add_typewide_sequence(ovm_object_wrapper seq_type);
     TYPE::add_typewide_sequence(seq_type);
     return 1;
   endfunction

`define SVT_SEQUENCER_DECL ( ITEM, CFG_TYPE )

/**
* This class is Sequencer that provides stimulus for the
* #ITEM``_driver class. The #ITEM``_agent class is responsible
* for connecting this SVT_XVM(sequencer) to the driver if the agent is configured as
* SVT_XVM_UC(ACTIVE).
*/
class ITEM``_sequencer extends svt_sequencer#(ITEM);

  /** @cond PRIVATE */
  /** Configuration object for this sequencer. */
  local CFG_TYPE cfg;
  /** @endcond */

`ifdef SVT_UVM_TECHNOLOGY
  `uvm_component_utils(ITEM``_sequencer)
`else
  ovm_sequencer_utils(ITEM``_sequencer)
`endif

  /**
   * CONSTRUCTOR: Create a new agent instance
   *
   * @param name The name of this instance. Used to construct the hierarchy.
   *
   * @param parent The component that contains this intance. Used to construct
   * the hierarchy.
   */
  extern function new (string name = SVT_DATA_UTIL_ARG_TO_STRING(ITEM``_sequencer), SVT_XVM(component) parent = null);

  /** Build phase */
`ifdef SVT_UVM_TECHNOLOGY
  extern virtual function void build_phase(uvm_phase phase);
`else
  extern virtual function void build();
`endif

  /**
   * Updates the sequencer's configuration with data from the supplied object.
   * NOTE:
   * This operation is different than the reconfigure() methods for svt_driver and
   * svt_monitor classes. This method sets a reference to the original
   * rather than making a copy.
   */
  extern virtual function void reconfigure(svt_configuration cfg);

  /**
   * Returns a reference of the sequencer's configuration object.
   * NOTE:
   * This operation is different than the get_cfg() methods for svt_driver and
   * svt_monitor classes. This method returns a reference to the configuration
   * rather than a copy.
   */
  extern virtual function void get_cfg(ref svt_configuration cfg);

endclass

Macro used to implement a sequencer for the supplied transaction.

`define SVT_SEQUENCER_IMP ( ITEM, SUITE_NAME, CFG_TYPE )

SVT_SEQUENCER_IMP_BASE(ITEM, SVT_DATA_UTIL_ARG_TO_STRING(SUITE_NAME), CFG_TYPE)

Macro used to implement a sequencer for the supplied transaction. This macro should be called from an encrypted portion of the extended file.

`define SVT_SEQUENCER_IMP_BASE ( ITEM, SUITE_STRING, CFG_TYPE )

function ITEM``_sequencer::new(string name = SVT_DATA_UTIL_ARG_TO_STRING(ITEM``_sequencer), SVT_XVM(component) parent = null);
   super.new(name, parent, SUITE_STRING);
endfunction: new

`ifdef SVT_UVM_TECHNOLOGY
function void ITEM``_sequencer::build_phase(uvm_phase phase);
  string method_name = "build_phase";
  super.build_phase(phase);
`elsif SVT_OVM_TECHNOLOGY
function void ITEM``_sequencer::build();
  string method_name = "build";
  super.build();
`endif
  begin
    if (cfg == null) begin
      if (svt_config_object_db#(CFG_TYPE)::get(this, "", "cfg", cfg) && (cfg != null)) begin
        /* If we got it from the config_db, then make a copy of it for use with the internally generated objects */
        if(!($cast(this.cfg, cfg.clone()))) begin
          svt_fatal(method_name, $sformatf("Failed when attempting to cast '%0s'", SVT_DATA_UTIL_ARG_TO_STRING(CFG_TYPE)));
        end
      end else begin
        svt_fatal(method_name, $sformatf("'cfg' is null. An '%0s' object or derivative object must be set using the configuration infrastructure or via reconfigure.",
                                       SVT_DATA_UTIL_ARG_TO_STRING(CFG_TYPE)));
      end
    end
  end
endfunction

function void ITEM``_sequencer::reconfigure(svt_configuration cfg);
  if (!$cast(this.cfg, cfg)) begin
    svt_error("reconfigure", "Failed attempting to assign 'cfg' argument to sequencer 'cfg' field.");
  end
endfunction

function void ITEM``_sequencer::get_cfg(ref svt_configuration cfg);
  cfg = this.cfg;
endfunction

Base macro used to implement a sequencer for the supplied transaction. This macro should be called from an encrypted portion of the extended file, and only if the client needs to provide a 'string' suite name. Clients should normally use the SVT_SEQUENCER_IMP macro instead.

`define SVT_SHALLOW

'h800

`define SVT_SHALLOW_RECURSION

`define SVT_SIMULATOR_STR

"VCS"

`define SVT_SOURCE_MAP_AGENT_CMD_INCLUDE_SVI ( suite, model, version, inclsvi )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/suite/model/include/inclsvi.svi)

`define SVT_SOURCE_MAP_AGENT_INCLUDE_SVI ( suite, model, version, inclsvi )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/suite/model/include/inclsvi.svi)

`define SVT_SOURCE_MAP_ENV_CMD_INCLUDE_SVI ( suite, model, version, inclsvi )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/suite/model/include/inclsvi.svi)

`define SVT_SOURCE_MAP_ENV_INCLUDE_SVI ( suite, model, version, inclsvi )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/suite/model/include/inclsvi.svi)

`define SVT_SOURCE_MAP_LIB_INCLUDE_PKG ( version, incpkg )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/svt/include/incpkg.pkg)

`define SVT_SOURCE_MAP_LIB_INCLUDE_PKG ( version, incpkg )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/svt/include/incpkg.pkg)

`define SVT_SOURCE_MAP_LIB_INCLUDE_PKG ( version, incpkg )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/svt/include/incpkg.pkg)

`define SVT_SOURCE_MAP_LIB_INCLUDE_PKG ( version, incpkg )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/svt/include/incpkg.pkg)

`define SVT_SOURCE_MAP_LIB_INCLUDE_PKG ( version, incpkg )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/svt/include/incpkg.pkg)

`define SVT_SOURCE_MAP_LIB_INCLUDE_PKG ( version, incpkg )

SVT_SOURCE_QUOTE_DESIGNWARE_HOME(vip/svt/include/incpkg.pkg)