[svn-r24709] rename H5V to H5VM since H5V is needed in the fastforward project for

view objects.  The addition of view objects in the fastforward project
is expected to be brough into the trunk sometimes in the future, which
is why we need to make this change.

Tested Manually on Jam and Ostrich.
Tested with h5commitest - Koala with intel compilers failed, but nothing had to do with those changes.
error on Koala: error while loading shared libraries: libirng.so

57 files changed, 385 insertions, 385 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index f71b8b6..c626065 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -604,12 +604,12 @@ SET (H5TS_HDRS
 IDE_GENERATED_PROPERTIES ("H5TS" "${H5TS_HDRS}" "${H5TS_SRCS}" )
 
 
-SET (H5V_SRCS
-    ${HDF5_SRC_DIR}/H5V.c
+SET (H5VM_SRCS
+    ${HDF5_SRC_DIR}/H5VM.c
 )
-SET (H5V_HDRS
+SET (H5VM_HDRS
 )
-IDE_GENERATED_PROPERTIES ("H5V" "${H5V_HDRS}" "${H5V_SRCS}" )
+IDE_GENERATED_PROPERTIES ("H5VM" "${H5VM_HDRS}" "${H5VM_SRCS}" )
 
 
 SET (H5WB_SRCS
@@ -681,7 +681,7 @@ SET (common_SRCS
     ${H5ST_SRCS}
     ${H5T_SRCS}
     ${H5TS_SRCS}
-    ${H5V_SRCS}
+    ${H5VM_SRCS}
     ${H5WB_SRCS}
     ${H5Z_SRCS}
 )
@@ -760,7 +760,7 @@ SET (H5_PRIVATE_HEADERS
     ${HDF5_SRC_DIR}/H5STprivate.h
     ${HDF5_SRC_DIR}/H5Tprivate.h
     ${HDF5_SRC_DIR}/H5TSprivate.h
-    ${HDF5_SRC_DIR}/H5Vprivate.h
+    ${HDF5_SRC_DIR}/H5VMprivate.h
     ${HDF5_SRC_DIR}/H5WBprivate.h
     ${HDF5_SRC_DIR}/H5Zprivate.h
     ${HDF5_SRC_DIR}/H5win32defs.h
diff --git a/src/H5B2hdr.c b/src/H5B2hdr.c
index 2148f1e..443a2e5 100644
--- a/src/H5B2hdr.c
+++ b/src/H5B2hdr.c
@@ -37,7 +37,7 @@
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -181,7 +181,7 @@ HDmemset(hdr->page, 0, hdr->node_size);
 
     /* Compute size to store # of records in each node */
     /* (uses leaf # of records because its the largest) */
-    u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[0].max_nrec);
+    u_max_nrec_size = H5VM_limit_enc_size((uint64_t)hdr->node_info[0].max_nrec);
     H5_ASSIGN_OVERFLOW(/* To: */ hdr->max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
     HDassert(hdr->max_nrec_size <= H5B2_SIZEOF_RECORDS_PER_NODE);
 
@@ -197,7 +197,7 @@ HDmemset(hdr->page, 0, hdr->node_size);
 
             hdr->node_info[u].cum_max_nrec = ((hdr->node_info[u].max_nrec + 1) *
                 hdr->node_info[u - 1].cum_max_nrec) + hdr->node_info[u].max_nrec;
-            u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[u].cum_max_nrec);
+            u_max_nrec_size = H5VM_limit_enc_size((uint64_t)hdr->node_info[u].cum_max_nrec);
             H5_ASSIGN_OVERFLOW(/* To: */ hdr->node_info[u].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
 
             if(NULL == (hdr->node_info[u].nat_rec_fac = H5FL_fac_init(hdr->cls->nrec_size * hdr->node_info[u].max_nrec)))
diff --git a/src/H5B2int.c b/src/H5B2int.c
index 8ea8426..630ff98 100644
--- a/src/H5B2int.c
+++ b/src/H5B2int.c
@@ -37,7 +37,7 @@
 #include "H5B2pkg.h"		/* v2 B-trees				*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -387,7 +387,7 @@ H5B2_split_root(H5B2_hdr_t *hdr, hid_t dxpl_id)
     hdr->node_info[hdr->depth].merge_nrec = (hdr->node_info[hdr->depth].max_nrec * hdr->merge_percent) / 100;
     hdr->node_info[hdr->depth].cum_max_nrec = ((hdr->node_info[hdr->depth].max_nrec + 1) *
         hdr->node_info[hdr->depth - 1].cum_max_nrec) + hdr->node_info[hdr->depth].max_nrec;
-    u_max_nrec_size = H5V_limit_enc_size((uint64_t)hdr->node_info[hdr->depth].cum_max_nrec);
+    u_max_nrec_size = H5VM_limit_enc_size((uint64_t)hdr->node_info[hdr->depth].cum_max_nrec);
     H5_ASSIGN_OVERFLOW(/* To: */ hdr->node_info[hdr->depth].cum_max_nrec_size, /* From: */ u_max_nrec_size, /* From: */ unsigned, /* To: */ uint8_t)
     if(NULL == (hdr->node_info[hdr->depth].nat_rec_fac = H5FL_fac_init(hdr->cls->nrec_size * hdr->node_info[hdr->depth].max_nrec)))
 	HGOTO_ERROR(H5E_RESOURCE, H5E_CANTINIT, FAIL, "can't create node native key block factory")
diff --git a/src/H5Dbtree.c b/src/H5Dbtree.c
index 37780e7..039ebdc 100644
--- a/src/H5Dbtree.c
+++ b/src/H5Dbtree.c
@@ -43,7 +43,7 @@
 #include "H5MFprivate.h"	/* File space management		*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Sprivate.h"         /* Dataspaces                           */
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 /****************/
 /* Local Macros */
@@ -345,7 +345,7 @@ H5D__btree_cmp2(void *_lt_key, void *_udata, void *_rt_key)
     HDassert(udata->layout->ndims > 0 && udata->layout->ndims <= H5O_LAYOUT_NDIMS);
 
     /* Compare the offsets but ignore the other fields */
-    ret_value = H5V_vector_cmp_u(udata->layout->ndims, lt_key->offset, rt_key->offset);
+    ret_value = H5VM_vector_cmp_u(udata->layout->ndims, lt_key->offset, rt_key->offset);
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5D__btree_cmp2() */
@@ -409,9 +409,9 @@ H5D__btree_cmp3(void *_lt_key, void *_udata, void *_rt_key)
             ret_value = (-1);
     } /* end if */
     else {
-        if(H5V_vector_ge_u(udata->layout->ndims, udata->offset, rt_key->offset))
+        if(H5VM_vector_ge_u(udata->layout->ndims, udata->offset, rt_key->offset))
             ret_value = 1;
-        else if(H5V_vector_lt_u(udata->layout->ndims, udata->offset, lt_key->offset))
+        else if(H5VM_vector_lt_u(udata->layout->ndims, udata->offset, lt_key->offset))
             ret_value = (-1);
     } /* end else */
 
@@ -540,7 +540,7 @@ H5D__btree_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
         /* Negative indices not supported yet */
         HGOTO_ERROR(H5E_STORAGE, H5E_UNSUPPORTED, H5B_INS_ERROR, "internal error")
 
-    } else if(H5V_vector_eq_u(udata->common.layout->ndims,
+    } else if(H5VM_vector_eq_u(udata->common.layout->ndims,
 				udata->common.offset, lt_key->offset) &&
 	       lt_key->nbytes > 0) {
         /*
@@ -579,10 +579,10 @@ H5D__btree_insert(H5F_t *f, hid_t dxpl_id, haddr_t addr, void *_lt_key,
             ret_value = H5B_INS_NOOP;
         }
 
-    } else if (H5V_hyper_disjointp(udata->common.layout->ndims,
+    } else if (H5VM_hyper_disjointp(udata->common.layout->ndims,
 				   lt_key->offset, udata->common.layout->dim,
 				   udata->common.offset, udata->common.layout->dim)) {
-        HDassert(H5V_hyper_disjointp(udata->common.layout->ndims,
+        HDassert(H5VM_hyper_disjointp(udata->common.layout->ndims,
 				   rt_key->offset, udata->common.layout->dim,
 				   udata->common.offset, udata->common.layout->dim));
         /*
diff --git a/src/H5Dchunk.c b/src/H5Dchunk.c
index db195ca..e834aa3 100644
--- a/src/H5Dchunk.c
+++ b/src/H5Dchunk.c
@@ -59,7 +59,7 @@
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -324,7 +324,7 @@ H5D__chunk_direct_write(const H5D_t *dset, hid_t dxpl_id, uint32_t filters, hsiz
          HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "unable to get simple dataspace info")
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index((unsigned)space_ndims, offset,
+    if(H5VM_chunk_index((unsigned)space_ndims, offset,
 	layout->u.chunk.dim, layout->u.chunk.down_chunks, &chunk_idx) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
 
@@ -419,7 +419,7 @@ H5D__chunk_set_info_real(H5O_layout_chunk_t *layout, unsigned ndims, const hsize
     } /* end for */
 
     /* Get the "down" sizes for each dimension */
-    if(H5V_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
+    if(H5VM_array_down(ndims, layout->chunks, layout->down_chunks) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTSET, FAIL, "can't compute 'down' chunk size value")
 
 done:
@@ -1137,7 +1137,7 @@ H5D__create_chunk_map_single(H5D_chunk_map_t *fm, const H5D_io_info_t
     chunk_info->coords[fm->f_ndims] = 0;
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(fm->f_ndims, chunk_info->coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_info->index) < 0)
+    if(H5VM_chunk_index(fm->f_ndims, chunk_info->coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_info->index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Copy selection for file's dataspace into chunk dataspace */
@@ -1222,7 +1222,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
     } /* end for */
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Iterate through each chunk in the dataset */
@@ -1340,7 +1340,7 @@ H5D__create_chunk_file_map_hyper(H5D_chunk_map_t *fm, const H5D_io_info_t
             } while(coords[curr_dim] > sel_end[curr_dim]);
 
             /* Re-calculate the index of this chunk */
-            if(H5V_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+            if(H5VM_chunk_index(fm->f_ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
                 HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
         } /* end if */
     } /* end while */
@@ -1488,7 +1488,7 @@ H5D__chunk_file_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, cons
     FUNC_ENTER_STATIC
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Find correct chunk in file & memory skip list */
@@ -1600,7 +1600,7 @@ H5D__chunk_mem_cb(void UNUSED *elem, hid_t UNUSED type_id, unsigned ndims, const
     FUNC_ENTER_STATIC
 
     /* Calculate the index of this chunk */
-    if(H5V_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(ndims, coords, fm->layout->u.chunk.dim, fm->layout->u.chunk.down_chunks, &chunk_index) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
     /* Find correct chunk in file & memory skip list */
@@ -3412,7 +3412,7 @@ H5D__chunk_allocate(H5D_t *dset, hid_t dxpl_id, hbool_t full_overwrite,
                 hsize_t chunk_idx;
 
                 /* Calculate the index of this chunk */
-                if(H5V_chunk_index((unsigned)space_ndims, chunk_offset,
+                if(H5VM_chunk_index((unsigned)space_ndims, chunk_offset,
                         layout->u.chunk.dim, layout->u.chunk.down_chunks,
                         &chunk_idx) < 0)
                     HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
@@ -3986,7 +3986,7 @@ H5D__chunk_prune_by_extent(H5D_t *dset, hid_t dxpl_id, const hsize_t *old_dim)
 
         while(!carry) {
             /* Calculate the index of this chunk */
-            if(H5V_chunk_index((unsigned)space_ndims, chunk_offset,
+            if(H5VM_chunk_index((unsigned)space_ndims, chunk_offset,
                     layout->u.chunk.dim, layout->u.chunk.down_chunks,
                     &(chk_io_info.store->chunk.index)) < 0)
                 HGOTO_ERROR(H5E_DATASET, H5E_CANTINIT, FAIL, "can't get chunk index")
@@ -4127,7 +4127,7 @@ H5D__chunk_addrmap_cb(const H5D_chunk_rec_t *chunk_rec, void *_udata)
     FUNC_ENTER_STATIC
 
     /* Compute the index for this chunk */
-    if(H5V_chunk_index(rank, chunk_rec->offset, udata->common.layout->dim, udata->common.layout->down_chunks, &chunk_index) < 0)
+    if(H5VM_chunk_index(rank, chunk_rec->offset, udata->common.layout->dim, udata->common.layout->down_chunks, &chunk_index) < 0)
        HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, H5_ITER_ERROR, "can't get chunk index")
 
     /* Set it in the userdata to return */
@@ -4318,7 +4318,7 @@ H5D__chunk_update_cache(H5D_t *dset, hid_t dxpl_id)
         next = ent->next;
 
         /* Calculate the index of this chunk */
-        if(H5V_chunk_index(rank, ent->offset, dset->shared->layout.u.chunk.dim, dset->shared->layout.u.chunk.down_chunks, &idx) < 0)
+        if(H5VM_chunk_index(rank, ent->offset, dset->shared->layout.u.chunk.dim, dset->shared->layout.u.chunk.down_chunks, &idx) < 0)
             HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "can't get chunk index")
 
         /* Compute the index for the chunk entry */
@@ -5087,7 +5087,7 @@ static herr_t
 H5D__nonexistent_readvv_cb(hsize_t UNUSED dst_off, hsize_t src_off, size_t len,
     void *_udata)
 {
-    H5D_chunk_readvv_ud_t *udata = (H5D_chunk_readvv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_chunk_readvv_ud_t *udata = (H5D_chunk_readvv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     H5D_fill_buf_info_t fb_info;    /* Dataset's fill buffer info */
     hbool_t fb_info_init = FALSE;   /* Whether the fill value buffer has been initialized */
     herr_t ret_value = SUCCEED;     /* Return value */
@@ -5139,7 +5139,7 @@ H5D__nonexistent_readvv(const H5D_io_info_t *io_info,
     size_t chunk_max_nseq, size_t *chunk_curr_seq, size_t chunk_len_arr[], hsize_t chunk_off_arr[],
     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_off_arr[])
 {
-    H5D_chunk_readvv_ud_t udata;        /* User data for H5V_opvv() operator */
+    H5D_chunk_readvv_ud_t udata;        /* User data for H5VM_opvv() operator */
     ssize_t ret_value;                  /* Return value */
 
     FUNC_ENTER_STATIC
@@ -5153,13 +5153,13 @@ H5D__nonexistent_readvv(const H5D_io_info_t *io_info,
     HDassert(mem_len_arr);
     HDassert(mem_off_arr);
 
-    /* Set up user data for H5V_opvv() */
+    /* Set up user data for H5VM_opvv() */
     udata.rbuf = (unsigned char *)io_info->u.rbuf;
     udata.dset = io_info->dset;
     udata.dxpl_id = io_info->dxpl_id;
 
     /* Call generic sequence operation routine */
-    if((ret_value = H5V_opvv(chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_off_arr,
+    if((ret_value = H5VM_opvv(chunk_max_nseq, chunk_curr_seq, chunk_len_arr, chunk_off_arr,
             mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
             H5D__nonexistent_readvv_cb, &udata)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized fill value init")
diff --git a/src/H5Dcompact.c b/src/H5Dcompact.c
index c692c2b..0b34c07 100644
--- a/src/H5Dcompact.c
+++ b/src/H5Dcompact.c
@@ -40,7 +40,7 @@
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -297,7 +297,7 @@ H5D__compact_readvv(const H5D_io_info_t *io_info,
     HDassert(io_info);
 
     /* Use the vectorized memory copy routine to do actual work */
-    if((ret_value = H5V_memcpyvv(io_info->u.rbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr, io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr)) < 0)
+    if((ret_value = H5VM_memcpyvv(io_info->u.rbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr, io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr)) < 0)
         HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed")
 
 done:
@@ -338,7 +338,7 @@ H5D__compact_writevv(const H5D_io_info_t *io_info,
     HDassert(io_info);
 
     /* Use the vectorized memory copy routine to do actual work */
-    if((ret_value = H5V_memcpyvv(io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr, io_info->u.wbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr)) < 0)
+    if((ret_value = H5VM_memcpyvv(io_info->store->compact.buf, dset_max_nseq, dset_curr_seq, dset_size_arr, dset_offset_arr, io_info->u.wbuf, mem_max_nseq, mem_curr_seq, mem_size_arr, mem_offset_arr)) < 0)
         HGOTO_ERROR(H5E_IO, H5E_WRITEERROR, FAIL, "vectorized memcpy failed")
 
     /* Mark the compact dataset's buffer as dirty */
diff --git a/src/H5Dcontig.c b/src/H5Dcontig.c
index acc7124..69db7d4 100644
--- a/src/H5Dcontig.c
+++ b/src/H5Dcontig.c
@@ -43,7 +43,7 @@
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Pprivate.h"		/* Property lists			*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -638,7 +638,7 @@ static herr_t
 H5D__contig_readvv_sieve_cb(hsize_t dst_off, hsize_t src_off, size_t len,
     void *_udata)
 {
-    H5D_contig_readvv_sieve_ud_t *udata = (H5D_contig_readvv_sieve_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_readvv_sieve_ud_t *udata = (H5D_contig_readvv_sieve_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     H5F_t *file = udata->file;        /* File for dataset */
     H5D_rdcdc_t *dset_contig = udata->dset_contig; /* Cached information about contiguous data */
     const H5D_contig_storage_t *store_contig = udata->store_contig;    /* Contiguous storage info for this I/O operation */
@@ -804,7 +804,7 @@ done:
 static herr_t
 H5D__contig_readvv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_contig_readvv_ud_t *udata = (H5D_contig_readvv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_readvv_ud_t *udata = (H5D_contig_readvv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -857,9 +857,9 @@ H5D__contig_readvv(const H5D_io_info_t *io_info,
 
     /* Check if data sieving is enabled */
     if(H5F_HAS_FEATURE(io_info->dset->oloc.file, H5FD_FEAT_DATA_SIEVE)) {
-        H5D_contig_readvv_sieve_ud_t udata;     /* User data for H5V_opvv() operator */
+        H5D_contig_readvv_sieve_ud_t udata;     /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_contig = &(io_info->dset->shared->cache.contig);
         udata.store_contig = &(io_info->store->contig);
@@ -867,22 +867,22 @@ H5D__contig_readvv(const H5D_io_info_t *io_info,
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_readvv_sieve_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized sieve buffer read")
     } /* end if */
     else {
-        H5D_contig_readvv_ud_t udata;     /* User data for H5V_opvv() operator */
+        H5D_contig_readvv_ud_t udata;     /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_addr = io_info->store->contig.dset_addr;
         udata.rbuf = (unsigned char *)io_info->u.rbuf;
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_readvv_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized read")
@@ -909,7 +909,7 @@ static herr_t
 H5D__contig_writevv_sieve_cb(hsize_t dst_off, hsize_t src_off, size_t len,
     void *_udata)
 {
-    H5D_contig_writevv_sieve_ud_t *udata = (H5D_contig_writevv_sieve_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_writevv_sieve_ud_t *udata = (H5D_contig_writevv_sieve_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     H5F_t *file = udata->file;        /* File for dataset */
     H5D_rdcdc_t *dset_contig = udata->dset_contig; /* Cached information about contiguous data */
     const H5D_contig_storage_t *store_contig = udata->store_contig;    /* Contiguous storage info for this I/O operation */
@@ -1126,7 +1126,7 @@ done:
 static herr_t
 H5D__contig_writevv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_contig_writevv_ud_t *udata = (H5D_contig_writevv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_contig_writevv_ud_t *udata = (H5D_contig_writevv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED; /* Return value */
 
     FUNC_ENTER_STATIC
@@ -1178,9 +1178,9 @@ H5D__contig_writevv(const H5D_io_info_t *io_info,
 
     /* Check if data sieving is enabled */
     if(H5F_HAS_FEATURE(io_info->dset->oloc.file, H5FD_FEAT_DATA_SIEVE)) {
-        H5D_contig_writevv_sieve_ud_t udata;    /* User data for H5V_opvv() operator */
+        H5D_contig_writevv_sieve_ud_t udata;    /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_contig = &(io_info->dset->shared->cache.contig);
         udata.store_contig = &(io_info->store->contig);
@@ -1188,22 +1188,22 @@ H5D__contig_writevv(const H5D_io_info_t *io_info,
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_writevv_sieve_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized sieve buffer write")
     } /* end if */
     else {
-        H5D_contig_writevv_ud_t udata;     /* User data for H5V_opvv() operator */
+        H5D_contig_writevv_ud_t udata;     /* User data for H5VM_opvv() operator */
 
-        /* Set up user data for H5V_opvv() */
+        /* Set up user data for H5VM_opvv() */
         udata.file = io_info->dset->oloc.file;
         udata.dset_addr = io_info->store->contig.dset_addr;
         udata.wbuf = (const unsigned char *)io_info->u.wbuf;
         udata.dxpl_id = io_info->dxpl_id;
 
         /* Call generic sequence operation routine */
-        if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+        if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
                 mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
                 H5D__contig_writevv_cb, &udata)) < 0)
             HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized read")
diff --git a/src/H5Defl.c b/src/H5Defl.c
index c5cf8e2..38c8ccd 100644
--- a/src/H5Defl.c
+++ b/src/H5Defl.c
@@ -33,7 +33,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fprivate.h"		/* Files				*/
 #include "H5HLprivate.h"	/* Local Heaps				*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 
 /****************/
@@ -425,7 +425,7 @@ done:
 static herr_t
 H5D__efl_readvv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_efl_readvv_ud_t *udata = (H5D_efl_readvv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_efl_readvv_ud_t *udata = (H5D_efl_readvv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -459,7 +459,7 @@ H5D__efl_readvv(const H5D_io_info_t *io_info,
     size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_off_arr[],
     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_off_arr[])
 {
-    H5D_efl_readvv_ud_t udata;  /* User data for H5V_opvv() operator */
+    H5D_efl_readvv_ud_t udata;  /* User data for H5VM_opvv() operator */
     ssize_t ret_value;          /* Return value (Total size of sequence in bytes) */
 
     FUNC_ENTER_STATIC
@@ -475,12 +475,12 @@ H5D__efl_readvv(const H5D_io_info_t *io_info,
     HDassert(mem_len_arr);
     HDassert(mem_off_arr);
 
-    /* Set up user data for H5V_opvv() */
+    /* Set up user data for H5VM_opvv() */
     udata.efl = &(io_info->store->efl);
     udata.rbuf = (unsigned char *)io_info->u.rbuf;
 
     /* Call generic sequence operation routine */
-    if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+    if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
             mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
             H5D__efl_readvv_cb, &udata)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized EFL read")
@@ -505,7 +505,7 @@ done:
 static herr_t
 H5D__efl_writevv_cb(hsize_t dst_off, hsize_t src_off, size_t len, void *_udata)
 {
-    H5D_efl_writevv_ud_t *udata = (H5D_efl_writevv_ud_t *)_udata; /* User data for H5V_opvv() operator */
+    H5D_efl_writevv_ud_t *udata = (H5D_efl_writevv_ud_t *)_udata; /* User data for H5VM_opvv() operator */
     herr_t ret_value = SUCCEED;         /* Return value */
 
     FUNC_ENTER_STATIC
@@ -539,7 +539,7 @@ H5D__efl_writevv(const H5D_io_info_t *io_info,
     size_t dset_max_nseq, size_t *dset_curr_seq, size_t dset_len_arr[], hsize_t dset_off_arr[],
     size_t mem_max_nseq, size_t *mem_curr_seq, size_t mem_len_arr[], hsize_t mem_off_arr[])
 {
-    H5D_efl_writevv_ud_t udata;  /* User data for H5V_opvv() operator */
+    H5D_efl_writevv_ud_t udata;  /* User data for H5VM_opvv() operator */
     ssize_t ret_value;          /* Return value (Total size of sequence in bytes) */
 
     FUNC_ENTER_STATIC
@@ -555,12 +555,12 @@ H5D__efl_writevv(const H5D_io_info_t *io_info,
     HDassert(mem_len_arr);
     HDassert(mem_off_arr);
 
-    /* Set up user data for H5V_opvv() */
+    /* Set up user data for H5VM_opvv() */
     udata.efl = &(io_info->store->efl);
     udata.wbuf = (const unsigned char *)io_info->u.wbuf;
 
     /* Call generic sequence operation routine */
-    if((ret_value = H5V_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
+    if((ret_value = H5VM_opvv(dset_max_nseq, dset_curr_seq, dset_len_arr, dset_off_arr,
             mem_max_nseq, mem_curr_seq, mem_len_arr, mem_off_arr,
             H5D__efl_writevv_cb, &udata)) < 0)
         HGOTO_ERROR(H5E_DATASET, H5E_CANTOPERATE, FAIL, "can't perform vectorized EFL write")
diff --git a/src/H5Dfill.c b/src/H5Dfill.c
index 2edb363..e682dd6 100644
--- a/src/H5Dfill.c
+++ b/src/H5Dfill.c
@@ -38,7 +38,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5Iprivate.h"		/* IDs			  		*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 
@@ -262,7 +262,7 @@ H5D__fill(const void *fill, const H5T_t *fill_type, void *buf,
                 HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, FAIL, "memory allocation failed")
 
             /* Replicate the file's fill value into the temporary buffer */
-            H5V_array_fill(tmp_buf, fill, src_type_size, (size_t)nelmts);
+            H5VM_array_fill(tmp_buf, fill, src_type_size, (size_t)nelmts);
 
             /* Convert from file's fill value into memory form */
             if(H5T_convert(tpath, src_id, dst_id, (size_t)nelmts, (size_t)0, (size_t)0, tmp_buf, bkg_buf, dxpl_id) < 0)
@@ -494,7 +494,7 @@ H5D__fill_init(H5D_fill_buf_info_t *fb_info, void *caller_fill_buf,
             } /* end else */
 
             /* Replicate the fill value into the cached buffer */
-            H5V_array_fill(fb_info->fill_buf, fill->buf, fb_info->max_elmt_size, fb_info->elmts_per_buf);
+            H5VM_array_fill(fb_info->fill_buf, fill->buf, fb_info->max_elmt_size, fb_info->elmts_per_buf);
         } /* end else */
     } /* end if */
     else {      /* Fill the buffer with the default fill value */
@@ -588,7 +588,7 @@ H5D__fill_refill_vl(H5D_fill_buf_info_t *fb_info, size_t nelmts, hid_t dxpl_id)
 
     /* Replicate the fill value into the cached buffer */
     if(nelmts > 1)
-        H5V_array_fill((void *)((unsigned char *)fb_info->fill_buf + fb_info->mem_elmt_size), fb_info->fill_buf, fb_info->mem_elmt_size, (nelmts - 1));
+        H5VM_array_fill((void *)((unsigned char *)fb_info->fill_buf + fb_info->mem_elmt_size), fb_info->fill_buf, fb_info->mem_elmt_size, (nelmts - 1));
 
     /* Reset the entire background buffer, if necessary */
     if(H5T_path_bkg(fb_info->mem_to_dset_tpath))
diff --git a/src/H5Dmpio.c b/src/H5Dmpio.c
index 4d4c2bf..3b5bb30 100644
--- a/src/H5Dmpio.c
+++ b/src/H5Dmpio.c
@@ -43,7 +43,7 @@
 #include "H5Oprivate.h"       /* Object headers    */
 #include "H5Pprivate.h"       /* Property lists    */
 #include "H5Sprivate.h"       /* Dataspaces        */
-#include "H5Vprivate.h"       /* Vector            */
+#include "H5VMprivate.h"       /* Vector            */
 
 #ifdef H5_HAVE_PARALLEL
 
diff --git a/src/H5EA.c b/src/H5EA.c
index 1679f89..c967517 100644
--- a/src/H5EA.c
+++ b/src/H5EA.c
@@ -48,7 +48,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Vprivate.h"         /* Vector functions			*/
+#include "H5VMprivate.h"         /* Vector functions			*/
 
 
 /****************/
@@ -560,13 +560,13 @@ if(sblock->dblk_npages)
 HDfprintf(stderr, "%s: sblock->addr = %a\n", FUNC, sblock->addr);
 HDfprintf(stderr, "%s: sblock->dblk_addrs[%Zu] = %a\n", FUNC, dblk_idx, sblock->dblk_addrs[dblk_idx]);
 HDfprintf(stderr, "%s: H5EA_DBLOCK_PREFIX_SIZE(sblock) = %u\n", FUNC, (unsigned)H5EA_DBLOCK_PREFIX_SIZE(sblock));
-HDfprintf(stderr, "%s: sblock->page_init[%Zu] = %t\n", FUNC, page_init_idx, H5V_bit_get(sblock->page_init, page_init_idx));
+HDfprintf(stderr, "%s: sblock->page_init[%Zu] = %t\n", FUNC, page_init_idx, H5VM_bit_get(sblock->page_init, page_init_idx));
 HDfprintf(stderr, "%s: page_idx = %Zu, elmt_idx = %Hu, dblk_page_addr = %a\n", FUNC, page_idx, elmt_idx, dblk_page_addr);
 HDfprintf(stderr, "%s: sblock->dblk_page_size = %Zu\n", FUNC, sblock->dblk_page_size);
 #endif /* QAK */
 
                 /* Check if page has been initialized yet */
-                if(!H5V_bit_get(sblock->page_init, page_init_idx)) {
+                if(!H5VM_bit_get(sblock->page_init, page_init_idx)) {
                     /* Check if we are allowed to create the thing */
                     if(H5AC_WRITE == thing_acc) {
                         /* Create the data block page */
@@ -574,7 +574,7 @@ HDfprintf(stderr, "%s: sblock->dblk_page_size = %Zu\n", FUNC, sblock->dblk_page_
                             H5E_THROW(H5E_CANTCREATE, "unable to create data block page")
 
                         /* Mark data block page as initialized in super block */
-                        H5V_bit_set(sblock->page_init, page_init_idx, TRUE);
+                        H5VM_bit_set(sblock->page_init, page_init_idx, TRUE);
                         sblock_cache_flags |= H5AC__DIRTIED_FLAG;
                     } /* end if */
                     else
diff --git a/src/H5EAcache.c b/src/H5EAcache.c
index a178536..1d40283 100644
--- a/src/H5EAcache.c
+++ b/src/H5EAcache.c
@@ -43,7 +43,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 
diff --git a/src/H5EAdblkpage.c b/src/H5EAdblkpage.c
index eba7470..3c2da7c 100644
--- a/src/H5EAdblkpage.c
+++ b/src/H5EAdblkpage.c
@@ -43,7 +43,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
diff --git a/src/H5EAdblock.c b/src/H5EAdblock.c
index 640f353..dd1e7b0 100644
--- a/src/H5EAdblock.c
+++ b/src/H5EAdblock.c
@@ -44,7 +44,7 @@
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -276,7 +276,7 @@ HDfprintf(stderr, "%s: after adjusting for index block elements, idx = %Hu\n", F
 #ifdef QAK
 HDfprintf(stderr, "%s: hdr->cparam.data_blk_min_elmts = %u\n", FUNC, (unsigned)hdr->cparam.data_blk_min_elmts);
 #endif /* QAK */
-    sblk_idx = H5V_log2_gen((uint64_t)((idx / hdr->cparam.data_blk_min_elmts) + 1));
+    sblk_idx = H5VM_log2_gen((uint64_t)((idx / hdr->cparam.data_blk_min_elmts) + 1));
 #ifdef QAK
 HDfprintf(stderr, "%s: sblk_idx = %u\n", FUNC, sblk_idx);
 HDfprintf(stderr, "%s: hdr->sblk_info[%u] = {%Hu, %Zu, %Hu, %Hu}\n", FUNC, sblk_idx, hdr->sblk_info[sblk_idx].ndblks, hdr->sblk_info[sblk_idx].dblk_nelmts, hdr->sblk_info[sblk_idx].start_idx, hdr->sblk_info[sblk_idx].start_dblk);
diff --git a/src/H5EAhdr.c b/src/H5EAhdr.c
index 08d2fb9..d5f3538 100644
--- a/src/H5EAhdr.c
+++ b/src/H5EAhdr.c
@@ -43,7 +43,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -201,7 +201,7 @@ H5EA__hdr_init(H5EA_hdr_t *hdr, void *ctx_udata))
     HDassert(hdr->cparam.sup_blk_min_data_ptrs);
 
     /* Compute general information */
-    hdr->nsblks = 1 + (hdr->cparam.max_nelmts_bits - H5V_log2_of2(hdr->cparam.data_blk_min_elmts));
+    hdr->nsblks = 1 + (hdr->cparam.max_nelmts_bits - H5VM_log2_of2(hdr->cparam.data_blk_min_elmts));
     hdr->dblk_page_nelmts = (size_t)1 << hdr->cparam.max_dblk_page_nelmts_bits;
     hdr->arr_off_size = (unsigned char)H5EA_SIZEOF_OFFSET_BITS(hdr->cparam.max_nelmts_bits);
 #ifdef QAK
@@ -270,7 +270,7 @@ H5EA__hdr_alloc_elmts(H5EA_hdr_t *hdr, size_t nelmts))
 
     /* Compute the index of the element buffer factory */
     H5_CHECK_OVERFLOW(nelmts, /*From:*/size_t, /*To:*/uint32_t);
-    idx = H5V_log2_of2((uint32_t)nelmts) - H5V_log2_of2((uint32_t)hdr->cparam.data_blk_min_elmts);
+    idx = H5VM_log2_of2((uint32_t)nelmts) - H5VM_log2_of2((uint32_t)hdr->cparam.data_blk_min_elmts);
 #ifdef QAK
 HDfprintf(stderr, "%s: nelmts = %Zu, hdr->data_blk_min_elmts = %u, idx = %u\n", FUNC, nelmts, (unsigned)hdr->data_blk_min_elmts, idx);
 #endif /* QAK */
@@ -340,7 +340,7 @@ H5EA__hdr_free_elmts(H5EA_hdr_t *hdr, size_t nelmts, void *elmts))
 
     /* Compute the index of the element buffer factory */
     H5_CHECK_OVERFLOW(nelmts, /*From:*/size_t, /*To:*/uint32_t);
-    idx = H5V_log2_of2((uint32_t)nelmts) - H5V_log2_of2((uint32_t)hdr->cparam.data_blk_min_elmts);
+    idx = H5VM_log2_of2((uint32_t)nelmts) - H5VM_log2_of2((uint32_t)hdr->cparam.data_blk_min_elmts);
 #ifdef QAK
 HDfprintf(stderr, "%s: nelmts = %Zu, hdr->data_blk_min_elmts = %u, idx = %u\n", FUNC, nelmts, (unsigned)hdr->data_blk_min_elmts, idx);
 #endif /* QAK */
diff --git a/src/H5EAiblock.c b/src/H5EAiblock.c
index e18947a..3c2894a 100644
--- a/src/H5EAiblock.c
+++ b/src/H5EAiblock.c
@@ -44,7 +44,7 @@
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -219,7 +219,7 @@ HDfprintf(stderr, "%s: iblock->size = %Zu\n", FUNC, iblock->size);
         haddr_t tmp_addr = HADDR_UNDEF;         /* Address value to fill data block addresses with */
 
         /* Set all the data block addresses to "undefined" address value */
-        H5V_array_fill(iblock->dblk_addrs, &tmp_addr, sizeof(haddr_t), iblock->ndblk_addrs);
+        H5VM_array_fill(iblock->dblk_addrs, &tmp_addr, sizeof(haddr_t), iblock->ndblk_addrs);
     } /* end if */
 
     /* Reset any super block addresses in the index block */
@@ -227,7 +227,7 @@ HDfprintf(stderr, "%s: iblock->size = %Zu\n", FUNC, iblock->size);
         haddr_t tmp_addr = HADDR_UNDEF;         /* Address value to fill super block addresses with */
 
         /* Set all the super block addresses to "undefined" address value */
-        H5V_array_fill(iblock->sblk_addrs, &tmp_addr, sizeof(haddr_t), iblock->nsblk_addrs);
+        H5VM_array_fill(iblock->sblk_addrs, &tmp_addr, sizeof(haddr_t), iblock->nsblk_addrs);
     } /* end if */
 
     /* Cache the new extensible array index block */
diff --git a/src/H5EApkg.h b/src/H5EApkg.h
index af560b5..fc15e72 100644
--- a/src/H5EApkg.h
+++ b/src/H5EApkg.h
@@ -148,7 +148,7 @@
 #define H5EA_SIZEOF_OFFSET_BITS(b)      (((b) + 7) / 8)
 
 /* Compute the first super block index that will hold a certain # of data block pointers */
-#define H5EA_SBLK_FIRST_IDX(m)          (2 * H5V_log2_of2((uint32_t)m))
+#define H5EA_SBLK_FIRST_IDX(m)          (2 * H5VM_log2_of2((uint32_t)m))
 
 /****************************/
 /* Package Private Typedefs */
diff --git a/src/H5EAsblock.c b/src/H5EAsblock.c
index ba1c40f..1cc8bd9 100644
--- a/src/H5EAsblock.c
+++ b/src/H5EAsblock.c
@@ -44,7 +44,7 @@
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -229,7 +229,7 @@ HDfprintf(stderr, "%s: sblock->block_off = %Hu\n", FUNC, sblock->block_off);
     sblock->addr = sblock_addr;
 
     /* Reset data block addresses to "undefined" address value */
-    H5V_array_fill(sblock->dblk_addrs, &tmp_addr, sizeof(haddr_t), sblock->ndblks);
+    H5VM_array_fill(sblock->dblk_addrs, &tmp_addr, sizeof(haddr_t), sblock->ndblks);
 
     /* Cache the new extensible array super block */
     if(H5AC_insert_entry(hdr->f, dxpl_id, H5AC_EARRAY_SBLOCK, sblock_addr, sblock, H5AC__NO_FLAGS_SET) < 0)
diff --git a/src/H5EAtest.c b/src/H5EAtest.c
index 0153a1e..94303c3 100644
--- a/src/H5EAtest.c
+++ b/src/H5EAtest.c
@@ -40,7 +40,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5EApkg.h"		/* Extensible Arrays			*/
 #include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Vprivate.h"         /* Vector functions			*/
+#include "H5VMprivate.h"         /* Vector functions			*/
 
 
 /****************/
@@ -210,7 +210,7 @@ H5EA__test_fill(void *nat_blk, size_t nelmts))
     HDassert(nat_blk);
     HDassert(nelmts);
 
-    H5V_array_fill(nat_blk, &fill_val, sizeof(uint64_t), nelmts);
+    H5VM_array_fill(nat_blk, &fill_val, sizeof(uint64_t), nelmts);
 
 END_FUNC(STATIC)  /* end H5EA__test_fill() */
 
diff --git a/src/H5FA.c b/src/H5FA.c
index 2a602a1..128999a 100644
--- a/src/H5FA.c
+++ b/src/H5FA.c
@@ -43,7 +43,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FApkg.h"		/* Fixed Arrays				*/
 #include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Vprivate.h"         /* Vector functions			*/
+#include "H5VMprivate.h"         /* Vector functions			*/
 
 
 /****************/
@@ -389,13 +389,13 @@ HDfprintf(stderr, "%s: fixed array data block address not defined!\n", FUNC, idx
 	    dblk_page_nelmts = dblock->dblk_page_nelmts;
 
         /* Check if the page has been created yet */
-        if(!H5V_bit_get(dblock->dblk_page_init, page_idx)) {
+        if(!H5VM_bit_get(dblock->dblk_page_init, page_idx)) {
 	    /* Create the data block page */
 	    if(H5FA__dblk_page_create(hdr, dxpl_id, dblk_page_addr, dblk_page_nelmts) < 0)
 		H5E_THROW(H5E_CANTCREATE, "unable to create data block page")
 
 	    /* Mark data block page as initialized in data block */
-	    H5V_bit_set(dblock->dblk_page_init, page_idx, TRUE);
+	    H5VM_bit_set(dblock->dblk_page_init, page_idx, TRUE);
 	    dblock_cache_flags |= H5AC__DIRTIED_FLAG;
 	} /* end if */
 
@@ -481,7 +481,7 @@ HDfprintf(stderr, "%s: Index %Hu\n", FUNC, idx);
             page_idx = (size_t)(idx / dblock->dblk_page_nelmts);
 
             /* Check if the page is defined yet */
-            if(!H5V_bit_get(dblock->dblk_page_init, page_idx)) {
+            if(!H5VM_bit_get(dblock->dblk_page_init, page_idx)) {
                 /* Call the class's 'fill' callback */
                 if((hdr->cparam.cls->fill)(elmt, (size_t)1) < 0)
                     H5E_THROW(H5E_CANTSET, "can't set element to class's fill value")
diff --git a/src/H5FAcache.c b/src/H5FAcache.c
index 14df4c8..cb156db 100644
--- a/src/H5FAcache.c
+++ b/src/H5FAcache.c
@@ -41,7 +41,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FApkg.h"		/* Fixed Arrays				*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 
diff --git a/src/H5FAdbg.c b/src/H5FAdbg.c
index 9bb90af..eb5e32e 100644
--- a/src/H5FAdbg.c
+++ b/src/H5FAdbg.c
@@ -41,7 +41,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FApkg.h"		/* Fixed Arrays				*/
 #include "H5Oprivate.h"		/* Object Header 			*/
-#include "H5Vprivate.h"         /* Vector functions                     */
+#include "H5VMprivate.h"         /* Vector functions                     */
 
 
 /****************/
@@ -233,7 +233,7 @@ H5FA__dblock_debug(H5F_t *f, hid_t dxpl_id, haddr_t addr, FILE *stream, int inde
 
 	/* Read and print each page's elements in the data block */
 	for(page_idx = 0; page_idx < dblock->npages; page_idx++) {
-	    if(!H5V_bit_get(dblock->dblk_page_init, page_idx)) {
+	    if(!H5VM_bit_get(dblock->dblk_page_init, page_idx)) {
 		HDfprintf(stream, "%*s%-*s %Hu %s\n", indent, "", fwidth,
 		    "Page %Zu:", page_idx, "empty");
 
diff --git a/src/H5FAtest.c b/src/H5FAtest.c
index 1828fa4..298c89d 100644
--- a/src/H5FAtest.c
+++ b/src/H5FAtest.c
@@ -40,7 +40,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FApkg.h"		/* Fixed Arrays				*/
 #include "H5FLprivate.h"	/* Free Lists                           */
-#include "H5Vprivate.h"         /* Vector functions			*/
+#include "H5VMprivate.h"         /* Vector functions			*/
 
 
 /****************/
@@ -206,7 +206,7 @@ H5FA__test_fill(void *nat_blk, size_t nelmts))
     HDassert(nat_blk);
     HDassert(nelmts);
 
-    H5V_array_fill(nat_blk, &fill_val, sizeof(uint64_t), nelmts);
+    H5VM_array_fill(nat_blk, &fill_val, sizeof(uint64_t), nelmts);
 
 END_FUNC(STATIC)  /* end H5FA__test_fill() */
 
diff --git a/src/H5FScache.c b/src/H5FScache.c
index e441398..e03a0a4 100644
--- a/src/H5FScache.c
+++ b/src/H5FScache.c
@@ -38,7 +38,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FSpkg.h"		/* File free space			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 /****************/
@@ -612,7 +612,7 @@ H5FS_cache_sinfo_load(H5F_t *f, hid_t dxpl_id, haddr_t UNUSED addr, void *_udata
         unsigned sect_cnt_size;         /* The size of the section size counts */
 
         /* Compute the size of the section counts */
-        sect_cnt_size = H5V_limit_enc_size((uint64_t)udata->fspace->serial_sect_count);
+        sect_cnt_size = H5VM_limit_enc_size((uint64_t)udata->fspace->serial_sect_count);
 
         /* Reset the section count, the "add" routine will update it */
         old_tot_sect_count = udata->fspace->tot_sect_count;
@@ -862,7 +862,7 @@ H5FS_cache_sinfo_flush(H5F_t *f, hid_t dxpl_id, hbool_t destroy, haddr_t addr, H
         /* Set up user data for iterator */
         udata.sinfo = sinfo;
         udata.p = &p;
-        udata.sect_cnt_size = H5V_limit_enc_size((uint64_t)sinfo->fspace->serial_sect_count);
+        udata.sect_cnt_size = H5VM_limit_enc_size((uint64_t)sinfo->fspace->serial_sect_count);
 
         /* Iterate over all the bins */
         for(bin = 0; bin < sinfo->nbins; bin++) {
diff --git a/src/H5FSsection.c b/src/H5FSsection.c
index c0084b8..b06c9b8 100644
--- a/src/H5FSsection.c
+++ b/src/H5FSsection.c
@@ -35,7 +35,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5FSpkg.h"		/* File free space			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -143,10 +143,10 @@ HDfprintf(stderr, "%s: fspace->addr = %a\n", FUNC, fspace->addr);
 	HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, NULL, "memory allocation failed")
 
     /* Set non-zero values */
-    sinfo->nbins = H5V_log2_gen(fspace->max_sect_size);
+    sinfo->nbins = H5VM_log2_gen(fspace->max_sect_size);
     sinfo->sect_prefix_size = (size_t)H5FS_SINFO_PREFIX_SIZE(f);
     sinfo->sect_off_size = (fspace->max_sect_addr + 7) / 8;
-    sinfo->sect_len_size = H5V_limit_enc_size((uint64_t)fspace->max_sect_size);
+    sinfo->sect_len_size = H5VM_limit_enc_size((uint64_t)fspace->max_sect_size);
 #ifdef H5FS_SINFO_DEBUG
 HDfprintf(stderr, "%s: fspace->max_sect_size = %Hu\n", FUNC, fspace->max_sect_size);
 HDfprintf(stderr, "%s: fspace->max_sect_addr = %u\n", FUNC, fspace->max_sect_addr);
@@ -499,7 +499,7 @@ HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", "H5FS_sect_ser
 HDfprintf(stderr, "%s: fspace->sinfo->serial_size_count = %Zu\n", "H5FS_sect_serialize_size", fspace->sinfo->serial_size_count);
 HDfprintf(stderr, "%s: fspace->serial_sect_count = %Hu\n", "H5FS_sect_serialize_size", fspace->serial_sect_count);
 #endif /* QAK */
-        sect_buf_size += fspace->sinfo->serial_size_count * H5V_limit_enc_size((uint64_t)fspace->serial_sect_count);
+        sect_buf_size += fspace->sinfo->serial_size_count * H5VM_limit_enc_size((uint64_t)fspace->serial_sect_count);
 
         /* Size for each differently sized serializable section */
         sect_buf_size += fspace->sinfo->serial_size_count * fspace->sinfo->sect_len_size;
@@ -765,7 +765,7 @@ H5FS_sect_unlink_size(H5FS_sinfo_t *sinfo, const H5FS_section_class_t *cls,
     HDassert(cls);
 
     /* Determine correct bin which holds items of at least the section's size */
-    bin = H5V_log2_gen(sect->size);
+    bin = H5VM_log2_gen(sect->size);
     HDassert(bin < sinfo->nbins);
     if(sinfo->bins[bin].bin_list == NULL)
         HGOTO_ERROR(H5E_FSPACE, H5E_NOTFOUND, FAIL, "node's bin is empty?")
@@ -966,7 +966,7 @@ HDfprintf(stderr, "%s: sect->size = %Hu, sect->addr = %a\n", FUNC, sect->size, s
     HDassert(sect->size);
 
     /* Determine correct bin which holds items of the section's size */
-    bin = H5V_log2_gen(sect->size);
+    bin = H5VM_log2_gen(sect->size);
     HDassert(bin < sinfo->nbins);
     if(sinfo->bins[bin].bin_list == NULL) {
         if(NULL == (sinfo->bins[bin].bin_list = H5SL_create(H5SL_TYPE_HSIZE, NULL)))
@@ -1687,7 +1687,7 @@ H5FS_sect_find_node(H5FS_t *fspace, hsize_t request, H5FS_section_info_t **node)
     HDassert(node);
 
     /* Determine correct bin which holds items of at least the section's size */
-    bin = H5V_log2_gen(request);
+    bin = H5VM_log2_gen(request);
     HDassert(bin < fspace->sinfo->nbins);
 #ifdef QAK
 HDfprintf(stderr, "%s: fspace->sinfo->nbins = %u\n", FUNC, fspace->sinfo->nbins);
@@ -2121,7 +2121,7 @@ HDfprintf(stderr, "%s: to_ghost = %u\n", FUNC, to_ghost);
         HDassert(fspace->sinfo->bins);
 
         /* Determine correct bin which holds items of at least the section's size */
-        bin = H5V_log2_gen(sect->size);
+        bin = H5VM_log2_gen(sect->size);
         HDassert(bin < fspace->sinfo->nbins);
         HDassert(fspace->sinfo->bins[bin].bin_list);
 
diff --git a/src/H5Faccum.c b/src/H5Faccum.c
index e0ce292..037c085 100644
--- a/src/H5Faccum.c
+++ b/src/H5Faccum.c
@@ -40,7 +40,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fpkg.h"             /* File access				*/
 #include "H5FDprivate.h"	/* File drivers				*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -151,7 +151,7 @@ H5F_accum_read(const H5F_t *f, hid_t dxpl_id, H5FD_mem_t type, haddr_t addr,
                     size_t new_alloc_size;        /* New size of accumulator */
 
                     /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                    new_alloc_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(new_size - 1)));
+                    new_alloc_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(new_size - 1)));
 
                     /* Reallocate the metadata accumulator buffer */
                     if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_alloc_size)))
@@ -295,7 +295,7 @@ H5F_accum_adjust(H5F_meta_accum_t *accum, H5FD_t *lf, hid_t dxpl_id,
         size_t new_size;        /* New size of accumulator */
 
         /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-        new_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)((size + accum->size) - 1)));
+        new_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)((size + accum->size) - 1)));
 
         /* Check for accumulator getting too big */
         if(new_size > H5F_ACCUM_MAX_SIZE) {
@@ -606,7 +606,7 @@ H5F_accum_write(const H5F_t *f, hid_t dxpl_id, H5FD_mem_t type, haddr_t addr,
                             size_t new_alloc_size;        /* New size of accumulator */
 
                             /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                            new_alloc_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(size - 1)));
+                            new_alloc_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(size - 1)));
 
                             /* Reallocate the metadata accumulator buffer */
                             if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_alloc_size)))
@@ -649,7 +649,7 @@ HDmemset(f->shared->accum.buf + size, 0, (f->shared->accum.alloc_size - size));
                         size_t new_size;        /* New size of accumulator */
 
                         /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                        new_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(size - 1)));
+                        new_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(size - 1)));
 
                         /* Grow the metadata accumulator buffer */
                         if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_size)))
@@ -699,7 +699,7 @@ HDmemset(f->shared->accum.buf + clear_size, 0, (f->shared->accum.alloc_size - cl
                     size_t new_size;        /* New size of accumulator */
 
                     /* Adjust the buffer size to be a power of 2 that is large enough to hold data */
-                    new_size = (size_t)1 << (1 + H5V_log2_gen((uint64_t)(size - 1)));
+                    new_size = (size_t)1 << (1 + H5VM_log2_gen((uint64_t)(size - 1)));
 
                     /* Reallocate the metadata accumulator buffer */
                     if(NULL == (f->shared->accum.buf = H5FL_BLK_REALLOC(meta_accum, f->shared->accum.buf, new_size)))
diff --git a/src/H5Fprivate.h b/src/H5Fprivate.h
index 3565696..2690311 100644
--- a/src/H5Fprivate.h
+++ b/src/H5Fprivate.h
@@ -27,7 +27,7 @@
 #include "H5FDpublic.h"		/* File drivers				*/
 
 /* Private headers needed by this file */
-#include "H5Vprivate.h"		/* Vectors and arrays */
+#include "H5VMprivate.h"		/* Vectors and arrays */
 
 
 /****************************/
@@ -119,7 +119,7 @@ typedef struct H5F_blk_aggr_t H5F_blk_aggr_t;
 /* (Assumes that the high bits of the integer are zero) */
 #  define UINT64ENCODE_VARLEN(p, n) {					      \
    uint64_t __n = (uint64_t)(n);							      \
-   unsigned _s = H5V_limit_enc_size(__n);				      \
+   unsigned _s = H5VM_limit_enc_size(__n);				      \
 									      \
    *(p)++ = (uint8_t)_s;						      \
    UINT64ENCODE_VAR(p, __n, _s);						      \
diff --git a/src/H5HFcache.c b/src/H5HFcache.c
index ddff0e0..030927d 100644
--- a/src/H5HFcache.c
+++ b/src/H5HFcache.c
@@ -40,7 +40,7 @@
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 
diff --git a/src/H5HFdbg.c b/src/H5HFdbg.c
index 5d68fd1..7d22ddd 100644
--- a/src/H5HFdbg.c
+++ b/src/H5HFdbg.c
@@ -39,7 +39,7 @@
 #include "H5FLprivate.h"	/* Free Lists                           */
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -638,10 +638,10 @@ H5HF_iblock_print(const H5HF_indirect_t *iblock,
         unsigned    first_row_bits;         /* Number of bits used bit addresses in first row */
         unsigned    num_indirect_rows;      /* Number of rows of blocks in each indirect block */
 
-        first_row_bits = H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
-                            H5V_log2_of2(hdr->man_dtable.cparam.width);
+        first_row_bits = H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
+                            H5VM_log2_of2(hdr->man_dtable.cparam.width);
         for(u = hdr->man_dtable.max_direct_rows; u < iblock->nrows; u++) {
-            num_indirect_rows = (H5V_log2_gen(hdr->man_dtable.row_block_size[u]) - first_row_bits) + 1;
+            num_indirect_rows = (H5VM_log2_gen(hdr->man_dtable.row_block_size[u]) - first_row_bits) + 1;
             HDsnprintf(temp_str, sizeof(temp_str), "Row #%u: (# of rows: %u)", (unsigned)u, num_indirect_rows);
             HDfprintf(stream, "%*s%-*s\n", indent + 3, "", MAX(0, fwidth - 3),
                     temp_str);
diff --git a/src/H5HFdblock.c b/src/H5HFdblock.c
index afc7f25..dd36613 100644
--- a/src/H5HFdblock.c
+++ b/src/H5HFdblock.c
@@ -38,7 +38,7 @@
 #include "H5Fprivate.h"		/* File access				*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -354,7 +354,7 @@ H5HF_man_dblock_new(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t request,
     if(request < hdr->man_dtable.cparam.start_block_size)
         min_dblock_size = hdr->man_dtable.cparam.start_block_size;
     else {
-        min_dblock_size = ((size_t)1) << (1 + H5V_log2_gen((uint64_t)request));
+        min_dblock_size = ((size_t)1) << (1 + H5VM_log2_gen((uint64_t)request));
         HDassert(min_dblock_size <= hdr->man_dtable.cparam.max_direct_size);
     } /* end else */
 
@@ -549,7 +549,7 @@ H5HF_man_dblock_locate(H5HF_hdr_t *hdr, hid_t dxpl_id, hsize_t obj_off,
         unsigned cache_flags = H5AC__NO_FLAGS_SET;      /* Flags for unprotecting parent indirect block */
 
         /* Compute # of rows in child indirect block */
-        nrows = (H5V_log2_gen(hdr->man_dtable.row_block_size[row]) - hdr->man_dtable.first_row_bits) + 1;
+        nrows = (H5VM_log2_gen(hdr->man_dtable.row_block_size[row]) - hdr->man_dtable.first_row_bits) + 1;
         HDassert(nrows < iblock->nrows);        /* child must be smaller than parent */
 
         /* Compute indirect block's entry */
diff --git a/src/H5HFdtable.c b/src/H5HFdtable.c
index a7d95bc..607862a 100644
--- a/src/H5HFdtable.c
+++ b/src/H5HFdtable.c
@@ -37,7 +37,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -104,10 +104,10 @@ H5HF_dtable_init(H5HF_dtable_t *dtable)
     HDassert(dtable);
 
     /* Compute/cache some values */
-    dtable->start_bits = H5V_log2_of2((uint32_t)dtable->cparam.start_block_size);
-    dtable->first_row_bits = dtable->start_bits + H5V_log2_of2(dtable->cparam.width);
+    dtable->start_bits = H5VM_log2_of2((uint32_t)dtable->cparam.start_block_size);
+    dtable->first_row_bits = dtable->start_bits + H5VM_log2_of2(dtable->cparam.width);
     dtable->max_root_rows = (dtable->cparam.max_index - dtable->first_row_bits) + 1;
-    dtable->max_direct_bits = H5V_log2_of2((uint32_t)dtable->cparam.max_direct_size);
+    dtable->max_direct_bits = H5VM_log2_of2((uint32_t)dtable->cparam.max_direct_size);
     dtable->max_direct_rows = (dtable->max_direct_bits - dtable->start_bits) + 2;
     dtable->num_id_first_row = dtable->cparam.start_block_size * dtable->cparam.width;
     dtable->max_dir_blk_off_size = H5HF_SIZEOF_OFFSET_LEN(dtable->cparam.max_direct_size);
@@ -171,7 +171,7 @@ HDfprintf(stderr, "%s: off = %Hu\n", "H5HF_dtable_lookup", off);
         H5_ASSIGN_OVERFLOW(/* To: */ *col, /* From: */ (off / dtable->cparam.start_block_size), /* From: */ hsize_t, /* To: */ unsigned);
     } /* end if */
     else {
-        unsigned high_bit = H5V_log2_gen(off);  /* Determine the high bit in the offset */
+        unsigned high_bit = H5VM_log2_gen(off);  /* Determine the high bit in the offset */
         hsize_t off_mask = ((hsize_t)1) << high_bit;       /* Compute mask for determining column */
 
 #ifdef QAK
@@ -252,7 +252,7 @@ H5HF_dtable_size_to_row(const H5HF_dtable_t *dtable, size_t block_size)
     if(block_size == dtable->cparam.start_block_size)
         row = 0;
     else
-        row = (H5V_log2_of2((uint32_t)block_size) - H5V_log2_of2((uint32_t)dtable->cparam.start_block_size)) + 1;
+        row = (H5VM_log2_of2((uint32_t)block_size) - H5VM_log2_of2((uint32_t)dtable->cparam.start_block_size)) + 1;
 
     FUNC_LEAVE_NOAPI(row)
 } /* end H5HF_dtable_size_to_row() */
@@ -283,7 +283,7 @@ H5HF_dtable_size_to_rows(const H5HF_dtable_t *dtable, hsize_t size)
      */
     HDassert(dtable);
 
-    rows = (H5V_log2_gen(size) - dtable->first_row_bits) + 1;
+    rows = (H5VM_log2_gen(size) - dtable->first_row_bits) + 1;
 
     FUNC_LEAVE_NOAPI(rows)
 } /* end H5HF_dtable_size_to_rows() */
diff --git a/src/H5HFhdr.c b/src/H5HFhdr.c
index e4b89ba..d3c4473 100644
--- a/src/H5HFhdr.c
+++ b/src/H5HFhdr.c
@@ -37,7 +37,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -46,7 +46,7 @@
 #ifndef NDEBUG
 /* Limit on the size of the max. direct block size */
 /* (This is limited to 32-bits currently, because I think it's unlikely to
- *      need to be larger, the 32-bit limit for H5V_log2_of2(n), and
+ *      need to be larger, the 32-bit limit for H5VM_log2_of2(n), and
  *      some offsets/sizes are encoded with a maxiumum of 32-bits  - QAK)
  */
 #define H5HF_MAX_DIRECT_SIZE_LIMIT ((hsize_t)2 * 1024 * 1024 * 1024)
@@ -224,7 +224,7 @@ H5HF_hdr_finish_init_phase1(H5HF_hdr_t *hdr)
 
     /* Set the size of heap IDs */
     hdr->heap_len_size = MIN(hdr->man_dtable.max_dir_blk_off_size,
-            H5V_limit_enc_size((uint64_t)hdr->max_man_size));
+            H5VM_limit_enc_size((uint64_t)hdr->max_man_size));
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1089,7 +1089,7 @@ H5HF_hdr_update_iter(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t min_dblock_size)
                     unsigned child_entry;           /* Entry of child indirect block */
 
                     /* Compute # of rows needed in child indirect block */
-                    child_rows_needed = (H5V_log2_of2((uint32_t)min_dblock_size) - H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size)) + 2;
+                    child_rows_needed = (H5VM_log2_of2((uint32_t)min_dblock_size) - H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size)) + 2;
                     HDassert(child_rows_needed > child_nrows);
                     child_entry = (next_row + (child_rows_needed - child_nrows)) * hdr->man_dtable.cparam.width;
                     if(child_entry > (iblock->nrows * hdr->man_dtable.cparam.width))
diff --git a/src/H5HFiblock.c b/src/H5HFiblock.c
index 342e228..c989bfc 100644
--- a/src/H5HFiblock.c
+++ b/src/H5HFiblock.c
@@ -38,7 +38,7 @@
 #include "H5Fprivate.h"		/* File access				*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -409,7 +409,7 @@ H5HF_man_iblock_root_create(H5HF_hdr_t *hdr, hid_t dxpl_id, size_t min_dblock_si
 
         nrows = hdr->man_dtable.cparam.start_root_rows;
 
-        block_row_off = H5V_log2_of2((uint32_t)min_dblock_size) - H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size);
+        block_row_off = H5VM_log2_of2((uint32_t)min_dblock_size) - H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size);
         if(block_row_off > 0)
             block_row_off++;        /* Account for the pair of initial rows of the initial block size */
         rows_needed = 1 + block_row_off;
@@ -730,7 +730,7 @@ H5HF_man_iblock_root_halve(H5HF_indirect_t *iblock, hid_t dxpl_id)
     max_child_row = iblock->max_child / hdr->man_dtable.cparam.width;
 
     /* Compute new # of rows in root indirect block */
-    new_nrows = 1 << (1 + H5V_log2_gen((uint64_t)max_child_row));
+    new_nrows = 1 << (1 + H5VM_log2_gen((uint64_t)max_child_row));
 
     /* Check if the indirect block is NOT currently allocated in temp. file space */
     /* (temp. file space does not need to be freed) */
@@ -1662,10 +1662,10 @@ H5HF_man_iblock_size(H5F_t *f, hid_t dxpl_id, H5HF_hdr_t *hdr, haddr_t iblock_ad
         size_t      u;                  /* Local index variable */
 
         entry = hdr->man_dtable.max_direct_rows * hdr->man_dtable.cparam.width;
-	first_row_bits = H5V_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
-			    H5V_log2_of2(hdr->man_dtable.cparam.width);
+	first_row_bits = H5VM_log2_of2((uint32_t)hdr->man_dtable.cparam.start_block_size) +
+			    H5VM_log2_of2(hdr->man_dtable.cparam.width);
         num_indirect_rows =
-	    (H5V_log2_gen(hdr->man_dtable.row_block_size[hdr->man_dtable.max_direct_rows]) - first_row_bits) + 1;
+	    (H5VM_log2_gen(hdr->man_dtable.row_block_size[hdr->man_dtable.max_direct_rows]) - first_row_bits) + 1;
         for(u = hdr->man_dtable.max_direct_rows; u < iblock->nrows; u++, num_indirect_rows++) {
             size_t      v;                      /* Local index variable */
 
diff --git a/src/H5HFiter.c b/src/H5HFiter.c
index 0f2f7a4..137d0ee 100644
--- a/src/H5HFiter.c
+++ b/src/H5HFiter.c
@@ -36,7 +36,7 @@
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
@@ -213,7 +213,7 @@ H5HF_man_iter_start_offset(H5HF_hdr_t *hdr, hid_t dxpl_id,
 
             /* Compute # of rows in context indirect block */
             child_size = hdr->man_dtable.row_block_size[biter->curr->up->row];
-            iblock_nrows = (H5V_log2_gen(child_size) - hdr->man_dtable.first_row_bits) + 1;
+            iblock_nrows = (H5VM_log2_gen(child_size) - hdr->man_dtable.first_row_bits) + 1;
         } /* end else */
 
         /* Load indirect block for this context location */
diff --git a/src/H5HFman.c b/src/H5HFman.c
index 23afb5e..882d2ba 100644
--- a/src/H5HFman.c
+++ b/src/H5HFman.c
@@ -38,7 +38,7 @@
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MFprivate.h"	/* File memory management		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
diff --git a/src/H5HFpkg.h b/src/H5HFpkg.h
index 23b7c35..a17088b 100644
--- a/src/H5HFpkg.h
+++ b/src/H5HFpkg.h
@@ -136,7 +136,7 @@
 
 /* Compute the # of bytes required to store an offset into a given buffer size */
 #define H5HF_SIZEOF_OFFSET_BITS(b)   (((b) + 7) / 8)
-#define H5HF_SIZEOF_OFFSET_LEN(l)   H5HF_SIZEOF_OFFSET_BITS(H5V_log2_of2((unsigned)(l)))
+#define H5HF_SIZEOF_OFFSET_LEN(l)   H5HF_SIZEOF_OFFSET_BITS(H5VM_log2_of2((unsigned)(l)))
 
 /* Heap ID bit flags */
 /* Heap ID version (2 bits: 6-7) */
diff --git a/src/H5HFsection.c b/src/H5HFsection.c
index 794d36c..d78114e 100644
--- a/src/H5HFsection.c
+++ b/src/H5HFsection.c
@@ -34,7 +34,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5HFpkg.h"		/* Fractal heaps			*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 /****************/
 /* Local Macros */
diff --git a/src/H5MF.c b/src/H5MF.c
index 4b0668f..956ec18 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -39,7 +39,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Fpkg.h"             /* File access				*/
 #include "H5MFpkg.h"		/* File memory management		*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /****************/
@@ -301,7 +301,7 @@ H5MF_alloc_create(H5F_t *f, hid_t dxpl_id, H5FD_mem_t type)
     fs_create.client = H5FS_CLIENT_FILE_ID;
     fs_create.shrink_percent = H5MF_FSPACE_SHRINK;
     fs_create.expand_percent = H5MF_FSPACE_EXPAND;
-    fs_create.max_sect_addr = 1 + H5V_log2_gen((uint64_t)f->shared->maxaddr);
+    fs_create.max_sect_addr = 1 + H5VM_log2_gen((uint64_t)f->shared->maxaddr);
     fs_create.max_sect_size = f->shared->maxaddr;
 
     if(NULL == (f->shared->fs_man[type] = H5FS_create(f, dxpl_id, NULL,
diff --git a/src/H5Odtype.c b/src/H5Odtype.c
index b482115..cb6bf98 100644
--- a/src/H5Odtype.c
+++ b/src/H5Odtype.c
@@ -25,7 +25,7 @@
 #include "H5MMprivate.h"	/* Memory management			*/
 #include "H5Opkg.h"             /* Object headers			*/
 #include "H5Tpkg.h"		/* Datatypes				*/
-#include "H5Vprivate.h"		/* Vectors and arrays 			*/
+#include "H5VMprivate.h"		/* Vectors and arrays 			*/
 
 
 /* PRIVATE PROTOTYPES */
@@ -266,7 +266,7 @@ H5O_dtype_decode_helper(H5F_t *f, unsigned *ioflags/*in,out*/, const uint8_t **p
                 unsigned j;
 
                 /* Compute the # of bytes required to store a member offset */
-                offset_nbytes = H5V_limit_enc_size((uint64_t)dt->shared->size);
+                offset_nbytes = H5VM_limit_enc_size((uint64_t)dt->shared->size);
 
                 /*
                  * Compound datatypes...
@@ -891,7 +891,7 @@ H5O_dtype_encode_helper(const H5F_t *f, uint8_t **pp, const H5T_t *dt)
                 unsigned offset_nbytes;         /* Size needed to encode member offsets */
 
                 /* Compute the # of bytes required to store a member offset */
-                offset_nbytes = H5V_limit_enc_size((uint64_t)dt->shared->size);
+                offset_nbytes = H5VM_limit_enc_size((uint64_t)dt->shared->size);
 
                 /*
                  * Compound datatypes...
@@ -1262,7 +1262,7 @@ H5O_dtype_size(const H5F_t *f, const void *_mesg)
                 unsigned offset_nbytes;         /* Size needed to encode member offsets */
 
                 /* Compute the # of bytes required to store a member offset */
-                offset_nbytes = H5V_limit_enc_size((uint64_t)dt->shared->size);
+                offset_nbytes = H5VM_limit_enc_size((uint64_t)dt->shared->size);
 
                 /* Compute the total size needed to encode compound datatype */
                 for(u = 0; u < dt->shared->u.compnd.nmembs; u++) {
diff --git a/src/H5Pdcpl.c b/src/H5Pdcpl.c
index 66c1757..e029da3 100644
--- a/src/H5Pdcpl.c
+++ b/src/H5Pdcpl.c
@@ -668,7 +668,7 @@ H5P__fill_value_enc(const void *value, void **_pp, size_t *size)
 
             /* Encode the size of a size_t */
             enc_value = (uint64_t)dt_size;
-            enc_size = H5V_limit_enc_size(enc_value);
+            enc_size = H5VM_limit_enc_size(enc_value);
             HDassert(enc_size < 256);
 
             /* Encode the size */
@@ -697,7 +697,7 @@ H5P__fill_value_enc(const void *value, void **_pp, size_t *size)
             if(H5T_encode(fill->type, NULL, &dt_size) < 0)
                 HGOTO_ERROR(H5E_DATATYPE, H5E_CANTENCODE, FAIL, "can't encode datatype")
             enc_value = (uint64_t)dt_size;
-            enc_size = H5V_limit_enc_size(enc_value);
+            enc_size = H5VM_limit_enc_size(enc_value);
         }
         *size += (1 + enc_size);
         *size += dt_size;
@@ -873,7 +873,7 @@ H5P__dcrt_ext_file_list_enc(const void *value, void **_pp, size_t *size)
     if(NULL != *pp) {
         /* Encode number of slots used */
         enc_value = (uint64_t)efl->nused;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -883,7 +883,7 @@ H5P__dcrt_ext_file_list_enc(const void *value, void **_pp, size_t *size)
             /* Calculate length of slot name and encode it */
             len = HDstrlen(efl->slot[u].name) + 1;
             enc_value = (uint64_t)len;
-            enc_size = H5V_limit_enc_size(enc_value);
+            enc_size = H5VM_limit_enc_size(enc_value);
             HDassert(enc_size < 256);
             *(*pp)++ = (uint8_t)enc_size;
             UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -894,14 +894,14 @@ H5P__dcrt_ext_file_list_enc(const void *value, void **_pp, size_t *size)
 
             /* Encode offset */
             enc_value = (uint64_t)efl->slot[u].offset;
-            enc_size = H5V_limit_enc_size(enc_value);
+            enc_size = H5VM_limit_enc_size(enc_value);
             HDassert(enc_size < 256);
             *(*pp)++ = (uint8_t)enc_size;
             UINT64ENCODE_VAR(*pp, enc_value, enc_size);
 
             /* encode size */
             enc_value = (uint64_t)efl->slot[u].size;
-            enc_size = H5V_limit_enc_size(enc_value);
+            enc_size = H5VM_limit_enc_size(enc_value);
             HDassert(enc_size < 256);
             *(*pp)++ = (uint8_t)enc_size;
             UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -909,13 +909,13 @@ H5P__dcrt_ext_file_list_enc(const void *value, void **_pp, size_t *size)
     } /* end if */
 
     /* Calculate size needed for encoding */
-    *size += (1 + H5V_limit_enc_size((uint64_t)efl->nused));
+    *size += (1 + H5VM_limit_enc_size((uint64_t)efl->nused));
     for(u = 0; u < efl->nused; u++) {
         len = HDstrlen(efl->slot[u].name) + 1;
-        *size += (1 + H5V_limit_enc_size((uint64_t)len));
+        *size += (1 + H5VM_limit_enc_size((uint64_t)len));
         *size += len;
-        *size += (1 + H5V_limit_enc_size((uint64_t)efl->slot[u].offset));
-        *size += (1 + H5V_limit_enc_size((uint64_t)efl->slot[u].size));
+        *size += (1 + H5VM_limit_enc_size((uint64_t)efl->slot[u].offset));
+        *size += (1 + H5VM_limit_enc_size((uint64_t)efl->slot[u].size));
     } /* end for */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
diff --git a/src/H5Pdxpl.c b/src/H5Pdxpl.c
index 552ea63..b5d688b 100644
--- a/src/H5Pdxpl.c
+++ b/src/H5Pdxpl.c
@@ -681,7 +681,7 @@ H5P__dxfr_xform_enc(const void *value, void **_pp, size_t *size)
 
         /* encode the length of the prefix */
         enc_value = (uint64_t)len;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -698,7 +698,7 @@ H5P__dxfr_xform_enc(const void *value, void **_pp, size_t *size)
     } /* end if */
 
     /* Size of encoded data transform */
-    *size += (1 + H5V_limit_enc_size((uint64_t)len));
+    *size += (1 + H5VM_limit_enc_size((uint64_t)len));
     if(NULL != pexp)
         *size += len;
 
diff --git a/src/H5Pencdec.c b/src/H5Pencdec.c
index ff148b0..0c70c6c 100644
--- a/src/H5Pencdec.c
+++ b/src/H5Pencdec.c
@@ -118,7 +118,7 @@ H5P__encode_size_t(const void *value, void **_pp, size_t *size)
 {
     uint64_t enc_value = (uint64_t)*(const size_t *)value;    /* Property value to encode */
     uint8_t **pp = (uint8_t **)_pp;
-    unsigned enc_size = H5V_limit_enc_size(enc_value);  /* Size of encoded property */
+    unsigned enc_size = H5VM_limit_enc_size(enc_value);  /* Size of encoded property */
 
     FUNC_ENTER_PACKAGE_NOERR
 
@@ -159,7 +159,7 @@ herr_t
 H5P__encode_hsize_t(const void *value, void **_pp, size_t *size)
 {
     uint64_t enc_value = (uint64_t)*(const hsize_t *)value;    /* Property value to encode */
-    unsigned enc_size = H5V_limit_enc_size(enc_value);  /* Size of encoded property */
+    unsigned enc_size = H5VM_limit_enc_size(enc_value);  /* Size of encoded property */
     uint8_t **pp = (uint8_t **)_pp;
 
     FUNC_ENTER_PACKAGE_NOERR
diff --git a/src/H5Pfapl.c b/src/H5Pfapl.c
index 6955a60..a4c09e5 100644
--- a/src/H5Pfapl.c
+++ b/src/H5Pfapl.c
@@ -2606,7 +2606,7 @@ H5P__facc_cache_config_enc(const void *value, void **_pp, size_t *size)
         H5_ENCODE_UNSIGNED(*pp, config->set_initial_size);
 
         enc_value = (uint64_t)config->initial_size;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -2614,13 +2614,13 @@ H5P__facc_cache_config_enc(const void *value, void **_pp, size_t *size)
         H5_ENCODE_DOUBLE(*pp, config->min_clean_fraction);
 
         enc_value = (uint64_t)config->max_size;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
 
         enc_value = (uint64_t)config->min_size;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -2638,7 +2638,7 @@ H5P__facc_cache_config_enc(const void *value, void **_pp, size_t *size)
         H5_ENCODE_UNSIGNED(*pp, config->apply_max_increment);
 
         enc_value = (uint64_t)config->max_increment;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -2660,7 +2660,7 @@ H5P__facc_cache_config_enc(const void *value, void **_pp, size_t *size)
         H5_ENCODE_UNSIGNED(*pp, config->apply_max_decrement);
 
         enc_value = (uint64_t)config->max_decrement;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -2681,15 +2681,15 @@ H5P__facc_cache_config_enc(const void *value, void **_pp, size_t *size)
 
     /* Compute encoded size of variably-encoded values */
     enc_value = (uint64_t)config->initial_size;
-    *size += 1 + H5V_limit_enc_size(enc_value);
+    *size += 1 + H5VM_limit_enc_size(enc_value);
     enc_value = (uint64_t)config->max_size;
-    *size += 1 + H5V_limit_enc_size(enc_value);
+    *size += 1 + H5VM_limit_enc_size(enc_value);
     enc_value = (uint64_t)config->min_size;
-    *size += 1 + H5V_limit_enc_size(enc_value);
+    *size += 1 + H5VM_limit_enc_size(enc_value);
     enc_value = (uint64_t)config->max_increment;
-    *size += 1 + H5V_limit_enc_size(enc_value);
+    *size += 1 + H5VM_limit_enc_size(enc_value);
     enc_value = (uint64_t)config->max_decrement;
-    *size += 1 + H5V_limit_enc_size(enc_value);
+    *size += 1 + H5VM_limit_enc_size(enc_value);
 
     /* Compute encoded size of fixed-size values */
     *size += (5 + (sizeof(unsigned) * 8) + (sizeof(double) * 8) +
diff --git a/src/H5Plapl.c b/src/H5Plapl.c
index aa02546..676b574 100644
--- a/src/H5Plapl.c
+++ b/src/H5Plapl.c
@@ -514,7 +514,7 @@ H5P_lacc_elink_pref_enc(const void *value, void **_pp, size_t *size)
         len = HDstrlen(elink_pref);
 
     enc_value = (uint64_t)len;
-    enc_size = H5V_limit_enc_size(enc_value);
+    enc_size = H5VM_limit_enc_size(enc_value);
     HDassert(enc_size < 256);
 
     if(NULL != *pp) {
diff --git a/src/H5Pocpl.c b/src/H5Pocpl.c
index 32f6a1b..df4ebb6 100644
--- a/src/H5Pocpl.c
+++ b/src/H5Pocpl.c
@@ -1495,7 +1495,7 @@ H5P__ocrt_pipeline_enc(const void *value, void **_pp, size_t *size)
 
         /* encode nused value */
         enc_value = (uint64_t)pline->nused;
-        enc_size = H5V_limit_enc_size(enc_value);
+        enc_size = H5VM_limit_enc_size(enc_value);
         HDassert(enc_size < 256);
         *(*pp)++ = (uint8_t)enc_size;
         UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -1525,7 +1525,7 @@ H5P__ocrt_pipeline_enc(const void *value, void **_pp, size_t *size)
 
             /* encode cd_nelmts */
             enc_value = (uint64_t)pline->filter[u].cd_nelmts;
-            enc_size = H5V_limit_enc_size(enc_value);
+            enc_size = H5VM_limit_enc_size(enc_value);
             HDassert(enc_size < 256);
             *(*pp)++ = (uint8_t)enc_size;
             UINT64ENCODE_VAR(*pp, enc_value, enc_size);
@@ -1538,12 +1538,12 @@ H5P__ocrt_pipeline_enc(const void *value, void **_pp, size_t *size)
 
     /* calculate size required for encoding */
     *size += 1;
-    *size += (1 + H5V_limit_enc_size((uint64_t)pline->nused));
+    *size += (1 + H5VM_limit_enc_size((uint64_t)pline->nused));
     for(u = 0; u < pline->nused; u++) {
         *size += (sizeof(int32_t) + sizeof(unsigned) + 1);
         if(NULL != pline->filter[u].name)
             *size += H5Z_COMMON_NAME_LEN;
-        *size += (1 + H5V_limit_enc_size((uint64_t)pline->filter[u].cd_nelmts));
+        *size += (1 + H5VM_limit_enc_size((uint64_t)pline->filter[u].cd_nelmts));
         *size += pline->filter[u].cd_nelmts * sizeof(unsigned);
     } /* end for */
 
diff --git a/src/H5Sall.c b/src/H5Sall.c
index 19d1efc..24caad2 100644
--- a/src/H5Sall.c
+++ b/src/H5Sall.c
@@ -27,7 +27,7 @@
 #include "H5Eprivate.h"		/* Error handling		        */
 #include "H5Iprivate.h"		/* ID Functions		                */
 #include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5Vprivate.h"         /* Vector functions                     */
+#include "H5VMprivate.h"         /* Vector functions                     */
 
 /* Static function prototypes */
 
@@ -162,7 +162,7 @@ H5S_all_iter_coords (const H5S_sel_iter_t *iter, hsize_t *coords)
     HDassert (coords);
 
     /* Calculate the coordinates for the current iterator offset */
-    if(H5V_array_calc(iter->u.all.elmt_offset,iter->rank,iter->dims,coords)<0)
+    if(H5VM_array_calc(iter->u.all.elmt_offset,iter->rank,iter->dims,coords)<0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGET, FAIL, "can't retrieve coordinates");
 
 done:
diff --git a/src/H5Shyper.c b/src/H5Shyper.c
index f8d87e4..c97c9b6 100644
--- a/src/H5Shyper.c
+++ b/src/H5Shyper.c
@@ -28,7 +28,7 @@
 #include "H5FLprivate.h"	/* Free Lists				*/
 #include "H5Iprivate.h"		/* ID Functions				*/
 #include "H5Spkg.h"		/* Dataspace functions			*/
-#include "H5Vprivate.h"         /* Vector functions			*/
+#include "H5VMprivate.h"         /* Vector functions			*/
 
 /* Local datatypes */
 
@@ -464,7 +464,7 @@ H5S_hyper_iter_coords (const H5S_sel_iter_t *iter, hsize_t *coords)
                     HDassert(v >= 0);
 
                     /* Compute the coords for the flattened dimensions */
-                    H5V_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), &(coords[u]));
+                    H5VM_array_calc(iter->u.hyp.off[v], (unsigned)((begin - u) + 1), &(iter->dims[u]), &(coords[u]));
 
                     /* Continue to faster dimension in both indices */
                     u--;
@@ -4102,7 +4102,7 @@ H5S_hyper_project_scalar(const H5S_t *space, hsize_t *offset)
     } /* end else */
 
     /* Calculate offset of selection in projected buffer */
-    *offset = H5V_array_offset(space->extent.rank, space->extent.size, block); 
+    *offset = H5VM_array_offset(space->extent.rank, space->extent.size, block); 
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -4294,7 +4294,7 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             HDmemset(block, 0, sizeof(block));
             for(u = 0; u < (base_space->extent.rank - new_space->extent.rank); u++)
                 block[u] = opt_diminfo[u].start;
-            *offset = H5V_array_offset(base_space->extent.rank, base_space->extent.size, block); 
+            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
             /* Set the correct dimensions for the base & new spaces */
             base_space_dim = base_space->extent.rank - new_space->extent.rank;
@@ -4377,7 +4377,7 @@ H5S_hyper_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
             } /* end while */
 
             /* Compute the offset for the down-projection */
-            *offset = H5V_array_offset(base_space->extent.rank, base_space->extent.size, block); 
+            *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
             /* Project the base space's selection down in less dimensions */
             if(H5S_hyper_project_simple_lower(base_space, new_space) < 0)
diff --git a/src/H5Smpio.c b/src/H5Smpio.c
index 868a00f..77e902f 100644
--- a/src/H5Smpio.c
+++ b/src/H5Smpio.c
@@ -35,7 +35,7 @@
 #include "H5Oprivate.h"		/* Object headers		  	*/
 #include "H5Pprivate.h"         /* Property lists                       */
 #include "H5Spkg.h"		/* Dataspaces 				*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 
 #ifdef H5_HAVE_PARALLEL
 
@@ -453,7 +453,7 @@ H5S_mpio_span_hyper_type(const H5S_t *space, size_t elmt_size,
     elmt_type_is_derived = TRUE;
 
     /* Compute 'down' sizes for each dimension */
-    if(H5V_array_down(space->extent.rank, space->extent.size, down) < 0)
+    if(H5VM_array_down(space->extent.rank, space->extent.size, down) < 0)
         HGOTO_ERROR(H5E_DATASPACE, H5E_CANTGETSIZE, FAIL, "couldn't compute 'down' dimension sizes")
 
     /* Obtain derived data type */
diff --git a/src/H5Snone.c b/src/H5Snone.c
index 021dd61..3c5eccc 100644
--- a/src/H5Snone.c
+++ b/src/H5Snone.c
@@ -27,7 +27,7 @@
 #include "H5Eprivate.h"
 #include "H5Iprivate.h"
 #include "H5Spkg.h"
-#include "H5Vprivate.h"
+#include "H5VMprivate.h"
 #include "H5Dprivate.h"
 
 /* Static function prototypes */
diff --git a/src/H5Spoint.c b/src/H5Spoint.c
index b758a92..70842df 100644
--- a/src/H5Spoint.c
+++ b/src/H5Spoint.c
@@ -29,7 +29,7 @@
 #include "H5Iprivate.h"		/* ID Functions		  */
 #include "H5MMprivate.h"	/* Memory Management functions		  */
 #include "H5Spkg.h"		/* Dataspace functions			  */
-#include "H5Vprivate.h"         /* Vector functions */
+#include "H5VMprivate.h"         /* Vector functions */
 
 /* Static function prototypes */
 
@@ -1383,7 +1383,7 @@ H5S_point_project_scalar(const H5S_t *space, hsize_t *offset)
         HGOTO_ERROR(H5E_DATASPACE, H5E_BADRANGE, FAIL, "point selection of one element has more than one node!")
 
     /* Calculate offset of selection in projected buffer */
-    *offset = H5V_array_offset(space->extent.rank, space->extent.size, node->pnt); 
+    *offset = H5VM_array_offset(space->extent.rank, space->extent.size, node->pnt); 
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1437,7 +1437,7 @@ H5S_point_project_simple(const H5S_t *base_space, H5S_t *new_space, hsize_t *off
         /* Calculate offset of selection in projected buffer */
         HDmemset(block, 0, sizeof(block));
         HDmemcpy(block, base_space->select.sel_info.pnt_lst->head->pnt, sizeof(hsize_t) * rank_diff);
-        *offset = H5V_array_offset(base_space->extent.rank, base_space->extent.size, block); 
+        *offset = H5VM_array_offset(base_space->extent.rank, base_space->extent.size, block); 
 
         /* Iterate through base space's point nodes, copying the point information */
         base_node = base_space->select.sel_info.pnt_lst->head;
diff --git a/src/H5Sselect.c b/src/H5Sselect.c
index 1eb0cbc..44688b6 100644
--- a/src/H5Sselect.c
+++ b/src/H5Sselect.c
@@ -29,7 +29,7 @@
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"        /* Memory management                    */
 #include "H5Spkg.h"		/* Dataspaces 				*/
-#include "H5Vprivate.h"		/* Vector and array functions		*/
+#include "H5VMprivate.h"		/* Vector and array functions		*/
 #include "H5WBprivate.h"        /* Wrapped Buffers                      */
 
 /* Local functions */
@@ -1872,8 +1872,8 @@ H5S_select_construct_projection(const H5S_t *base_space, H5S_t **new_space_ptr,
              * and set the remaining dimensions to 1
              */
             rank_diff = new_space_rank - base_space_rank;
-            H5V_array_fill(new_space_dims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
-            H5V_array_fill(new_space_maxdims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
+            H5VM_array_fill(new_space_dims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
+            H5VM_array_fill(new_space_maxdims, &tmp_dim_size, sizeof(tmp_dim_size), rank_diff);
             HDmemcpy(&new_space_dims[rank_diff], base_space_dims, sizeof(new_space_dims[0]) * base_space_rank);
             HDmemcpy(&new_space_maxdims[rank_diff], base_space_maxdims, sizeof(new_space_maxdims[0]) * base_space_rank);
         } /* end if */
@@ -2038,7 +2038,7 @@ H5S_select_fill(const void *fill, size_t fill_size, const H5S_t *space, void *_b
 
             /* Fill each sequence in memory with fill value */
             HDassert((len[curr_seq] % fill_size) == 0);
-            H5V_array_fill(buf, fill, fill_size, (len[curr_seq] / fill_size));
+            H5VM_array_fill(buf, fill, fill_size, (len[curr_seq] / fill_size));
         } /* end for */
 
         /* Decrement number of elements left to process */
diff --git a/src/H5V.c b/src/H5VM.c
index 3277b90..6f72c57 100644
--- a/src/H5V.c
+++ b/src/H5VM.c
@@ -22,34 +22,34 @@
 #include "H5private.h"
 #include "H5Eprivate.h"
 #include "H5Oprivate.h"
-#include "H5Vprivate.h"
+#include "H5VMprivate.h"
 
 /* Local typedefs */
-typedef struct H5V_memcpy_ud_t {
+typedef struct H5VM_memcpy_ud_t {
     unsigned char *dst;         /* Pointer to destination buffer */
     const unsigned char *src;   /* Pointer to source buffer */
-} H5V_memcpy_ud_t;
+} H5VM_memcpy_ud_t;
 
 /* Local macros */
-#define H5V_HYPER_NDIMS H5O_LAYOUT_NDIMS
+#define H5VM_HYPER_NDIMS H5O_LAYOUT_NDIMS
 
 /* Local prototypes */
 static void
-H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1);
 static void
-H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1, hsize_t *stride2);
 #ifdef LATER
 static void
-H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
+H5VM_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
      unsigned dst_n, const hsize_t *dst_size, const ssize_t *dst_stride, void *_dst,
      unsigned src_n, const hsize_t *src_size, const ssize_t *src_stride, const void *_src);
 #endif /* LATER */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_optimize1
+ * Function:	H5VM_stride_optimize1
  *
  * Purpose:	Given a stride vector which references elements of the
  *		specified size, optimize the dimensionality, the stride
@@ -69,7 +69,7 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
  *-------------------------------------------------------------------------
  */
 static void
-H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -78,7 +78,7 @@ H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
      * This has to be true because if we optimize the dimensionality down to
      * zero we still must make one reference.
      */
-    HDassert(1 == H5V_vector_reduce_product(0, NULL));
+    HDassert(1 == H5VM_vector_reduce_product(0, NULL));
 
     /*
      * Combine adjacent memory accesses
@@ -95,7 +95,7 @@ H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_optimize2
+ * Function:	H5VM_stride_optimize2
  *
  * Purpose:	Given two stride vectors which reference elements of the
  *		specified size, optimize the dimensionality, the stride
@@ -118,7 +118,7 @@ H5V_stride_optimize1(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
  *-------------------------------------------------------------------------
  */
 static void
-H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
+H5VM_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 		     const hsize_t *size, hsize_t *stride1, hsize_t *stride2)
 {
     FUNC_ENTER_NOAPI_NOINIT_NOERR
@@ -127,7 +127,7 @@ H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
      * This has to be true because if we optimize the dimensionality down to
      * zero we still must make one reference.
      */
-    HDassert(1 == H5V_vector_reduce_product(0, NULL));
+    HDassert(1 == H5VM_vector_reduce_product(0, NULL));
     HDassert(*elmt_size>0);
 
     /*
@@ -224,7 +224,7 @@ H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_stride
+ * Function:	H5VM_hyper_stride
  *
  * Purpose:	Given a description of a hyperslab, this function returns
  *		(through STRIDE[]) the byte strides appropriate for accessing
@@ -256,7 +256,7 @@ H5V_stride_optimize2(unsigned *np/*in,out*/, hsize_t *elmt_size/*in,out*/,
  *-------------------------------------------------------------------------
  */
 hsize_t
-H5V_hyper_stride(unsigned n, const hsize_t *size,
+H5VM_hyper_stride(unsigned n, const hsize_t *size,
 		 const hsize_t *total_size, const hsize_t *offset,
 		 hsize_t *stride/*out*/)
 {
@@ -267,7 +267,7 @@ H5V_hyper_stride(unsigned n, const hsize_t *size,
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(size);
     HDassert(total_size);
     HDassert(stride);
@@ -333,7 +333,7 @@ H5V_hyper_stride(unsigned n, const hsize_t *size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_eq
+ * Function:	H5VM_hyper_eq
  *
  * Purpose:	Determines whether two hyperslabs are equal.  This function
  *		assumes that both hyperslabs are relative to the same array,
@@ -356,7 +356,7 @@ H5V_hyper_stride(unsigned n, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 htri_t
-H5V_hyper_eq(unsigned n,
+H5VM_hyper_eq(unsigned n,
 	     const hsize_t *offset1, const hsize_t *size1,
 	     const hsize_t *offset2, const hsize_t *size2)
 {
@@ -386,7 +386,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_disjointp
+ * Function:	H5VM_hyper_disjointp
  *
  * Purpose:	Determines if two hyperslabs are disjoint.
  *
@@ -404,7 +404,7 @@ done:
  *-------------------------------------------------------------------------
  */
 htri_t
-H5V_hyper_disjointp(unsigned n,
+H5VM_hyper_disjointp(unsigned n,
     const hsize_t *offset1, const uint32_t *size1,
     const hsize_t *offset2, const uint32_t *size2)
 {
@@ -432,11 +432,11 @@ H5V_hyper_disjointp(unsigned n,
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_hyper_disjointp() */
+} /* end H5VM_hyper_disjointp() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_fill
+ * Function:	H5VM_hyper_fill
  *
  * Purpose:	Similar to memset() except it operates on hyperslabs...
  *
@@ -457,13 +457,13 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_hyper_fill(unsigned n, const hsize_t *_size,
+H5VM_hyper_fill(unsigned n, const hsize_t *_size,
 	       const hsize_t *total_size, const hsize_t *offset, void *_dst,
 	       unsigned fill_value)
 {
     uint8_t	*dst = (uint8_t*)_dst;	/*cast for ptr arithmetic	*/
-    hsize_t	size[H5V_HYPER_NDIMS];	/*a modifiable copy of _size	*/
-    hsize_t	dst_stride[H5V_HYPER_NDIMS]; /*destination stride info  */
+    hsize_t	size[H5VM_HYPER_NDIMS];	/*a modifiable copy of _size	*/
+    hsize_t	dst_stride[H5VM_HYPER_NDIMS]; /*destination stride info  */
     hsize_t	dst_start;		/*byte offset to start of stride*/
     hsize_t	elmt_size = 1;		/*bytes per element		*/
     herr_t	ret_value;		/*function return status	*/
@@ -474,7 +474,7 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* check args */
-    HDassert(n > 0 && n <= H5V_HYPER_NDIMS);
+    HDassert(n > 0 && n <= H5VM_HYPER_NDIMS);
     HDassert(_size);
     HDassert(total_size);
     HDassert(dst);
@@ -486,14 +486,14 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
 #endif
 
     /* Copy the size vector so we can modify it */
-    H5V_vector_cpy(n, size, _size);
+    H5VM_vector_cpy(n, size, _size);
 
     /* Compute an optimal destination stride vector */
-    dst_start = H5V_hyper_stride(n, size, total_size, offset, dst_stride);
-    H5V_stride_optimize1(&n, &elmt_size, size, dst_stride);
+    dst_start = H5VM_hyper_stride(n, size, total_size, offset, dst_stride);
+    H5VM_stride_optimize1(&n, &elmt_size, size, dst_stride);
 
     /* Copy */
-    ret_value = H5V_stride_fill(n, elmt_size, size, dst_stride, dst+dst_start,
+    ret_value = H5VM_stride_fill(n, elmt_size, size, dst_stride, dst+dst_start,
 			     fill_value);
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -501,7 +501,7 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_hyper_copy
+ * Function:	H5VM_hyper_copy
  *
  * Purpose:	Copies a hyperslab from the source to the destination.
  *
@@ -535,7 +535,7 @@ H5V_hyper_fill(unsigned n, const hsize_t *_size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_hyper_copy(unsigned n, const hsize_t *_size,
+H5VM_hyper_copy(unsigned n, const hsize_t *_size,
 
 	       /*destination*/
 	       const hsize_t *dst_size, const hsize_t *dst_offset,
@@ -547,9 +547,9 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 {
     const uint8_t *src = (const uint8_t*)_src;	/*cast for ptr arithmtc */
     uint8_t	*dst = (uint8_t*) _dst;		/*cast for ptr arithmtc */
-    hsize_t	size[H5V_HYPER_NDIMS];		/*a modifiable _size	*/
-    hsize_t	src_stride[H5V_HYPER_NDIMS];	/*source stride info	*/
-    hsize_t	dst_stride[H5V_HYPER_NDIMS];	/*dest stride info	*/
+    hsize_t	size[H5VM_HYPER_NDIMS];		/*a modifiable _size	*/
+    hsize_t	src_stride[H5VM_HYPER_NDIMS];	/*source stride info	*/
+    hsize_t	dst_stride[H5VM_HYPER_NDIMS];	/*dest stride info	*/
     hsize_t	dst_start, src_start;		/*offset to start at	*/
     hsize_t	elmt_size = 1;			/*element size in bytes */
     herr_t	ret_value;			/*return status		*/
@@ -560,7 +560,7 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* check args */
-    HDassert(n > 0 && n <= H5V_HYPER_NDIMS);
+    HDassert(n > 0 && n <= H5VM_HYPER_NDIMS);
     HDassert(_size);
     HDassert(dst_size);
     HDassert(src_size);
@@ -575,14 +575,14 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 #endif
 
     /* Copy the size vector so we can modify it */
-    H5V_vector_cpy(n, size, _size);
+    H5VM_vector_cpy(n, size, _size);
 
     /* Compute stride vectors for source and destination */
 #ifdef NO_INLINED_CODE
-    dst_start = H5V_hyper_stride(n, size, dst_size, dst_offset, dst_stride);
-    src_start = H5V_hyper_stride(n, size, src_size, src_offset, src_stride);
+    dst_start = H5VM_hyper_stride(n, size, dst_size, dst_offset, dst_stride);
+    src_start = H5VM_hyper_stride(n, size, src_size, src_offset, src_stride);
 #else /* NO_INLINED_CODE */
-    /* in-line version of two calls to H5V_hyper_stride() */
+    /* in-line version of two calls to H5VM_hyper_stride() */
     {
         hsize_t	    dst_acc;	/*accumulator				*/
         hsize_t	    src_acc;	/*accumulator				*/
@@ -675,10 +675,10 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 #endif /* NO_INLINED_CODE */
 
     /* Optimize the strides as a pair */
-    H5V_stride_optimize2(&n, &elmt_size, size, dst_stride, src_stride);
+    H5VM_stride_optimize2(&n, &elmt_size, size, dst_stride, src_stride);
 
     /* Perform the copy in terms of stride */
-    ret_value = H5V_stride_copy(n, elmt_size, size,
+    ret_value = H5VM_stride_copy(n, elmt_size, size,
              dst_stride, dst+dst_start, src_stride, src+src_start);
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -686,7 +686,7 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_fill
+ * Function:	H5VM_stride_fill
  *
  * Purpose:	Fills all bytes of a hyperslab with the same value using
  *		memset().
@@ -701,11 +701,11 @@ H5V_hyper_copy(unsigned n, const hsize_t *_size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5VM_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 		const hsize_t *stride, void *_dst, unsigned fill_value)
 {
     uint8_t	*dst = (uint8_t*)_dst; 	/*cast for ptr arithmetic	*/
-    hsize_t	idx[H5V_HYPER_NDIMS]; 	/*1-origin indices		*/
+    hsize_t	idx[H5VM_HYPER_NDIMS]; 	/*1-origin indices		*/
     hsize_t	nelmts;			/*number of elements to fill	*/
     hsize_t	i;			/*counter			*/
     int	j;			/*counter			*/
@@ -715,8 +715,8 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 
     HDassert(elmt_size < SIZET_MAX);
 
-    H5V_vector_cpy(n, idx, size);
-    nelmts = H5V_vector_reduce_product(n, size);
+    H5VM_vector_cpy(n, idx, size);
+    nelmts = H5VM_vector_reduce_product(n, size);
     for (i=0; i<nelmts; i++) {
         /* Copy an element */
         H5_CHECK_OVERFLOW(elmt_size,hsize_t,size_t);
@@ -740,7 +740,7 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_copy
+ * Function:	H5VM_stride_copy
  *
  * Purpose:	Uses DST_STRIDE and SRC_STRIDE to advance through the arrays
  *		DST and SRC while copying bytes from SRC to DST.  This
@@ -749,7 +749,7 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *		outside the hyperslab defined by the strides.
  *
  * Note:	If the src_stride is all zero and elmt_size is one, then it's
- *		probably more efficient to use H5V_stride_fill() instead.
+ *		probably more efficient to use H5VM_stride_fill() instead.
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -761,13 +761,13 @@ H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5VM_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
 		const hsize_t *dst_stride, void *_dst,
 		const hsize_t *src_stride, const void *_src)
 {
     uint8_t	*dst = (uint8_t*)_dst;		/*cast for ptr arithmetic*/
     const uint8_t *src = (const uint8_t*) _src;	/*cast for ptr arithmetic*/
-    hsize_t	idx[H5V_HYPER_NDIMS];		/*1-origin indices	*/
+    hsize_t	idx[H5VM_HYPER_NDIMS];		/*1-origin indices	*/
     hsize_t	nelmts;				/*num elements to copy	*/
     hsize_t	i;				/*counter		*/
     int	j;				/*counters		*/
@@ -778,8 +778,8 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
     HDassert(elmt_size<SIZET_MAX);
 
     if (n) {
-        H5V_vector_cpy(n, idx, size);
-        nelmts = H5V_vector_reduce_product(n, size);
+        H5VM_vector_cpy(n, idx, size);
+        nelmts = H5VM_vector_reduce_product(n, size);
         for (i=0; i<nelmts; i++) {
 
             /* Copy an element */
@@ -809,7 +809,7 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_copy_s
+ * Function:	H5VM_stride_copy_s
  *
  * Purpose:	Uses DST_STRIDE and SRC_STRIDE to advance through the arrays
  *		DST and SRC while copying bytes from SRC to DST.  This
@@ -818,7 +818,7 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *		outside the hyperslab defined by the strides.
  *
  * Note:	If the src_stride is all zero and elmt_size is one, then it's
- *		probably more efficient to use H5V_stride_fill() instead.
+ *		probably more efficient to use H5VM_stride_fill() instead.
  *
  * Return:	Non-negative on success/Negative on failure
  *
@@ -830,13 +830,13 @@ H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5VM_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
 		const hssize_t *dst_stride, void *_dst,
 		const hssize_t *src_stride, const void *_src)
 {
     uint8_t	*dst = (uint8_t*)_dst;		/*cast for ptr arithmetic*/
     const uint8_t *src = (const uint8_t*) _src;	/*cast for ptr arithmetic*/
-    hsize_t	idx[H5V_HYPER_NDIMS];		/*1-origin indices	*/
+    hsize_t	idx[H5VM_HYPER_NDIMS];		/*1-origin indices	*/
     hsize_t	nelmts;				/*num elements to copy	*/
     hsize_t	i;				/*counter		*/
     int	j;				/*counters		*/
@@ -847,8 +847,8 @@ H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
     HDassert(elmt_size<SIZET_MAX);
 
     if (n) {
-        H5V_vector_cpy(n, idx, size);
-        nelmts = H5V_vector_reduce_product(n, size);
+        H5VM_vector_cpy(n, idx, size);
+        nelmts = H5VM_vector_reduce_product(n, size);
         for (i=0; i<nelmts; i++) {
 
             /* Copy an element */
@@ -879,9 +879,9 @@ H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
 #ifdef LATER
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_stride_copy2
+ * Function:	H5VM_stride_copy2
  *
- * Purpose:	Similar to H5V_stride_copy() except the source and
+ * Purpose:	Similar to H5VM_stride_copy() except the source and
  *		destination each have their own dimensionality and size and
  *		we copy exactly NELMTS elements each of size ELMT_SIZE.	 The
  *		size counters wrap if NELMTS is more than a size counter.
@@ -896,7 +896,7 @@ H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *size,
  *-------------------------------------------------------------------------
  */
 static void
-H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
+H5VM_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
 
 		 /* destination */
 		 unsigned dst_n, const hsize_t *dst_size,
@@ -910,8 +910,8 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
 {
     uint8_t	*dst = (uint8_t *) _dst;
     const uint8_t *src = (const uint8_t *) _src;
-    hsize_t	dst_idx[H5V_HYPER_NDIMS];
-    hsize_t	src_idx[H5V_HYPER_NDIMS];
+    hsize_t	dst_idx[H5VM_HYPER_NDIMS];
+    hsize_t	src_idx[H5VM_HYPER_NDIMS];
     hsize_t	i;              /* Local index variable */
     int		j;              /* Local index variable */
     hbool_t	carry;
@@ -922,8 +922,8 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
     HDassert(dst_n>0);
     HDassert(src_n>0);
 
-    H5V_vector_cpy(dst_n, dst_idx, dst_size);
-    H5V_vector_cpy(src_n, src_idx, src_size);
+    H5VM_vector_cpy(dst_n, dst_idx, dst_size);
+    H5VM_vector_cpy(src_n, src_idx, src_size);
 
     for (i=0; i<nelmts; i++) {
 
@@ -958,7 +958,7 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_fill
+ * Function:	H5VM_array_fill
  *
  * Purpose:	Fills all bytes of an array with the same value using
  *		memset(). Increases amount copied by power of two until the
@@ -974,7 +974,7 @@ H5V_stride_copy2(hsize_t nelmts, hsize_t elmt_size,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_array_fill(void *_dst, const void *src, size_t size, size_t count)
+H5VM_array_fill(void *_dst, const void *src, size_t size, size_t count)
 {
     size_t      copy_size;          /* size of the buffer to copy	*/
     size_t      copy_items;         /* number of items currently copying*/
@@ -1010,11 +1010,11 @@ H5V_array_fill(void *_dst, const void *src, size_t size, size_t count)
         HDmemcpy(dst, _dst, items_left * size);
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-}   /* H5V_array_fill() */
+}   /* H5VM_array_fill() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_down
+ * Function:	H5VM_array_down
  *
  * Purpose:	Given a set of dimension sizes, calculate the size of each
  *              "down" slice.  This is the size of the dimensions for all the
@@ -1031,14 +1031,14 @@ H5V_array_fill(void *_dst, const void *src, size_t size, size_t count)
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
+H5VM_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
 {
     hsize_t	acc;	                /*accumulator			*/
     int	        i;		        /*counter			*/
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(total_size);
     HDassert(down);
 
@@ -1050,11 +1050,11 @@ H5V_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
     } /* end for */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5V_array_down() */
+} /* end H5VM_array_down() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_offset_pre
+ * Function:	H5VM_array_offset_pre
  *
  * Purpose:	Given a coordinate description of a location in an array, this
  *      function returns the byte offset of the coordinate.
@@ -1077,14 +1077,14 @@ H5V_array_down(unsigned n, const hsize_t *total_size, hsize_t *down)
  *-------------------------------------------------------------------------
  */
 hsize_t
-H5V_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
+H5VM_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
 {
     int             i;		/*counter				*/
     hsize_t	    ret_value;  /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(acc);
     HDassert(offset);
 
@@ -1093,11 +1093,11 @@ H5V_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
         ret_value += acc[i] * offset[i];
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_array_offset_pre() */
+} /* end H5VM_array_offset_pre() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_offset
+ * Function:	H5VM_array_offset
  *
  * Purpose:	Given a coordinate description of a location in an array, this
  *      function returns the byte offset of the coordinate.
@@ -1117,31 +1117,31 @@ H5V_array_offset_pre(unsigned n, const hsize_t *acc, const hsize_t *offset)
  *-------------------------------------------------------------------------
  */
 hsize_t
-H5V_array_offset(unsigned n, const hsize_t *total_size, const hsize_t *offset)
+H5VM_array_offset(unsigned n, const hsize_t *total_size, const hsize_t *offset)
 {
-    hsize_t	acc_arr[H5V_HYPER_NDIMS];	/* Accumulated size of down dimensions */
+    hsize_t	acc_arr[H5VM_HYPER_NDIMS];	/* Accumulated size of down dimensions */
     hsize_t	ret_value;  /* Return value */
 
     FUNC_ENTER_NOAPI((HDabort(), 0)) /*lint !e527 Don't worry about unreachable statement */
 
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(total_size);
     HDassert(offset);
 
     /* Build the sizes of each dimension in the array */
-    if(H5V_array_down(n,total_size,acc_arr)<0)
+    if(H5VM_array_down(n,total_size,acc_arr)<0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, UFAIL, "can't compute down sizes")
 
     /* Set return value */
-    ret_value=H5V_array_offset_pre(n,acc_arr,offset);
+    ret_value=H5VM_array_offset_pre(n,acc_arr,offset);
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_array_offset() */
+} /* end H5VM_array_offset() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_calc_pre
+ * Function:	H5VM_array_calc_pre
  *
  * Purpose:	Given a linear offset in an array, the dimensions of that
  *              array and the pre-computed 'down' (accumulator) sizes, this
@@ -1159,7 +1159,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
+H5VM_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
     hsize_t *coords)
 {
     unsigned    u;                      /* Local index variable */
@@ -1167,7 +1167,7 @@ H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Sanity check */
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(coords);
 
     /* Compute the coordinates from the offset */
@@ -1177,11 +1177,11 @@ H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
     } /* end for */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5V_array_calc_pre() */
+} /* end H5VM_array_calc_pre() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_array_calc
+ * Function:	H5VM_array_calc
  *
  * Purpose:	Given a linear offset in an array and the dimensions of that
  *              array, this function computes the coordinates of that offset
@@ -1201,33 +1201,33 @@ H5V_array_calc_pre(hsize_t offset, unsigned n, const hsize_t *down,
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_array_calc(hsize_t offset, unsigned n, const hsize_t *total_size, hsize_t *coords)
+H5VM_array_calc(hsize_t offset, unsigned n, const hsize_t *total_size, hsize_t *coords)
 {
-    hsize_t	idx[H5V_HYPER_NDIMS];	/* Size of each dimension in bytes */
+    hsize_t	idx[H5VM_HYPER_NDIMS];	/* Size of each dimension in bytes */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
     FUNC_ENTER_NOAPI(FAIL)
 
     /* Sanity check */
-    HDassert(n <= H5V_HYPER_NDIMS);
+    HDassert(n <= H5VM_HYPER_NDIMS);
     HDassert(total_size);
     HDassert(coords);
 
     /* Build the sizes of each dimension in the array */
-    if(H5V_array_down(n, total_size, idx) < 0)
+    if(H5VM_array_down(n, total_size, idx) < 0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "can't compute down sizes")
 
     /* Compute the coordinates from the offset */
-    if(H5V_array_calc_pre(offset, n, idx, coords) < 0)
+    if(H5VM_array_calc_pre(offset, n, idx, coords) < 0)
         HGOTO_ERROR(H5E_INTERNAL, H5E_BADVALUE, FAIL, "can't compute coordinates")
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_array_calc() */
+} /* end H5VM_array_calc() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_chunk_index
+ * Function:	H5VM_chunk_index
  *
  * Purpose:	Given a coordinate offset (COORD), the size of each chunk
  *              (CHUNK), the number of chunks in each dimension (NCHUNKS)
@@ -1269,16 +1269,16 @@ done:
  *-------------------------------------------------------------------------
  */
 herr_t
-H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
+H5VM_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
     const hsize_t *down_nchunks, hsize_t *chunk_idx)
 {
-    hsize_t	scaled_coord[H5V_HYPER_NDIMS];	/* Scaled, coordinates, in terms of chunks */
+    hsize_t	scaled_coord[H5VM_HYPER_NDIMS];	/* Scaled, coordinates, in terms of chunks */
     unsigned    u;                      /* Local index variable */
 
     FUNC_ENTER_NOAPI_NOINIT_NOERR
 
     /* Sanity check */
-    HDassert(ndims <= H5V_HYPER_NDIMS);
+    HDassert(ndims <= H5VM_HYPER_NDIMS);
     HDassert(coord);
     HDassert(chunk);
     HDassert(chunk_idx);
@@ -1288,14 +1288,14 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
         scaled_coord[u]=coord[u]/chunk[u];
 
     /* Compute the chunk index */
-    *chunk_idx=H5V_array_offset_pre(ndims,down_nchunks,scaled_coord); /*lint !e772 scaled_coord will always be initialized */
+    *chunk_idx=H5VM_array_offset_pre(ndims,down_nchunks,scaled_coord); /*lint !e772 scaled_coord will always be initialized */
 
     FUNC_LEAVE_NOAPI(SUCCEED)
-} /* end H5V_chunk_index() */
+} /* end H5VM_chunk_index() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_opvv
+ * Function:	H5VM_opvv
  *
  * Purpose:	Perform an operation on a source & destination sequences
  *		of offset/length pairs.  Each set of sequnces has an array
@@ -1307,7 +1307,7 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
  *              source or destination sequence runs out of information.
  *
  * Note:	The algorithm in this routine is [basically] the same as for
- *		H5V_memcpyvv().  Changes should be made to both!
+ *		H5VM_memcpyvv().  Changes should be made to both!
  *
  * Return:	Non-negative # of bytes operated on, on success/Negative on failure
  *
@@ -1317,11 +1317,11 @@ H5V_chunk_index(unsigned ndims, const hsize_t *coord, const uint32_t *chunk,
  *-------------------------------------------------------------------------
  */
 ssize_t
-H5V_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
+H5VM_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
     hsize_t dst_off_arr[],
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[],
     hsize_t src_off_arr[],
-    H5V_opvv_func_t op, void *op_data)
+    H5VM_opvv_func_t op, void *op_data)
 {
     hsize_t *max_dst_off_ptr, *max_src_off_ptr;  /* Pointers to max. source and destination offset locations */
     hsize_t *dst_off_ptr, *src_off_ptr; /* Pointers to source and destination offset arrays */
@@ -1497,11 +1497,11 @@ finished:
 
 done:
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_opvv() */
+} /* end H5VM_opvv() */
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_memcpyvv
+ * Function:	H5VM_memcpyvv
  *
  * Purpose:	Given source and destination buffers in memory (SRC & DST)
  *              copy sequences of from the source buffer into the destination
@@ -1514,7 +1514,7 @@ done:
  *              source or destination buffer runs out of sequence information.
  *
  * Note:	The algorithm in this routine is [basically] the same as for
- *		H5V_opvv().  Changes should be made to both!
+ *		H5VM_opvv().  Changes should be made to both!
  *
  * Return:	Non-negative # of bytes copied on success/Negative on failure
  *
@@ -1524,7 +1524,7 @@ done:
  *-------------------------------------------------------------------------
  */
 ssize_t
-H5V_memcpyvv(void *_dst,
+H5VM_memcpyvv(void *_dst,
     size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[], hsize_t dst_off_arr[],
     const void *_src,
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[], hsize_t src_off_arr[])
@@ -1708,5 +1708,5 @@ finished:
     *src_curr_seq = (size_t)(src_off_ptr - src_off_arr);
 
     FUNC_LEAVE_NOAPI(ret_value)
-} /* end H5V_memcpyvv() */
+} /* end H5VM_memcpyvv() */
 
diff --git a/src/H5Vprivate.h b/src/H5VMprivate.h
index 5ce26a0..4706b5f 100644
--- a/src/H5Vprivate.h
+++ b/src/H5VMprivate.h
@@ -17,93 +17,93 @@
  * Programmer: Robb Matzke <matzke@llnl.gov>
  *             Friday, October 10, 1997
  */
-#ifndef H5Vprivate_H
-#define H5Vprivate_H
+#ifndef H5VMprivate_H
+#define H5VMprivate_H
 
 /* Private headers needed by this file */
 #include "H5private.h"		/* Generic Functions			*/
 #include "H5Eprivate.h"		/* Error handling		  	*/
 
 /* Vector-Vector sequence operation callback */
-typedef herr_t (*H5V_opvv_func_t)(hsize_t dst_off, hsize_t src_off,
+typedef herr_t (*H5VM_opvv_func_t)(hsize_t dst_off, hsize_t src_off,
     size_t len, void *udata);
 
 /* Vector comparison functions like Fortran66 comparison operators */
-#define H5V_vector_eq_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)==0)
-#define H5V_vector_lt_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)<0)
-#define H5V_vector_gt_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)>0)
-#define H5V_vector_le_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)<=0)
-#define H5V_vector_ge_s(N,V1,V2) (H5V_vector_cmp_s (N, V1, V2)>=0)
-#define H5V_vector_eq_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)==0)
-#define H5V_vector_lt_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)<0)
-#define H5V_vector_gt_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)>0)
-#define H5V_vector_le_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)<=0)
-#define H5V_vector_ge_u(N,V1,V2) (H5V_vector_cmp_u (N, V1, V2)>=0)
+#define H5VM_vector_eq_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)==0)
+#define H5VM_vector_lt_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)<0)
+#define H5VM_vector_gt_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)>0)
+#define H5VM_vector_le_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)<=0)
+#define H5VM_vector_ge_s(N,V1,V2) (H5VM_vector_cmp_s (N, V1, V2)>=0)
+#define H5VM_vector_eq_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)==0)
+#define H5VM_vector_lt_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)<0)
+#define H5VM_vector_gt_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)>0)
+#define H5VM_vector_le_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)<=0)
+#define H5VM_vector_ge_u(N,V1,V2) (H5VM_vector_cmp_u (N, V1, V2)>=0)
 
 /* Other functions */
-#define H5V_vector_cpy(N,DST,SRC) {                                           \
+#define H5VM_vector_cpy(N,DST,SRC) {                                           \
     HDassert(sizeof(*(DST))==sizeof(*(SRC)));				                  \
     if (SRC) HDmemcpy (DST, SRC, (N)*sizeof(*(DST)));                         \
     else HDmemset (DST, 0, (N)*sizeof(*(DST)));                               \
 }
 
-#define H5V_vector_zero(N,DST) HDmemset(DST,0,(N)*sizeof(*(DST)))
+#define H5VM_vector_zero(N,DST) HDmemset(DST,0,(N)*sizeof(*(DST)))
 
 /* A null pointer is equivalent to a zero vector */
-#define H5V_ZERO        NULL
+#define H5VM_ZERO        NULL
 
-H5_DLL hsize_t H5V_hyper_stride(unsigned n, const hsize_t *size,
+H5_DLL hsize_t H5VM_hyper_stride(unsigned n, const hsize_t *size,
 				 const hsize_t *total_size,
 				 const hsize_t *offset,
 				 hsize_t *stride);
-H5_DLL htri_t H5V_hyper_disjointp(unsigned n, const hsize_t *offset1,
+H5_DLL htri_t H5VM_hyper_disjointp(unsigned n, const hsize_t *offset1,
     const uint32_t *size1, const hsize_t *offset2, const uint32_t *size2);
-H5_DLL htri_t H5V_hyper_eq(unsigned n, const hsize_t *offset1,
+H5_DLL htri_t H5VM_hyper_eq(unsigned n, const hsize_t *offset1,
 			    const hsize_t *size1, const hsize_t *offset2,
 			    const hsize_t *size2);
-H5_DLL herr_t H5V_hyper_fill(unsigned n, const hsize_t *_size,
+H5_DLL herr_t H5VM_hyper_fill(unsigned n, const hsize_t *_size,
 			      const hsize_t *total_size,
 			      const hsize_t *offset, void *_dst,
 			      unsigned fill_value);
-H5_DLL herr_t H5V_hyper_copy(unsigned n, const hsize_t *size,
+H5_DLL herr_t H5VM_hyper_copy(unsigned n, const hsize_t *size,
 			      const hsize_t *dst_total_size,
 			      const hsize_t *dst_offset, void *_dst,
 			      const hsize_t *src_total_size,
 			      const hsize_t *src_offset, const void *_src);
-H5_DLL herr_t H5V_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
+H5_DLL herr_t H5VM_stride_fill(unsigned n, hsize_t elmt_size, const hsize_t *size,
 			       const hsize_t *stride, void *_dst,
 			       unsigned fill_value);
-H5_DLL herr_t H5V_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *_size,
+H5_DLL herr_t H5VM_stride_copy(unsigned n, hsize_t elmt_size, const hsize_t *_size,
 			       const hsize_t *dst_stride, void *_dst,
 			       const hsize_t *src_stride, const void *_src);
-H5_DLL herr_t H5V_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *_size,
+H5_DLL herr_t H5VM_stride_copy_s(unsigned n, hsize_t elmt_size, const hsize_t *_size,
 			       const hssize_t *dst_stride, void *_dst,
 			       const hssize_t *src_stride, const void *_src);
-H5_DLL herr_t H5V_array_fill(void *_dst, const void *src, size_t size,
+H5_DLL herr_t H5VM_array_fill(void *_dst, const void *src, size_t size,
 			      size_t count);
-H5_DLL herr_t H5V_array_down(unsigned n, const hsize_t *total_size,
+H5_DLL herr_t H5VM_array_down(unsigned n, const hsize_t *total_size,
     hsize_t *down);
-H5_DLL hsize_t H5V_array_offset_pre(unsigned n,
+H5_DLL hsize_t H5VM_array_offset_pre(unsigned n,
     const hsize_t *acc, const hsize_t *offset);
-H5_DLL hsize_t H5V_array_offset(unsigned n, const hsize_t *total_size,
+H5_DLL hsize_t H5VM_array_offset(unsigned n, const hsize_t *total_size,
     const hsize_t *offset);
-H5_DLL herr_t H5V_array_calc(hsize_t offset, unsigned n,
+H5_DLL herr_t H5VM_array_calc(hsize_t offset, unsigned n,
     const hsize_t *total_size, hsize_t *coords);
-H5_DLL herr_t H5V_chunk_index(unsigned ndims, const hsize_t *coord,
+H5_DLL herr_t H5VM_chunk_index(unsigned ndims, const hsize_t *coord,
     const uint32_t *chunk, const hsize_t *down_nchunks, hsize_t *chunk_idx);
-H5_DLL ssize_t H5V_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
+H5_DLL ssize_t H5VM_opvv(size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[],
     hsize_t dst_off_arr[],
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[],
     hsize_t src_off_arr[],
-    H5V_opvv_func_t op, void *op_data);
-H5_DLL ssize_t H5V_memcpyvv(void *_dst,
+    H5VM_opvv_func_t op, void *op_data);
+H5_DLL ssize_t H5VM_memcpyvv(void *_dst,
     size_t dst_max_nseq, size_t *dst_curr_seq, size_t dst_len_arr[], hsize_t dst_off_arr[],
     const void *_src,
     size_t src_max_nseq, size_t *src_curr_seq, size_t src_len_arr[], hsize_t src_off_arr[]);
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_reduce_product
+ * Function:    H5VM_vector_reduce_product
  *
  * Purpose:     Product reduction of a vector.  Vector elements and return
  *              value are size_t because we usually want the number of
@@ -122,7 +122,7 @@ H5_DLL ssize_t H5V_memcpyvv(void *_dst,
  *-------------------------------------------------------------------------
  */
 static H5_inline hsize_t UNUSED
-H5V_vector_reduce_product(unsigned n, const hsize_t *v)
+H5VM_vector_reduce_product(unsigned n, const hsize_t *v)
 {
     hsize_t                  ret_value = 1;
 
@@ -137,7 +137,7 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_zerop_u
+ * Function:    H5VM_vector_zerop_u
  *
  * Purpose:     Determines if all elements of a vector are zero.
  *
@@ -154,7 +154,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline htri_t UNUSED
-H5V_vector_zerop_u(int n, const hsize_t *v)
+H5VM_vector_zerop_u(int n, const hsize_t *v)
 {
     htri_t      ret_value=TRUE;       /* Return value */
 
@@ -172,7 +172,7 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_zerop_s
+ * Function:    H5VM_vector_zerop_s
  *
  * Purpose:     Determines if all elements of a vector are zero.
  *
@@ -189,7 +189,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline htri_t UNUSED
-H5V_vector_zerop_s(int n, const hssize_t *v)
+H5VM_vector_zerop_s(int n, const hssize_t *v)
 {
     htri_t      ret_value=TRUE;       /* Return value */
 
@@ -207,7 +207,7 @@ done:
 }
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_cmp_u
+ * Function:    H5VM_vector_cmp_u
  *
  * Purpose:     Compares two vectors of the same size and determines if V1 is
  *              lexicographically less than, equal, or greater than V2.
@@ -226,7 +226,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline int UNUSED
-H5V_vector_cmp_u (unsigned n, const hsize_t *v1, const hsize_t *v2)
+H5VM_vector_cmp_u (unsigned n, const hsize_t *v1, const hsize_t *v2)
 {
     int ret_value=0;    /* Return value */
 
@@ -249,7 +249,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:	H5V_vector_cmp_s
+ * Function:	H5VM_vector_cmp_s
  *
  * Purpose:     Compares two vectors of the same size and determines if V1 is
  *              lexicographically less than, equal, or greater than V2.
@@ -268,7 +268,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline int UNUSED
-H5V_vector_cmp_s (unsigned n, const hssize_t *v1, const hssize_t *v2)
+H5VM_vector_cmp_s (unsigned n, const hssize_t *v1, const hssize_t *v2)
 {
     int ret_value=0;    /* Return value */
 
@@ -291,7 +291,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_vector_inc
+ * Function:    H5VM_vector_inc
  *
  * Purpose:     Increments V1 by V2
  *
@@ -305,7 +305,7 @@ done:
  *-------------------------------------------------------------------------
  */
 static H5_inline void UNUSED
-H5V_vector_inc(int n, hsize_t *v1, const hsize_t *v2)
+H5VM_vector_inc(int n, hsize_t *v1, const hsize_t *v2)
 {
     while (n--) *v1++ += *v2++;
 }
@@ -333,7 +333,7 @@ static const unsigned char LogTable256[] =
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_log2_gen
+ * Function:    H5VM_log2_gen
  *
  * Purpose:     Determines the log base two of a number (i.e. log2(n)).
  *              (i.e. the highest bit set in a number)
@@ -352,7 +352,7 @@ static const unsigned char LogTable256[] =
  *-------------------------------------------------------------------------
  */
 static H5_inline unsigned UNUSED
-H5V_log2_gen(uint64_t n)
+H5VM_log2_gen(uint64_t n)
 {
     unsigned r;                         /* r will be log2(n) */
     register unsigned int t, tt, ttt;   /* temporaries */
@@ -379,7 +379,7 @@ H5V_log2_gen(uint64_t n)
 #endif /* H5_BAD_LOG2_CODE_GENERATED  */
 
     return(r);
-} /* H5V_log2_gen() */
+} /* H5VM_log2_gen() */
 
 
 /* Lookup table for specialized log2(n) of power of two routine */
@@ -391,7 +391,7 @@ static const unsigned MultiplyDeBruijnBitPosition[32] =
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_log2_of2
+ * Function:    H5VM_log2_of2
  *
  * Purpose:     Determines the log base two of a number (i.e. log2(n)).
  *              (i.e. the highest bit set in a number)
@@ -409,17 +409,17 @@ static const unsigned MultiplyDeBruijnBitPosition[32] =
  *-------------------------------------------------------------------------
  */
 static H5_inline unsigned UNUSED
-H5V_log2_of2(uint32_t n)
+H5VM_log2_of2(uint32_t n)
 {
 #ifndef NDEBUG
     HDassert(POWER_OF_TWO(n));
 #endif /* NDEBUG */
     return(MultiplyDeBruijnBitPosition[(n * (uint32_t)0x077CB531UL) >> 27]);
-} /* H5V_log2_of2() */
+} /* H5VM_log2_of2() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_limit_enc_size
+ * Function:    H5VM_limit_enc_size
  *
  * Purpose:     Determine the # of bytes needed to encode values within a
  *              range from 0 to a given limit
@@ -432,17 +432,17 @@ H5V_log2_of2(uint32_t n)
  *-------------------------------------------------------------------------
  */
 static H5_inline unsigned UNUSED
-H5V_limit_enc_size(uint64_t limit)
+H5VM_limit_enc_size(uint64_t limit)
 {
-    return (H5V_log2_gen(limit) / 8) + 1;
-} /* end H5V_limit_enc_size() */
+    return (H5VM_log2_gen(limit) / 8) + 1;
+} /* end H5VM_limit_enc_size() */
 
-static const unsigned char H5V_bit_set_g[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
-static const unsigned char H5V_bit_clear_g[8] = {0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE};
+static const unsigned char H5VM_bit_set_g[8] = {0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01};
+static const unsigned char H5VM_bit_clear_g[8] = {0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0xFB, 0xFD, 0xFE};
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_bit_get
+ * Function:    H5VM_bit_get
  *
  * Purpose:     Determine the value of the n'th bit in a buffer.
  *
@@ -461,15 +461,15 @@ static const unsigned char H5V_bit_clear_g[8] = {0x7F, 0xBF, 0xDF, 0xEF, 0xF7, 0
  *-------------------------------------------------------------------------
  */
 static H5_inline hbool_t UNUSED
-H5V_bit_get(const unsigned char *buf, size_t offset)
+H5VM_bit_get(const unsigned char *buf, size_t offset)
 {
     /* Test the appropriate bit in the buffer */
-    return (hbool_t)((buf[offset / 8] & (H5V_bit_set_g[offset % 8])) ? TRUE : FALSE);
-} /* end H5V_bit_get() */
+    return (hbool_t)((buf[offset / 8] & (H5VM_bit_set_g[offset % 8])) ? TRUE : FALSE);
+} /* end H5VM_bit_get() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5V_bit_set
+ * Function:    H5VM_bit_set
  *
  * Purpose:     Set/reset the n'th bit in a buffer.
  *
@@ -488,14 +488,14 @@ H5V_bit_get(const unsigned char *buf, size_t offset)
  *-------------------------------------------------------------------------
  */
 static H5_inline void UNUSED
-H5V_bit_set(unsigned char *buf, size_t offset, hbool_t val)
+H5VM_bit_set(unsigned char *buf, size_t offset, hbool_t val)
 {
     /* Set/reset the appropriate bit in the buffer */
     if(val)
-        buf[offset / 8] |= H5V_bit_set_g[offset % 8];
+        buf[offset / 8] |= H5VM_bit_set_g[offset % 8];
     else
-        buf[offset / 8] &= H5V_bit_clear_g[offset % 8];
-} /* end H5V_bit_set() */
+        buf[offset / 8] &= H5VM_bit_clear_g[offset % 8];
+} /* end H5VM_bit_set() */
 
-#endif /* H5Vprivate_H */
+#endif /* H5VMprivate_H */
 
diff --git a/src/H5Ztrans.c b/src/H5Ztrans.c
index f9e7186..1b8c096 100644
--- a/src/H5Ztrans.c
+++ b/src/H5Ztrans.c
@@ -20,7 +20,7 @@
 #include "H5Eprivate.h"		/* Error handling		  	*/
 #include "H5Iprivate.h"		/* IDs			  		*/
 #include "H5MMprivate.h"	/* Memory management			*/
-#include "H5Vprivate.h"		/* H5V_array_fill			*/
+#include "H5VMprivate.h"		/* H5VM_array_fill			*/
 #include "H5Zpkg.h"		/* Data filters				*/
 
 
@@ -292,7 +292,7 @@ static void H5Z_print(H5Z_node *tree, FILE *stream);
 #define H5Z_XFORM_DO_OP5(TYPE, SIZE)                                                               \
 {                                                                                                  \
     TYPE val = ((tree->type == H5Z_XFORM_INTEGER) ? (TYPE)tree->value.int_val : (TYPE)tree->value.float_val); \
-    H5V_array_fill(array, &val, sizeof(TYPE), (SIZE));                                             \
+    H5VM_array_fill(array, &val, sizeof(TYPE), (SIZE));                                             \
 }
 
 /* The difference of this macro from H5Z_XFORM_DO_OP3 is that it handles the operations when the left operand is empty, like -x or +x.  
diff --git a/src/Makefile.am b/src/Makefile.am
index f63a36e..6525211 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -104,7 +104,7 @@ libhdf5_la_SOURCES= H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
         H5Tfloat.c H5Tinit.c H5Tnative.c H5Toffset.c H5Toh.c \
         H5Topaque.c \
         H5Torder.c \
-        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5V.c H5WB.c H5Z.c  \
+        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5VM.c H5WB.c H5Z.c  \
         H5Zdeflate.c H5Zfletcher32.c H5Znbit.c H5Zshuffle.c H5Zszip.c  \
         H5Zscaleoffset.c H5Ztrans.c
 
diff --git a/src/Makefile.in b/src/Makefile.in
index 79b268e..edfa1dd 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -169,7 +169,7 @@ am_libhdf5_la_OBJECTS = H5.lo H5checksum.lo H5dbg.lo H5system.lo \
 	H5Tfields.lo H5Tfixed.lo H5Tfloat.lo H5Tinit.lo H5Tnative.lo \
 	H5Toffset.lo H5Toh.lo H5Topaque.lo H5Torder.lo H5Tpad.lo \
 	H5Tprecis.lo H5Tstrpad.lo H5Tvisit.lo H5Tvlen.lo H5TS.lo \
-	H5V.lo H5WB.lo H5Z.lo H5Zdeflate.lo H5Zfletcher32.lo \
+	H5VM.lo H5WB.lo H5Z.lo H5Zdeflate.lo H5Zfletcher32.lo \
 	H5Znbit.lo H5Zshuffle.lo H5Zszip.lo H5Zscaleoffset.lo \
 	H5Ztrans.lo
 libhdf5_la_OBJECTS = $(am_libhdf5_la_OBJECTS)
@@ -599,7 +599,7 @@ libhdf5_la_SOURCES = H5.c H5checksum.c H5dbg.c H5system.c H5timer.c H5trace.c \
         H5Tfloat.c H5Tinit.c H5Tnative.c H5Toffset.c H5Toh.c \
         H5Topaque.c \
         H5Torder.c \
-        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5V.c H5WB.c H5Z.c  \
+        H5Tpad.c H5Tprecis.c H5Tstrpad.c H5Tvisit.c H5Tvlen.c H5TS.c H5VM.c H5WB.c H5Z.c  \
         H5Zdeflate.c H5Zfletcher32.c H5Znbit.c H5Zshuffle.c H5Zszip.c  \
         H5Zscaleoffset.c H5Ztrans.c
 
@@ -998,7 +998,7 @@ distclean-compile:
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Tvisit.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Tvlen.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5UC.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5V.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5VM.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5WB.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Z.Plo@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H5Zdeflate.Plo@am__quote@
diff --git a/src/hdf5.lnt b/src/hdf5.lnt
index 6865720..90af778 100644
--- a/src/hdf5.lnt
+++ b/src/hdf5.lnt
@@ -1,9 +1,9 @@
 // Lint options shared by both PC-Lint for Windows and Flexelint for Linux
 
 // Turn off warnings about not using the inlined H5V* functions:
--esym(528, H5V_vector_reduce_product, H5V_vector_inc)
--esym(528, H5V_vector_cmp, H5V_vector_cmp_s, H5V_vector_cmp_u)
--esym(528, H5V_vector_zerop_s, H5V_vector_zerop_u)
+-esym(528, H5VM_vector_reduce_product, H5VM_vector_inc)
+-esym(528, H5VM_vector_cmp, H5VM_vector_cmp_s, H5VM_vector_cmp_u)
+-esym(528, H5VM_vector_zerop_s, H5VM_vector_zerop_u)
 
 // Suppress message about using 'goto' in a few functions
 -efunc(801,H5_term_library,H5_trace)
@@ -34,7 +34,7 @@
 -esym(534, H5I_clear_type, H5I_dec_type_ref)
 -esym(534, H5MM_xfree)
 -esym(534, H5UC_decr)
--esym(534, H5V_array_fill)
+-esym(534, H5VM_array_fill)
 
 
 // Turn off warnings about "Expression-like macro not parenthesized" for