Fix for HDFFV-9947 H5Sencode

Modifications to fix H5Sencode bug when num points selected is > 2^32.

1 files changed, 245 insertions, 82 deletions

diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index 9263cd8..71bfa51 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -55,8 +55,8 @@ static herr_t H5S_hyper_get_seq_list(const H5S_t *space, unsigned flags,
     size_t *nseq, size_t *nbytes, hsize_t *off, size_t *len);
 static herr_t H5S_hyper_release(H5S_t *space);
 static htri_t H5S_hyper_is_valid(const H5S_t *space);
-static hssize_t H5S_hyper_serial_size(const H5S_t *space);
-static herr_t H5S_hyper_serialize(const H5S_t *space, uint8_t **p);
+static hssize_t H5S_hyper_serial_size(const H5S_t *space, H5F_t *f);
+static herr_t H5S_hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f);
 static herr_t H5S_hyper_deserialize(H5S_t *space, uint32_t version, uint8_t flags,
     const uint8_t **p);
 static herr_t H5S_hyper_bounds(const H5S_t *space, hsize_t *start, hsize_t *end);
@@ -77,7 +77,7 @@ static herr_t H5S_hyper_iter_coords(const H5S_sel_iter_t *iter, hsize_t *coords)
 static herr_t H5S_hyper_iter_block(const H5S_sel_iter_t *iter, hsize_t *start, hsize_t *end);
 static hsize_t H5S_hyper_iter_nelmts(const H5S_sel_iter_t *iter);
 static htri_t H5S_hyper_iter_has_next_block(const H5S_sel_iter_t *sel_iter);
-static herr_t H5S_hyper_iter_next(H5S_sel_iter_t *sel_iter, size_t nelem);
+static herr_t H5S_hyper_iter_next(H5S_sel_iter_t *sel_iter, hsize_t nelem);
 static herr_t H5S_hyper_iter_next_block(H5S_sel_iter_t *sel_iter);
 static herr_t H5S_hyper_iter_release(H5S_sel_iter_t *sel_iter);
 
@@ -664,7 +664,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5S_hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
+H5S_hyper_iter_next(H5S_sel_iter_t *iter, hsize_t nelem)
 {
     unsigned ndims;     /* Number of dimensions of dataset */
     int fast_dim;       /* Rank of the fastest changing dimension for the dataspace */
@@ -714,14 +714,14 @@ H5S_hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
             temp_dim=fast_dim;
             while(temp_dim>=0) {
                 if(temp_dim==fast_dim) {
-                    size_t actual_elem;     /* Actual # of elements advanced on each iteration through loop */
+                    hsize_t actual_elem;    /* Actual # of elements advanced on each iteration through loop */
                     hsize_t block_elem;     /* Number of elements left in a block */
 
                     /* Compute the number of elements left in block */
                     block_elem=tdiminfo[temp_dim].block-iter_offset[temp_dim];
 
                     /* Compute the number of actual elements to advance */
-                    actual_elem=(size_t)MIN(nelem,block_elem);
+                    actual_elem=MIN(nelem,block_elem);
 
                     /* Move the iterator over as many elements as possible */
                     iter_offset[temp_dim]+=actual_elem;
@@ -785,14 +785,14 @@ H5S_hyper_iter_next(H5S_sel_iter_t *iter, size_t nelem)
 
                 /* Increment absolute position */
                 if(curr_dim==fast_dim) {
-                    size_t actual_elem;     /* Actual # of elements advanced on each iteration through loop */
+                    hsize_t actual_elem;    /* Actual # of elements advanced on each iteration through loop */
                     hsize_t span_elem;      /* Number of elements left in a span */
 
                     /* Compute the number of elements left in block */
                     span_elem=(curr_span->high-abs_arr[curr_dim])+1;
 
                     /* Compute the number of actual elements to advance */
-                    actual_elem=(size_t)MIN(nelem,span_elem);
+                    actual_elem=MIN(nelem,span_elem);
 
                     /* Move the iterator over as many elements as possible */
                     abs_arr[curr_dim]+=actual_elem;
@@ -1941,13 +1941,129 @@ done:
 
 /*--------------------------------------------------------------------------
  NAME
+    H5S_hyper_set_offset_size
+ PURPOSE
+    Determine the offset size (4 or 8 bytes) to use for encoding hyperslab selection info
+ USAGE
+    hssize_t H5S_hyper_set_offset_size(space, block_count, bounds_end, version, offset_size)
+        const H5S_t *space:             IN: The maximum size of the hyperslab selection info
+        hsize_t block_count:            IN: The number of blocks in the selection
+        hsize_t bounds_end:             IN: The selection high bounds
+        uint32_t version:               IN: The version used for encoding
+        uint8_t *offset_size:           OUT: The offset size
+
+ RETURNS
+    The offset size
+ DESCRIPTION
+    Determine the offset size for encoding hyperslab selection info based on the
+    the input parameter "version".  This is for release 1.10.
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_set_offset_size(const H5S_t *space, hsize_t block_count, hsize_t bounds_end[], uint32_t version, uint8_t *offset_size)
+{
+    herr_t ret_value = SUCCEED;
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    switch(version) {
+        case H5S_HYPER_VERSION_1:
+            *offset_size = H5S_INFO_SIZE_4;
+            break;
+
+        case H5S_HYPER_VERSION_2:
+            *offset_size = H5S_INFO_SIZE_8;
+            break;
+
+        default:
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper offset size")
+            break;
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5S_hyper_set_offset_size() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
+    H5S_hyper_set_version
+ PURPOSE
+    Determine the version to use for encoding hyperslab selection info
+ USAGE
+    hssize_t H5S_hyper_set_version(space, block_count, bounds_end, f, version)
+        const H5S_t *space:             IN: The dataspace
+        hsize_t block_count:            IN: The number of blocks in the selection
+        hsize_t bounds_end:             IN: The selection high bounds
+        H5F_t *f:                       IN: The file pointer
+        uint32_t *version:              OUT: The version to use for encoding
+
+ RETURNS
+    The version to use
+ DESCRIPTION
+    Determine the version to use for encoding hyperslab selection info based
+    on whether the number of blocks or the selection high bounds exceeds (2^32 - 1).
+ GLOBAL VARIABLES
+ COMMENTS, BUGS, ASSUMPTIONS
+ EXAMPLES
+ REVISION LOG
+--------------------------------------------------------------------------*/
+static herr_t
+H5S_hyper_set_version(const H5S_t *space, hsize_t block_count, hsize_t bounds_end[], H5F_t *f, uint32_t *version)
+{
+    hbool_t count_up_version = FALSE;
+    hbool_t bound_up_version = FALSE;
+    unsigned u;
+    herr_t ret_value = SUCCEED; /* return value */
+
+    FUNC_ENTER_NOAPI_NOINIT
+
+    /* Use version 2 for unlimited selection */
+    if(space->select.sel_info.hslab->unlim_dim >= 0) {
+       *version = H5S_HYPER_VERSION_2;
+       HGOTO_DONE(SUCCEED)
+    }
+
+    *version = H5S_HYPER_VERSION_1;
+
+    /* Determine whether the number of blocks or the high bounds in the selection exceed (2^32 - 1) */
+    if(block_count > H5S_UINT32_MAX)
+        count_up_version = TRUE;
+    else {
+        for(u = 0; u < space->extent.rank; u++)
+            if(bounds_end[u] > H5S_UINT32_MAX)
+                bound_up_version = TRUE;
+    }
+
+    if(H5S_hyper_is_regular(space)) {
+        if((H5F_USE_LATEST_FLAGS(f, H5F_LATEST_DATASPACE_SELECTION) && block_count > 4) ||
+           count_up_version || bound_up_version)
+            *version = H5S_HYPER_VERSION_2;
+    } else { /* Fail for irregular hyperslab if exceeds 32 bits */
+        if(count_up_version)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The number of blocks in hyperslab selection exceeds 2^32")
+        else if(bound_up_version)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_BADVALUE, FAIL, "The end of bounding box in hyperslab selection exceeds 2^32")
+    }
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* H5S_hyper_set_version() */
+
+
+/*--------------------------------------------------------------------------
+ NAME
     H5S_hyper_serial_size
  PURPOSE
     Determine the number of bytes needed to store the serialized hyperslab
         selection information.
  USAGE
-    hssize_t H5S_hyper_serial_size(space)
+    hssize_t H5S_hyper_serial_size(space, H5F_t *f)
         H5S_t *space;             IN: Dataspace pointer to query
+        H5F_t *f;                 IN: File pointer
  RETURNS
     The number of bytes required on success, negative on an error.
  DESCRIPTION
@@ -1959,52 +2075,72 @@ done:
  REVISION LOG
 --------------------------------------------------------------------------*/
 static hssize_t
-H5S_hyper_serial_size(const H5S_t *space)
+H5S_hyper_serial_size(const H5S_t *space, H5F_t *f)
 {
-    hsize_t block_count;       /* block counter for regular hyperslabs */
-    unsigned u;                /* Counter */
-    hssize_t ret_value = -1;   /* return value */
+    hsize_t block_count = 0;    /* block counter for regular hyperslabs */
+    hsize_t bounds_start[H5S_MAX_RANK]; /* Selection bounds */
+    hsize_t bounds_end[H5S_MAX_RANK];   /* Selection bounds */
+    uint32_t version;           /* Version number */
+    uint8_t offset_size;        /* Offset size */
+    unsigned u;                 /* Local index variable */
+    hssize_t ret_value = -1;    /* return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(space);
 
-    /* Check for version (right now, an unlimited dimension is the only thing
-     * that would bump the version) */
-    if(space->select.sel_info.hslab->unlim_dim >= 0)
+    /* Get bounding box for the selection */
+    HDmemset(bounds_end, 0, sizeof(bounds_end));
+    if(space->select.sel_info.hslab->unlim_dim < 0) { /* ! H5S_UNLIMITED */
+        /* Determine the number of blocks */
+        if(H5S_hyper_is_regular(space)) {
+            /* Check each dimension */
+            for(block_count = 1, u = 0; u < space->extent.rank; u++)
+                block_count *= space->select.sel_info.hslab->opt_diminfo[u].count;
+        } /* end if */
+        else
+            /* Spin through hyperslab spans, adding 8 * rank bytes for each block */
+            block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
+
+        /* Get bounding box for the selection */
+        if(H5S_hyper_bounds(space, bounds_start, bounds_end) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
+    }
+
+    /* Determine the version */
+    if(H5S_hyper_set_version(space, block_count, bounds_end, f, &version) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
+
+    /* Determine the offset size */
+    if(H5S_hyper_set_offset_size(space, block_count, bounds_end, version, &offset_size) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
+
+    if(version == H5S_HYPER_VERSION_2) {
         /* Version 2 */
         /* Size required is always:
          * <type (4 bytes)> + <version (4 bytes)> + <flags (1 byte)> +
          * <length (4 bytes)> + <rank (4 bytes)> +
-         * (4 (start/stride/count/block) * <rank> * <value (8 bytes)>) =
-         * 17 + (4 * rank * 8) bytes
+         * (4 (start/stride/count/block) * <offset_size (8 bytes)> * <rank>) =
+         * 17 + (4 * 8 * rank) bytes
          */
-        ret_value = (hssize_t)17 + ((hssize_t)4 * (hssize_t)space->extent.rank
-                * (hssize_t)8);
-    else {
+        HDassert(offset_size == 8);
+        ret_value = (hssize_t)17 + ((hssize_t)4 * (hssize_t)8 * (hssize_t)space->extent.rank);
+    } else {
+        HDassert(version == H5S_HYPER_VERSION_1);
+        HDassert(offset_size == 4);
         /* Version 1 */
         /* Basic number of bytes required to serialize hyperslab selection:
          * <type (4 bytes)> + <version (4 bytes)> + <padding (4 bytes)> +
-         * <length (4 bytes)> + <rank (4 bytes)> + <# of blocks (4 bytes)>
-         * = 24 bytes
+         * <length (4 bytes)> + <rank (4 bytes)> + <# of blocks (4 bytes)> +
+         * (2 (starting/ending offset) * <offset_size (4 bytes)> * <rank> * <# of blocks) =
+         * = 24 bytes + (2 * 4 * rank * block_count)
          */
         ret_value = 24;
-
-        /* Check for a "regular" hyperslab selection */
-        if(space->select.sel_info.hslab->diminfo_valid) {
-            /* Check each dimension */
-            for(block_count = 1, u = 0; u < space->extent.rank; u++)
-                block_count *= space->select.sel_info.hslab->opt_diminfo[u].count;
-        } /* end if */
-        else
-            /* Spin through hyperslab spans, adding 8 * rank bytes for each
-             * block */
-            block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
-
         H5_CHECK_OVERFLOW((8 * space->extent.rank * block_count), hsize_t, hssize_t);
-        ret_value += (hssize_t)(8 * block_count * space->extent.rank);
+        ret_value += (hssize_t)(8 * space->extent.rank * block_count);
     } /* end else */
 
+done:
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5S_hyper_serial_size() */
 
@@ -2100,6 +2236,7 @@ H5S_hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
         uint8_t **p;            OUT: Pointer to buffer to put serialized
                                 selection.  Will be advanced to end of
                                 serialized selection.
+        H5F_t *f;               IN: File pointer
  RETURNS
     Non-negative on success/Negative on failure
  DESCRIPTION
@@ -2111,15 +2248,15 @@ H5S_hyper_serialize_helper(const H5S_hyper_span_info_t *spans,
  REVISION LOG
 --------------------------------------------------------------------------*/
 static herr_t
-H5S_hyper_serialize(const H5S_t *space, uint8_t **p)
+H5S_hyper_serialize(const H5S_t *space, uint8_t **p, H5F_t *f)
 {
     const H5S_hyper_dim_t *diminfo;         /* Alias for dataspace's diminfo information */
     uint8_t *pp = (*p);                     /* Local pointer for decoding */
     hsize_t tmp_count[H5O_LAYOUT_NDIMS];    /* Temporary hyperslab counts */
-    hsize_t offset[H5O_LAYOUT_NDIMS];      /* Offset of element in dataspace */
+    hsize_t offset[H5O_LAYOUT_NDIMS];       /* Offset of element in dataspace */
     hsize_t start[H5O_LAYOUT_NDIMS];   /* Location of start of hyperslab */
     hsize_t end[H5O_LAYOUT_NDIMS];     /* Location of end of hyperslab */
-    hsize_t temp_off;            /* Offset in a given dimension */
+    hsize_t temp_off; /* Offset in a given dimension */
     uint8_t *lenp;          /* pointer to length location for later storage */
     uint32_t len = 0;       /* number of bytes used */
     uint32_t version;       /* Version number */
@@ -2127,63 +2264,89 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t **p)
     hsize_t block_count;    /* block counter for regular hyperslabs */
     unsigned fast_dim;      /* Rank of the fastest changing dimension for the dataspace */
     unsigned ndims;         /* Rank of the dataspace */
+    unsigned u;             /* Local counting variable */
     int done;               /* Whether we are done with the iteration */
+    uint8_t offset_size;
+    hsize_t bounds_start[H5S_MAX_RANK];
+    hsize_t bounds_end[H5S_MAX_RANK];
+    herr_t ret_value = SUCCEED; /* return value */
 
-    FUNC_ENTER_NOAPI_NOINIT_NOERR
+    FUNC_ENTER_NOAPI_NOINIT
 
     HDassert(space);
     HDassert(p);
     HDassert(pp);
 
-    /* Calculate version */
-    if(space->select.sel_info.hslab->unlim_dim >= 0) {
-        version = 2;
-        flags |= H5S_SELECT_FLAG_UNLIM;
-    } /* end if */
-    else
-        version = 1;
+    /* Set some convienence values */
+    ndims = space->extent.rank;
+    diminfo = space->select.sel_info.hslab->opt_diminfo;
+
+    if(space->select.sel_info.hslab->unlim_dim < 0) { /* ! H5S_UNLIMITED */
+        /* Calculate the # of blocks */
+        if(H5S_hyper_is_regular(space)) {
+            /* Check each dimension */
+            for(block_count = 1, u = 0; u < ndims; u++)
+                block_count *= diminfo[u].count;
+        } /* end if */
+        else
+            /* Spin through hyperslab spans, adding 8 * rank bytes for each block */
+            block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
+
+        /* Get bounding box */
+        if(H5S_hyper_bounds(space, bounds_start, bounds_end) < 0)
+            HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't get selection bounds")
+    }
+
+    /* Determine the version to use */
+    if(H5S_hyper_set_version(space, block_count, bounds_end, f, &version) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
+
+    /* Determine the size of offset info */
+    if(H5S_hyper_set_offset_size(space, block_count, bounds_end, version, &offset_size) < 0)
+        HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't determine hyper version")
+
+    if(H5S_hyper_is_regular(space) && version == H5S_HYPER_VERSION_2)
+        flags |= H5S_HYPER_REGULAR;
 
     /* Store the preamble information */
     UINT32ENCODE(pp, (uint32_t)H5S_GET_SELECT_TYPE(space)); /* Store the type of selection */
     UINT32ENCODE(pp, version); /* Store the version number */
-    if(version >= 2)
-        *(pp)++ = flags; /* Store the flags */
+
+    if(version == 2)
+        *(pp)++ = flags;    /* Store the flags */
     else
         UINT32ENCODE(pp, (uint32_t)0); /* Store the un-used padding */
-    lenp = pp;           /* keep the pointer to the length location for later */
-    pp += 4;             /* skip over space for length */
+    lenp = pp;              /* keep the pointer to the length location for later */
+    pp += 4;                /* skip over space for length */
+
+    len += 4;               /* ndims */
 
     /* Encode number of dimensions */
-    UINT32ENCODE(pp, (uint32_t)space->extent.rank);
-    len += 4;
+    UINT32ENCODE(pp, (uint32_t)ndims);
 
-    /* If there is an unlimited dimension, only encode opt_unlim_diminfo */
-    if(flags & H5S_SELECT_FLAG_UNLIM) {
+    /* If flags indicates a regular hyperslab or unlimited dimension, encode opt_diminfo */
+    if(flags & H5S_HYPER_REGULAR) {
         unsigned i;
 
         HDassert(H5S_UNLIMITED == HSIZE_UNDEF);
+        HDassert(version == H5S_HYPER_VERSION_2);
 
         /* Iterate over dimensions */
+        /* Encode start/stride/block/count */
         for(i = 0; i < space->extent.rank; i++) {
-            /* Encode start/stride/block/count */
-            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].start);
-            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].stride);
-            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].count);
-            UINT64ENCODE(pp, space->select.sel_info.hslab->opt_diminfo[i].block);
+            UINT64ENCODE(pp, diminfo[i].start);
+            UINT64ENCODE(pp, diminfo[i].stride);
+            UINT64ENCODE(pp, diminfo[i].count);
+            UINT64ENCODE(pp, diminfo[i].block);
         } /* end for */
+        len += (4 * space->extent.rank * 8);
     } /* end if */
     /* Check for a "regular" hyperslab selection */
-    else if(space->select.sel_info.hslab->diminfo_valid) {
-        unsigned u;     /* Local counting variable */
+    else if(H5S_hyper_is_regular(space)) {
+        HDassert(version == H5S_HYPER_VERSION_1);
 
         /* Set some convienence values */
-        ndims = space->extent.rank;
         fast_dim = ndims - 1;
-        diminfo=space->select.sel_info.hslab->opt_diminfo;
-
-        /* Check each dimension */
-        for(block_count = 1, u = 0; u < ndims; u++)
-            block_count *= diminfo[u].count;
 
         /* Encode number of hyperslabs */
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
@@ -2262,15 +2425,16 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t **p)
         } /* end while */
     } /* end if */
     else {
+        HDassert(version == H5S_HYPER_VERSION_1);
         /* Encode number of hyperslabs */
-        block_count = H5S_hyper_span_nblocks(space->select.sel_info.hslab->span_lst);
         H5_CHECK_OVERFLOW(block_count, hsize_t, uint32_t);
         UINT32ENCODE(pp, (uint32_t)block_count);
-        len+=4;
+
+        len+=4; /* block_count */
 
         /* Add 8 bytes times the rank for each hyperslab selected */
-        H5_CHECK_OVERFLOW((8 * space->extent.rank * block_count), hsize_t, size_t);
-        len += (uint32_t)(8 * space->extent.rank * block_count);
+        H5_CHECK_OVERFLOW((8 * ndims * block_count), hsize_t, size_t);
+        len += (uint32_t)(8 * ndims * block_count);
 
         /* Encode each hyperslab in selection */
         H5S_hyper_serialize_helper(space->select.sel_info.hslab->span_lst, start, end, (hsize_t)0, &pp);
@@ -2282,7 +2446,8 @@ H5S_hyper_serialize(const H5S_t *space, uint8_t **p)
     /* Update encoding pointer */
     *p = pp;
 
-    FUNC_LEAVE_NOAPI(SUCCEED)
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
 }   /* H5S_hyper_serialize() */
 
 
@@ -2316,7 +2481,7 @@ H5S_hyper_deserialize(H5S_t *space, uint32_t H5_ATTR_UNUSED version, uint8_t fla
 {
     unsigned rank;           	/* rank of points */
     const uint8_t *pp = (*p);   /* Local pointer for decoding */
-    size_t num_elem=0;      	/* number of elements in selection */
+    hsize_t num_elem=0;      	/* number of elements in selection */
     hsize_t start[H5O_LAYOUT_NDIMS];	/* hyperslab start information */
     hsize_t end[H5O_LAYOUT_NDIMS];	/* hyperslab end information */
     hsize_t stride[H5O_LAYOUT_NDIMS];   /* hyperslab stride information */
@@ -2341,14 +2506,13 @@ H5S_hyper_deserialize(H5S_t *space, uint32_t H5_ATTR_UNUSED version, uint8_t fla
     /* (The header and rank have already beed decoded) */
     rank = space->extent.rank;  /* Retrieve rank from space */
 
-    /* If there is an unlimited dimension, only encode opt_unlim_diminfo */
-    if(flags & H5S_SELECT_FLAG_UNLIM) {
+    if(flags & H5S_HYPER_REGULAR) {
         HDassert(H5S_UNLIMITED == HSIZE_UNDEF);
         HDassert(version >= 2);
 
         /* Iterate over dimensions */
+        /* Decode start/stride/block/count */
         for(i = 0; i < space->extent.rank; i++) {
-            /* Decode start/stride/block/count */
             UINT64DECODE(pp, start[i]);
             UINT64DECODE(pp, stride[i]);
             UINT64DECODE(pp, count[i]);
@@ -2360,7 +2524,7 @@ H5S_hyper_deserialize(H5S_t *space, uint32_t H5_ATTR_UNUSED version, uint8_t fla
             HGOTO_ERROR(H5E_DATASPACE, H5E_CANTDELETE, FAIL, "can't change selection")
     } /* end if */
     else {
-        /* decode the number of points */
+        /* decode the number of blocks */
         UINT32DECODE(pp,num_elem);
 
         /* Set the count & stride for all blocks */
@@ -2371,11 +2535,10 @@ H5S_hyper_deserialize(H5S_t *space, uint32_t H5_ATTR_UNUSED version, uint8_t fla
 
         /* Retrieve the coordinates from the buffer */
         for(i = 0; i < num_elem; i++) {
-            /* Decode the starting points */
+
+            /* Decode the starting and ending points */
             for(tstart=start,j=0; j<rank; j++,tstart++)
                 UINT32DECODE(pp, *tstart);
-
-            /* Decode the ending points */
             for(tend = end, j = 0; j < rank; j++, tend++)
                 UINT32DECODE(pp, *tend);