Subversion Repositories uart2bus_testbench

//

// -------------------------------------------------------------

//    Copyright 2004-2011 Synopsys, Inc.

//    Copyright 2010-2011 Mentor Graphics Corporation

//    Copyright 2010-2011 Cadence Design Systems, Inc.

//    All Rights Reserved Worldwide

//

//    Licensed under the Apache License, Version 2.0 (the

//    "License"); you may not use this file except in

//    compliance with the License.  You may obtain a copy of

//    the License at

//

//        http://www.apache.org/licenses/LICENSE-2.0

//

//    Unless required by applicable law or agreed to in

//    writing, software distributed under the License is

//    distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR

//    CONDITIONS OF ANY KIND, either express or implied.  See

//    the License for the specific language governing

//    permissions and limitations under the License.

// -------------------------------------------------------------

//

//------------------------------------------------------------------------

// Class: uvm_reg_block

//

// Block abstraction base class

//

// A block represents a design hierarchy. It can contain registers,

// register files, memories and sub-blocks.

//

// A block has one or more address maps, each corresponding to a physical

// interface on the block.

//

//------------------------------------------------------------------------

virtual class uvm_reg_block extends uvm_object;

   local uvm_reg_block  parent;

   local static bit     m_roots[uvm_reg_block];

   local int unsigned   blks[uvm_reg_block];

   local int unsigned   regs[uvm_reg];

   local int unsigned   vregs[uvm_vreg];

   local int unsigned   mems[uvm_mem];

   local bit            maps[uvm_reg_map];

   // Variable: default_path

   // Default access path for the registers and memories in this block.

   uvm_path_e      default_path = UVM_DEFAULT_PATH;

   local string         default_hdl_path = "RTL";

   local uvm_reg_backdoor backdoor;

   local uvm_object_string_pool #(uvm_queue #(string)) hdl_paths_pool;

   local string         root_hdl_paths[string];

   local bit            locked;

   local int            has_cover;

   local int            cover_on;

   local string         fname;

   local int            lineno;

   local static int id;

   //----------------------

   // Group: Initialization

   //----------------------

   // Function: new

   //

   // Create a new instance and type-specific configuration

   //

   // Creates an instance of a block abstraction class with the specified

   // name.

   //

   // ~has_coverage~ specifies which functional coverage models are present in

   // the extension of the block abstraction class.

   // Multiple functional coverage models may be specified by adding their

   // symbolic names, as defined by the  type.

   //

   extern function new(string name="", int has_coverage=UVM_NO_COVERAGE);

   // Function: configure

   //

   // Instance-specific configuration

   //

   // Specify the parent block of this block.

   // A block without parent is a root block.

   //

   // If the block file corresponds to a hierarchical RTL structure,

   // its contribution to the HDL path is specified as the ~hdl_path~.

   // Otherwise, the block does not correspond to a hierarchical RTL

   // structure (e.g. it is physically flattened) and does not contribute

   // to the hierarchical HDL path of any contained registers or memories.

   //

   extern function void configure(uvm_reg_block parent=null,

                                  string hdl_path="");

   // Function: create_map

   //

   // Create an address map in this block

   //

   // Create an address map with the specified ~name~, then

   // configures it with the following properties.

   //

   // base_addr - the base address for the map. All registers, memories,

   //             and sub-blocks within the map will be at offsets to this

   //             address

   //

   // n_bytes   - the byte-width of the bus on which this map is used

   //

   // endian    - the endian format. See  for possible

   //             values

   //

   // byte_addressing - specifies whether consecutive addresses refer are 1 byte

   //             apart (TRUE) or ~n_bytes~ apart (FALSE). Default is TRUE.

   //

   //| APB = create_map("APB", 0, 1, UVM_LITTLE_ENDIAN, 1);

   //

   extern virtual function uvm_reg_map create_map(string name,

                                                  uvm_reg_addr_t base_addr,

                                                  int unsigned n_bytes,

                                                  uvm_endianness_e endian,

                                                  bit byte_addressing = 1);

   // Function: check_data_width

   //

   // Check that the specified data width (in bits) is less than

   // or equal to the value of `UVM_REG_DATA_WIDTH

   //

   // This method is designed to be called by a static initializer

   //

   //| class my_blk extends uvm_reg_block;

   //|   local static bit m_data_width = check_data_width(356);

   //|   ...

   //| endclass

   //

   extern protected static function bit check_data_width(int unsigned width);

   // Function: set_default_map

   //

   // Defines the default address map

   //

   // Set the specified address map as the  for this

   // block. The address map must be a map of this address block.

   //

   extern function void set_default_map (uvm_reg_map map);

   // Variable: default_map

   //

   // Default address map

   //

   // Default address map for this block, to be used when no

   // address map is specified for a register operation and that

   // register is accessible from more than one address map.

   //

   // It is also the implicit address map for a block with a single,

   // unnamed address map because it has only one physical interface.

   //

   uvm_reg_map default_map;

   extern function uvm_reg_map get_default_map ();

   extern virtual function void set_parent(uvm_reg_block parent);

   /*local*/ extern function void add_block (uvm_reg_block blk);

   /*local*/ extern function void add_map   (uvm_reg_map map);

   /*local*/ extern function void add_reg   (uvm_reg  rg);

   /*local*/ extern function void add_vreg  (uvm_vreg vreg);

   /*local*/ extern function void add_mem   (uvm_mem  mem);

   // Function: lock_model

   //

   // Lock a model and build the address map.

   //

   // Recursively lock an entire register model

   // and build the address maps to enable the

   //  and

   //  methods.

   //

   // Once locked, no further structural changes,

   // such as adding registers or memories,

   // can be made.

   //

   // It is not possible to unlock a model.

   //

   extern virtual function void lock_model();

   // Function: is_locked

   //

   // Return TRUE if the model is locked.

   //

   extern function bit is_locked();

   //---------------------

   // Group: Introspection

   //---------------------

   // Function: get_name

   //

   // Get the simple name

   //

   // Return the simple object name of this block.

   //

   // Function: get_full_name

   //

   // Get the hierarchical name

   //

   // Return the hierarchal name of this block.

   // The base of the hierarchical name is the root block.

   //

   extern virtual function string get_full_name();

   // Function: get_parent

   //

   // Get the parent block

   //

   // If this a top-level block, returns ~null~.

   //

   extern virtual function uvm_reg_block get_parent();

   // Function: get_root_blocks

   //

   // Get the all root blocks

   //

   // Returns an array of all root blocks in the simulation.

   //

   extern static  function void get_root_blocks(ref uvm_reg_block blks[$]);

   // Function: find_blocks

   //

   // Find the blocks whose hierarchical names match the

   // specified ~name~ glob.

   // If a ~root~ block is specified, the name of the blocks are

   // relative to that block, otherwise they are absolute.

   //

   // Returns the number of blocks found.

   //

   extern static function int find_blocks(input string        name,

                                          ref   uvm_reg_block blks[$],

                                          input uvm_reg_block root = null,

                                          input uvm_object    accessor = null);

   // Function: find_block

   //

   // Find the first block whose hierarchical names match the

   // specified ~name~ glob.

   // If a ~root~ block is specified, the name of the blocks are

   // relative to that block, otherwise they are absolute.

   //

   // Returns the first block found or ~null~ otherwise.

   // A warning is issued if more than one block is found.

   //

   extern static function uvm_reg_block find_block(input string        name,

                                                   input uvm_reg_block root = null,

                                                   input uvm_object    accessor = null);

   // Function: get_blocks

   //

   // Get the sub-blocks

   //

   // Get the blocks instantiated in this blocks.

   // If ~hier~ is TRUE, recursively includes any sub-blocks.

   //

   extern virtual function void get_blocks (ref uvm_reg_block  blks[$],

                                            input uvm_hier_e hier=UVM_HIER);

   // Function: get_maps

   //

   // Get the address maps

   //

   // Get the address maps instantiated in this block.

   //

   extern virtual function void get_maps (ref uvm_reg_map maps[$]);

   // Function: get_registers

   //

   // Get the registers

   //

   // Get the registers instantiated in this block.

   // If ~hier~ is TRUE, recursively includes the registers

   // in the sub-blocks.

   //

   // Note that registers may be located in different and/or multiple

   // address maps. To get the registers in a specific address map,

   // use the  method.

   //

   extern virtual function void get_registers (ref uvm_reg regs[$],

                                               input uvm_hier_e hier=UVM_HIER);

   // Function: get_fields

   //

   // Get the fields

   //

   // Get the fields in the registers instantiated in this block.

   // If ~hier~ is TRUE, recursively includes the fields of the registers

   // in the sub-blocks.

   //

   extern virtual function void get_fields (ref uvm_reg_field  fields[$],

                                            input uvm_hier_e hier=UVM_HIER);

   // Function: get_memories

   //

   // Get the memories

   //

   // Get the memories instantiated in this block.

   // If ~hier~ is TRUE, recursively includes the memories

   // in the sub-blocks.

   //

   // Note that memories may be located in different and/or multiple

   // address maps. To get the memories in a specific address map,

   // use the  method.

   //

   extern virtual function void get_memories (ref uvm_mem mems[$],

                                              input uvm_hier_e hier=UVM_HIER);

   // Function: get_virtual_registers

   //

   // Get the virtual registers

   //

   // Get the virtual registers instantiated in this block.

   // If ~hier~ is TRUE, recursively includes the virtual registers

   // in the sub-blocks.

   //

   extern virtual function void get_virtual_registers(ref uvm_vreg regs[$],

                                                input uvm_hier_e hier=UVM_HIER);

   // Function: get_virtual_fields

   //

   // Get the virtual fields

   //

   // Get the virtual fields from the virtual registers instantiated

   // in this block.

   // If ~hier~ is TRUE, recursively includes the virtual fields

   // in the virtual registers in the sub-blocks.

   //

   extern virtual function void get_virtual_fields (ref uvm_vreg_field fields[$],

                                                 input uvm_hier_e hier=UVM_HIER);

   // Function: get_block_by_name

   //

   // Finds a sub-block with the specified simple name.

   //

   // The name is the simple name of the block, not a hierarchical name.

   // relative to this block.

   // If no block with that name is found in this block, the sub-blocks

   // are searched for a block of that name and the first one to be found

   // is returned.

   //

   // If no blocks are found, returns ~null~.

   //

   extern virtual function uvm_reg_block get_block_by_name (string name);

   // Function: get_map_by_name

   //

   // Finds an address map with the specified simple name.

   //

   // The name is the simple name of the address map, not a hierarchical name.

   // relative to this block.

   // If no map with that name is found in this block, the sub-blocks

   // are searched for a map of that name and the first one to be found

   // is returned.

   //

   // If no address maps are found, returns ~null~.

   //

   extern virtual function uvm_reg_map get_map_by_name (string name);

   // Function: get_reg_by_name

   //

   // Finds a register with the specified simple name.

   //

   // The name is the simple name of the register, not a hierarchical name.

   // relative to this block.

   // If no register with that name is found in this block, the sub-blocks

   // are searched for a register of that name and the first one to be found

   // is returned.

   //

   // If no registers are found, returns ~null~.

   //

   extern virtual function uvm_reg get_reg_by_name (string name);

   // Function: get_field_by_name

   //

   // Finds a field with the specified simple name.

   //

   // The name is the simple name of the field, not a hierarchical name.

   // relative to this block.

   // If no field with that name is found in this block, the sub-blocks

   // are searched for a field of that name and the first one to be found

   // is returned.

   //

   // If no fields are found, returns ~null~.

   //

   extern virtual function uvm_reg_field get_field_by_name (string name);

   // Function: get_mem_by_name

   //

   // Finds a memory with the specified simple name.

   //

   // The name is the simple name of the memory, not a hierarchical name.

   // relative to this block.

   // If no memory with that name is found in this block, the sub-blocks

   // are searched for a memory of that name and the first one to be found

   // is returned.

   //

   // If no memories are found, returns ~null~.

   //

   extern virtual function uvm_mem get_mem_by_name (string name);

   // Function: get_vreg_by_name

   //

   // Finds a virtual register with the specified simple name.

   //

   // The name is the simple name of the virtual register,

   // not a hierarchical name.

   // relative to this block.

   // If no virtual register with that name is found in this block,

   // the sub-blocks are searched for a virtual register of that name

   // and the first one to be found is returned.

   //

   // If no virtual registers are found, returns ~null~.

   //

   extern virtual function uvm_vreg get_vreg_by_name (string name);

   // Function: get_vfield_by_name

   //

   // Finds a virtual field with the specified simple name.

   //

   // The name is the simple name of the virtual field,

   // not a hierarchical name.

   // relative to this block.

   // If no virtual field with that name is found in this block,

   // the sub-blocks are searched for a virtual field of that name

   // and the first one to be found is returned.

   //

   // If no virtual fields are found, returns ~null~.

   //

   extern virtual function uvm_vreg_field get_vfield_by_name (string name);

   //----------------

   // Group: Coverage

   //----------------

   // Function: build_coverage

   //

   // Check if all of the specified coverage model must be built.

   //

   // Check which of the specified coverage model must be built

   // in this instance of the block abstraction class,

   // as specified by calls to .

   //

   // Models are specified by adding the symbolic value of individual

   // coverage model as defined in .

   // Returns the sum of all coverage models to be built in the

   // block model.

   //

   extern protected function uvm_reg_cvr_t build_coverage(uvm_reg_cvr_t models);

   // Function: add_coverage

   //

   // Specify that additional coverage models are available.

   //

   // Add the specified coverage model to the coverage models

   // available in this class.

   // Models are specified by adding the symbolic value of individual

   // coverage model as defined in .

   //

   // This method shall be called only in the constructor of

   // subsequently derived classes.

   //

   extern virtual protected function void add_coverage(uvm_reg_cvr_t models);

   // Function: has_coverage

   //

   // Check if block has coverage model(s)

   //

   // Returns TRUE if the block abstraction class contains a coverage model

   // for all of the models specified.

   // Models are specified by adding the symbolic value of individual

   // coverage model as defined in .

   //

   extern virtual function bit has_coverage(uvm_reg_cvr_t models);

   // Function: set_coverage

   //

   // Turns on coverage measurement.

   //

   // Turns the collection of functional coverage measurements on or off

   // for this block and all blocks, registers, fields and memories within it.

   // The functional coverage measurement is turned on for every

   // coverage model specified using  symbolic

   // identifiers.

   // Multiple functional coverage models can be specified by adding

   // the functional coverage model identifiers.

   // All other functional coverage models are turned off.

   // Returns the sum of all functional

   // coverage models whose measurements were previously on.

   //

   // This method can only control the measurement of functional

   // coverage models that are present in the various abstraction classes,

   // then enabled during construction.

   // See the  method to identify

   // the available functional coverage models.

   //

   extern virtual function uvm_reg_cvr_t set_coverage(uvm_reg_cvr_t is_on);

   // Function: get_coverage

   //

   // Check if coverage measurement is on.

   //

   // Returns TRUE if measurement for all of the specified functional

   // coverage models are currently on.

   // Multiple functional coverage models can be specified by adding the

   // functional coverage model identifiers.

   //

   // See  for more details.

   //

   extern virtual function bit get_coverage(uvm_reg_cvr_t is_on = UVM_CVR_ALL);

   // Function: sample

   //

   // Functional coverage measurement method

   //

   // This method is invoked by the block abstraction class

   // whenever an address within one of its address map

   // is successfully read or written.

   // The specified offset is the offset within the block,

   // not an absolute address.

   //

   // Empty by default, this method may be extended by the

   // abstraction class generator to perform the required sampling

   // in any provided functional coverage model.

   //

   protected virtual function void  sample(uvm_reg_addr_t offset,

                                           bit            is_read,

                                           uvm_reg_map    map);

   endfunction

   // Function: sample_values

   //

   // Functional coverage measurement method for field values

   //

   // This method is invoked by the user

   // or by the  method of the parent block

   // to trigger the sampling

   // of the current field values in the

   // block-level functional coverage model.

   // It recursively invokes the 

   // and  methods

   // in the blocks and registers in this block.

   //

   // This method may be extended by the

   // abstraction class generator to perform the required sampling

   // in any provided field-value functional coverage model.

   // If this method is extended, it MUST call super.sample_values().

   //

   extern virtual function void sample_values();

   /*local*/ extern function void XsampleX(uvm_reg_addr_t addr,

                                           bit            is_read,

                                           uvm_reg_map    map);

   //--------------

   // Group: Access

   //--------------

   // Function: get_default_path

   //

   // Default access path

   //

   // Returns the default access path for this block.

   //

   extern virtual function uvm_path_e get_default_path();

   // Function: reset

   //

   // Reset the mirror for this block.

   //

   // Sets the mirror value of all registers in the block and sub-blocks

   // to the reset value corresponding to the specified reset event.

   // See  for more details.

   // Does not actually set the value of the registers in the design,

   // only the values mirrored in their corresponding mirror.

   //

   extern virtual function void reset(string kind = "HARD");

   // Function: needs_update

   //

   // Check if DUT registers need to be written

   //

   // If a mirror value has been modified in the abstraction model

   // without actually updating the actual register

   // (either through randomization or via the  method,

   // the mirror and state of the registers are outdated.

   // The corresponding registers in the DUT need to be updated.

   //

   // This method returns TRUE if the state of at least one register in

   // the block or sub-blocks needs to be updated to match the mirrored

   // values.

   // The mirror values, or actual content of registers, are not modified.

   // For additional information, see  method.

   //

   extern virtual function bit needs_update();

   // Task: update

   //

   // Batch update of register.

   //

   // Using the minimum number of write operations, updates the registers

   // in the design to match the mirrored values in this block and sub-blocks.

   // The update can be performed using the physical

   // interfaces (front-door access) or back-door accesses.

   // This method performs the reverse operation of .

   //

   extern virtual task update(output uvm_status_e       status,

                              input  uvm_path_e         path = UVM_DEFAULT_PATH,

                              input  uvm_sequence_base  parent = null,

                              input  int                prior = -1,

                              input  uvm_object         extension = null,

                              input  string             fname = "",

                              input  int                lineno = 0);

   // Task: mirror

   //

   // Update the mirrored values

   //

   // Read all of the registers in this block and sub-blocks and update their

   // mirror values to match their corresponding values in the design.

   // The mirroring can be performed using the physical interfaces

   // (front-door access) or back-door accesses.

   // If the ~check~ argument is specified as ,

   // an error message is issued if the current mirrored value

   // does not match the actual value in the design.

   // This method performs the reverse operation of .

   //

   extern virtual task mirror(output uvm_status_e       status,

                              input  uvm_check_e        check = UVM_NO_CHECK,

                              input  uvm_path_e         path  = UVM_DEFAULT_PATH,

                              input  uvm_sequence_base  parent = null,

                              input  int                prior = -1,

                              input  uvm_object         extension = null,

                              input  string             fname = "",

                              input  int                lineno = 0);

   // Task: write_reg_by_name

   //

   // Write the named register

   //

   // Equivalent to  followed by 

   //

   extern virtual task write_reg_by_name(

                              output uvm_status_e        status,

                              input  string              name,

                              input  uvm_reg_data_t      data,

                              input  uvm_path_e     path = UVM_DEFAULT_PATH,

                              input  uvm_reg_map         map = null,

                              input  uvm_sequence_base   parent = null,

                              input  int                 prior = -1,

                              input  uvm_object          extension = null,

                              input  string              fname = "",

                              input  int                 lineno = 0);

   // Task: read_reg_by_name

   //

   // Read the named register

   //

   // Equivalent to  followed by 

   //

   extern virtual task read_reg_by_name(

                              output uvm_status_e       status,

                              input  string             name,

                              output uvm_reg_data_t     data,

                              input  uvm_path_e    path = UVM_DEFAULT_PATH,

                              input  uvm_reg_map        map = null,

                              input  uvm_sequence_base  parent = null,

                              input  int                prior = -1,

                              input  uvm_object         extension = null,

                              input  string             fname = "",

                              input  int                lineno = 0);

   // Task: write_mem_by_name

   //

   // Write the named memory

   //

   // Equivalent to  followed by 

   //

   extern virtual task write_mem_by_name(

                              output uvm_status_e       status,

                              input  string             name,

                              input  uvm_reg_addr_t     offset,

                              input  uvm_reg_data_t     data,

                              input  uvm_path_e    path = UVM_DEFAULT_PATH,

                              input  uvm_reg_map        map = null,

                              input  uvm_sequence_base  parent = null,

                              input  int                prior = -1,

                              input  uvm_object         extension = null,

                              input  string             fname = "",

                              input  int                lineno = 0);

   // Task: read_mem_by_name

   //

   // Read the named memory

   //

   // Equivalent to  followed by 

   //

   extern virtual task read_mem_by_name(

                              output uvm_status_e       status,

                              input  string             name,

                              input  uvm_reg_addr_t     offset,

                              output uvm_reg_data_t     data,

                              input  uvm_path_e    path = UVM_DEFAULT_PATH,

                              input  uvm_reg_map        map = null,

                              input  uvm_sequence_base  parent = null,

                              input  int                prior = -1,

                              input  uvm_object         extension = null,

                              input  string             fname = "",

                              input  int                lineno = 0);

   extern virtual task readmemh(string filename);

   extern virtual task writememh(string filename);

   //----------------

   // Group: Backdoor

   //----------------

   // Function: get_backdoor

   //

   // Get the user-defined backdoor for all registers in this block

   //

   // Return the user-defined backdoor for all register in this

   // block and all sub-blocks -- unless overridden by a backdoor set

   // in a lower-level block or in the register itself.

   //

   // If ~inherited~ is TRUE, returns the backdoor of the parent block

   // if none have been specified for this block.

   //

   extern function uvm_reg_backdoor get_backdoor(bit inherited = 1);

   // Function: set_backdoor

   //

   // Set the user-defined backdoor for all registers in this block

   //

   // Defines the backdoor mechanism for all registers instantiated

   // in this block and sub-blocks, unless overridden by a definition

   // in a lower-level block or register.

   //

   extern function void set_backdoor (uvm_reg_backdoor bkdr,

                                      string fname = "",

                                      int lineno = 0);

   // Function:  clear_hdl_path

   //

   // Delete HDL paths

   //

   // Remove any previously specified HDL path to the block instance

   // for the specified design abstraction.

   //

   extern function void clear_hdl_path (string kind = "RTL");

   // Function:  add_hdl_path

   //

   // Add an HDL path

   //

   // Add the specified HDL path to the block instance for the specified

   // design abstraction. This method may be called more than once for the

   // same design abstraction if the block is physically duplicated

   // in the design abstraction

   //

   extern function void add_hdl_path (string path, string kind = "RTL");

   // Function:   has_hdl_path

   //

   // Check if a HDL path is specified

   //

   // Returns TRUE if the block instance has a HDL path defined for the

   // specified design abstraction. If no design abstraction is specified,

   // uses the default design abstraction specified for this block or

   // the nearest block ancestor with a specified default design abstraction.

   //

   extern function bit has_hdl_path (string kind = "");

   // Function:  get_hdl_path

   //

   // Get the incremental HDL path(s)

   //

   // Returns the HDL path(s) defined for the specified design abstraction

   // in the block instance.

   // Returns only the component of the HDL paths that corresponds to

   // the block, not a full hierarchical path

   //

   // If no design abstraction is specified, the default design abstraction

   // for this block is used.

   //

   extern function void get_hdl_path (ref string paths[$], input string kind = "");

   // Function:  get_full_hdl_path

   //

   // Get the full hierarchical HDL path(s)

   //

   // Returns the full hierarchical HDL path(s) defined for the specified

   // design abstraction in the block instance.

   // There may be more than one path returned even

   // if only one path was defined for the block instance, if any of the

   // parent components have more than one path defined for the same design

   // abstraction

   //

   // If no design abstraction is specified, the default design abstraction

   // for each ancestor block is used to get each incremental path.

   //

   extern function void get_full_hdl_path (ref string paths[$],

                                           input string kind = "",

                                           string separator = ".");

   // Function: set_default_hdl_path

   //

   // Set the default design abstraction

   //

   // Set the default design abstraction for this block instance.

   //

   extern function void   set_default_hdl_path (string kind);

   // Function:  get_default_hdl_path

   //

   // Get the default design abstraction

   //

   // Returns the default design abstraction for this block instance.

   // If a default design abstraction has not been explicitly set for this

   // block instance, returns the default design abstraction for the

   // nearest block ancestor.

   // Returns "" if no default design abstraction has been specified.

   //

   extern function string get_default_hdl_path ();

   // Function: set_hdl_path_root

   //

   // Specify a root HDL path

   //

   // Set the specified path as the absolute HDL path to the block instance

   // for the specified design abstraction.

   // This absolute root path is prepended to all hierarchical paths

   // under this block. The HDL path of any ancestor block is ignored.

   // This method overrides any incremental path for the

   // same design abstraction specified using .

   //

   extern function void set_hdl_path_root (string path, string kind = "RTL");

   // Function: is_hdl_path_root

   //

   // Check if this block has an absolute path

   //

   // Returns TRUE if an absolute HDL path to the block instance

   // for the specified design abstraction has been defined.

   // If no design abstraction is specified, the default design abstraction

   // for this block is used.

   //

   extern function bit is_hdl_path_root (string kind = "");

   extern virtual function void   do_print      (uvm_printer printer);

   extern virtual function void   do_copy       (uvm_object rhs);

   extern virtual function bit    do_compare    (uvm_object  rhs,

                                                 uvm_comparer comparer);

   extern virtual function void   do_pack       (uvm_packer packer);

   extern virtual function void   do_unpack     (uvm_packer packer);

   extern virtual function string convert2string ();

   extern virtual function uvm_object clone();

   extern local function void Xinit_address_mapsX();

endclass: uvm_reg_block