[svn-r18726] Description:

	Bring r18725 from trunk to 1.8 branch:

	Bring r18724 from metadata journaling 'merging' branch to trunk:

	Rename H5[A]C_rename to H5[A]C_move_entry.

Tested on:
	FreeBSD/32 6.3 (duty) w/debug
	(h5committested on trunk)

3 files changed, 199 insertions, 199 deletions

diff --git a/test/cache.c b/test/cache.c
index cf565c5..6a35a84 100644
--- a/test/cache.c
+++ b/test/cache.c
@@ -97,16 +97,16 @@ static unsigned check_flush_protected_err(void);
 static unsigned check_get_entry_status(void);
 static unsigned check_expunge_entry(void);
 static unsigned check_multiple_read_protect(void);
-static unsigned check_rename_entry(void);
-static void check_rename_entry__run_test(H5F_t * file_ptr, int test_num,
-                                      struct rename_entry_test_spec * spec_ptr);
+static unsigned check_move_entry(void);
+static void check_move_entry__run_test(H5F_t * file_ptr, int test_num,
+                                      struct move_entry_test_spec * spec_ptr);
 static unsigned check_pin_protected_entry(void);
 static unsigned check_resize_entry(void);
 static unsigned check_evictions_enabled(void);
 static unsigned check_destroy_pinned_err(void);
 static unsigned check_destroy_protected_err(void);
 static unsigned check_duplicate_insert_err(void);
-static unsigned check_rename_err(void);
+static unsigned check_move_err(void);
 static unsigned check_double_pin_err(void);
 static unsigned check_double_unpin_err(void);
 static unsigned check_pin_entry_errs(void);
@@ -135,7 +135,7 @@ static unsigned check_metadata_blizzard_absence(hbool_t fill_via_insertion);
 /*-------------------------------------------------------------------------
  * Function:	smoke_check_1()
  *
- * Purpose:	A basic functional test, inserts, destroys, and renames in
+ * Purpose:	A basic functional test, inserts, destroys, and moves in
  *              the mix, along with repeated protects and unprotects.
  *		All entries are marked as clean.
  *
@@ -201,8 +201,8 @@ smoke_check_1(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -220,8 +220,8 @@ smoke_check_1(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -239,8 +239,8 @@ smoke_check_1(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -326,7 +326,7 @@ smoke_check_1(void)
  * Function:	smoke_check_2()
  *
  * Purpose:	A basic functional test, with inserts, destroys, and
- *		renames in the mix, along with some repeated protects
+ *		moves in the mix, along with some repeated protects
  *		and unprotects.  About half the entries are marked as
  *		dirty.
  *
@@ -392,8 +392,8 @@ smoke_check_2(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -411,8 +411,8 @@ smoke_check_2(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -430,8 +430,8 @@ smoke_check_2(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -517,7 +517,7 @@ smoke_check_2(void)
  * Function:	smoke_check_3()
  *
  * Purpose:	A basic functional test on a tiny cache, with inserts,
- *		destroys, and renames in the mix, along with repeated
+ *		destroys, and moves in the mix, along with repeated
  *		protects and unprotects.  All entries are marked as clean.
  *
  * Return:	void
@@ -582,8 +582,8 @@ smoke_check_3(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -601,8 +601,8 @@ smoke_check_3(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -620,8 +620,8 @@ smoke_check_3(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -707,7 +707,7 @@ smoke_check_3(void)
  * Function:	smoke_check_4()
  *
  * Purpose:	A basic functional test on a tiny cache, with inserts,
- *	 	destroys, and renames in the mix, along with repeated
+ *	 	destroys, and moves in the mix, along with repeated
  *		protects and unprotects.  About half the entries are
  *		marked as dirty.
  *
@@ -773,8 +773,8 @@ smoke_check_4(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -792,8 +792,8 @@ smoke_check_4(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -811,8 +811,8 @@ smoke_check_4(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -1861,7 +1861,7 @@ smoke_check_8(void)
  * 		part of the time.
  *
  * 		Recall that smoke check 1 is a basic functional test,
- * 		with inserts, destroys, and renames in the mix, along
+ * 		with inserts, destroys, and moves in the mix, along
  * 		with repeated protects and unprotects.  All entries are
  * 		marked as clean.
  *
@@ -1946,8 +1946,8 @@ smoke_check_9(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -1982,8 +1982,8 @@ smoke_check_9(void)
                             /* display_detailed_stats */ display_detailed_stats,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -2016,8 +2016,8 @@ smoke_check_9(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -2167,7 +2167,7 @@ smoke_check_9(void)
  * 		part of the time.
  *
  * 		Recall that smoke check 2 is a basic functional test,
- * 		with inserts, destroys, and renames in the mix, along
+ * 		with inserts, destroys, and moves in the mix, along
  * 		with some repeated protects and unprotects.  About half
  * 		the entries are marked as dirty.
  *
@@ -2235,8 +2235,8 @@ smoke_check_10(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -2269,8 +2269,8 @@ smoke_check_10(void)
                             /* display_detailed_stats */ display_detailed_stats,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ dirty_inserts,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ dirty_destroys,
@@ -2303,8 +2303,8 @@ smoke_check_10(void)
                            /* display_detailed_stats */ display_detailed_stats,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ dirty_inserts,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ dirty_destroys,
@@ -2526,8 +2526,8 @@ write_permitted_check(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ TRUE,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ TRUE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ TRUE,
@@ -2547,8 +2547,8 @@ write_permitted_check(void)
                             /* display_detailed_stats */ TRUE,
                             /* do_inserts             */ FALSE,
                             /* dirty_inserts          */ FALSE,
-                            /* do_renames             */ TRUE,
-                            /* rename_to_main_addr    */ TRUE,
+                            /* do_moves             */ TRUE,
+                            /* move_to_main_addr    */ TRUE,
                             /* do_destroys            */ FALSE,
 			    /* do_mult_ro_protects    */ TRUE,
                             /* dirty_destroys         */ FALSE,
@@ -2568,8 +2568,8 @@ write_permitted_check(void)
                            /* display_detailed_stats */ TRUE,
                            /* do_inserts             */ TRUE,
                            /* dirty_inserts          */ TRUE,
-                           /* do_renames             */ TRUE,
-                           /* rename_to_main_addr    */ FALSE,
+                           /* do_moves             */ TRUE,
+                           /* move_to_main_addr    */ FALSE,
                            /* do_destroys            */ FALSE,
 			   /* do_mult_ro_protects    */ TRUE,
                            /* dirty_destroys         */ TRUE,
@@ -5416,7 +5416,7 @@ check_flush_cache__pe_multi_entry_test(H5F_t * file_ptr,
  *
  * 		These are tests that test the cache's ability to handle
  * 		the case in which the flush callback dirties, resizes,
- * 		and/or renames entries.
+ * 		and/or moves entries.
  *
  * 		Do nothing if pass is FALSE on entry.
  *
@@ -5820,7 +5820,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
     if ( pass ) /* test #5 & #6 */
     {
 	/* Single entry test verifying that the cache can handle the case in
-	 * which the call back function renames the entry for which it has
+	 * which the call back function moves the entry for which it has
 	 * been called.
 	 *
 	 * Run this entry twice, as the first run moves the entry to its
@@ -5848,7 +5848,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* num_flush_ops      = */ 1,
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: */
-	    { { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	    { { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
@@ -5896,11 +5896,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -5932,7 +5932,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * second test.
 	 *
 	 * Single entry test verifying that the cache can handle the case in
-	 * which the call back function renames the entry for which it has
+	 * which the call back function moves the entry for which it has
 	 * been called.
 	 *
 	 * Run this entry twice, as the first run moves the entry to its
@@ -5960,7 +5960,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* num_flush_ops      = */ 1,
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: */
-	    { { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	    { { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
@@ -6008,11 +6008,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -6046,7 +6046,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
     if ( pass ) /* test #9 & #10 */
     {
 	/* Single entry test verifying that the cache can handle the case in
-	 * which the call back function both resizes and renames the entry
+	 * which the call back function both resizes and moves the entry
 	 * for which it has been called.
 	 *
 	 * Again, we run this entry twice, as the first run moves the entry
@@ -6075,7 +6075,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
@@ -6122,11 +6122,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -6158,7 +6158,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * second test.
 	 *
 	 * Single entry test verifying that the cache can handle the case in
-	 * which the call back function both resizes and renames the entry
+	 * which the call back function both resizes and moves the entry
 	 * for which it has been called.
 	 *
 	 * Again, we run this entry twice, as the first run moves the entry to its
@@ -6187,7 +6187,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /* flush_ops          = */
 	    /*	op_code:		type:			idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,			0,	FALSE,	0 },
@@ -6234,11 +6234,11 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the rename to move the target entry back to its
+	/* this change forces the move to move the target entry back to its
 	 * main address.  The first test moved it to its alternate address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entry is moved forward in the slist.  In the second
+	 * the moved entry is moved forward in the slist.  In the second
 	 * it is moved backwards.
 	 *
 	 * Since there is only one entry in the cache, this doesn't really
@@ -6661,7 +6661,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
     {
 	/* Test the ability of the cache to handle the case in which
 	 * the flush function of an entry that is resident in cache
-	 * resizes, dirties, and renames two entries that are not in cache.
+	 * resizes, dirties, and moves two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
 	 * lets make sure we can handle it regardless.
@@ -6692,10 +6692,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -6753,12 +6753,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the renames to move the target entries back to
+	/* this change forces the moves to move the target entries back to
 	 * their main address.  The first test moved them to their alternate
 	 * address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entries are moved forward in the slist.  In the second
+	 * the moved entries are moved forward in the slist.  In the second
 	 * they are moved backwards.
 	 */
 	if ( pass ) {
@@ -6790,7 +6790,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 *
 	 * Test the ability of the cache to handle the case in which
 	 * the flush function of an entry that is resident in cache
-	 * resizes, dirties, and renames two entries that are not in cache.
+	 * resizes, dirties, and moves two entries that are not in cache.
 	 *
 	 * At present, I am assured that this case will never occur, but
 	 * lets make sure we can handle it regardless.
@@ -6821,10 +6821,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -6882,12 +6882,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 					 check_size,
 					 checks);
 
-	/* this change forces the renames to move the target entries back to
+	/* this change forces the moves to move the target entries back to
 	 * their main address.  The first test moved them to their alternate
 	 * address.
 	 *
 	 * Note that these two tests are not the same, as in the first test,
-	 * the renamed entries are moved forward in the slist.  In the second
+	 * the moved entries are moved forward in the slist.  In the second
 	 * they are moved backwards.
 	 */
 	if ( pass ) {
@@ -6925,7 +6925,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	/* Now mix things up a bit.
 	 *
 	 * Load several entries, two of which have flush functions that
-	 * resize, dirty, and rename two entries that are not in the
+	 * resize, dirty, and move two entries that are not in the
 	 * cache.  Mark only one of these entries, and then flush the
 	 * cache with the flush marked entries flag.
 	 *
@@ -6962,10 +6962,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -6990,10 +6990,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -7144,7 +7144,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	/* Mix things up some more.
 	 *
 	 * Load lots of entries, some of which have flush functions that
-	 * resize, dirty, and rename two entries that are not in the
+	 * resize, dirty, and move two entries that are not in the
 	 * cache.
 	 *
 	 * Also load entries that have flush ops on entries that are in
@@ -7177,10 +7177,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -7205,10 +7205,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -7417,7 +7417,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * Mix things up some more.
 	 *
 	 * Load lots of entries, some of which have flush functions that
-	 * resize, dirty, and rename two entries that are not in the
+	 * resize, dirty, and move two entries that are not in the
 	 * cache.
 	 *
 	 * Also load entries that have flush ops on entries that are in
@@ -7447,10 +7447,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	0,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -7475,10 +7475,10 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	VARIABLE_ENTRY_SIZE / 4 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	10,	FALSE,	0 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	12,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -7986,12 +7986,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * 		dirties (VET, 100)
 	 * 		resizes (VET, 200)
 	 * 		dirty	(VET, 300) -- dirty first to bring into cache.
-	 * 		renames (VET, 300)
+	 * 		moves (VET, 300)
 	 *
 	 * (VET, 2000)	initially clean, and in cache
 	 * 		dirties (VET, 2100)
 	 * 		resizes (VET, 2200)
-	 * 		renames (VET, 2300)
+	 * 		moves (VET, 2300)
 	 *
 	 * (VET, 350)	initially clean, and in cache
 	 * 		pins	(VET, 1000)
@@ -8003,7 +8003,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * (VET, 450)	initially dirty, and in cache
 	 * 		pins	(VET, 1000)
 	 * 		dirties	(VET, 1000)
-	 * 		renames (VET, 450)
+	 * 		moves (VET, 450)
 	 * 		pins	(VET, 2000)
 	 * 		dirties (VET, 2000)
 	 *
@@ -8136,7 +8136,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -8163,7 +8163,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2200,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -8423,12 +8423,12 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * 		dirties (VET, 100)
 	 * 		resizes (VET, 200)
 	 * 		dirty	(VET, 300) -- dirty first to bring into cache.
-	 * 		renames (VET, 300)
+	 * 		moves (VET, 300)
 	 *
 	 * (VET, 2000)	initially clean, and in cache
 	 * 		dirties (VET, 2100)
 	 * 		resizes (VET, 2200)
-	 * 		renames (VET, 2300)
+	 * 		moves (VET, 2300)
 	 *
 	 * (VET, 350)	initially clean, and in cache
 	 * 		pins	(VET, 1000)
@@ -8440,7 +8440,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	 * (VET, 450)	initially dirty, and in cache
 	 * 		pins	(VET, 1000)
 	 * 		dirties	(VET, 1000)
-	 * 		renames (VET, 450)
+	 * 		moves (VET, 450)
 	 * 		pins	(VET, 2000)
 	 * 		dirties (VET, 2000)
 	 *
@@ -8573,7 +8573,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
 	      { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -8600,7 +8600,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	2100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	2200,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	2300,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -8878,7 +8878,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	200,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -8906,7 +8906,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	400,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -8962,7 +8962,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	500,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -9071,7 +9071,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	VARIABLE_ENTRY_SIZE },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	200,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	200,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -9099,7 +9099,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	400,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	300,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -9155,7 +9155,7 @@ check_flush_cache__flush_ops(H5F_t * file_ptr)
 	    /*	op_code:		type:	idx:	flag:	size: */
 	    { { FLUSH_OP__DIRTY,	VARIABLE_ENTRY_TYPE,	100,	FALSE,	0 },
 	      { FLUSH_OP__RESIZE,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	VARIABLE_ENTRY_SIZE / 2 },
-	      { FLUSH_OP__RENAME,	VARIABLE_ENTRY_TYPE,	500,	FALSE,	0 },
+	      { FLUSH_OP__MOVE,		VARIABLE_ENTRY_TYPE,	500,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
 	      { FLUSH_OP__NO_OP,	0,	0,	FALSE,	0 },
@@ -9986,7 +9986,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 *
 	 *          (VET, 2) dirties (VET, 0)
 	 *                   resizes (VET, 0) to VARIABLE_ENTRY_SIZE
-	 *                   renames (VET, 0) to its alternate address
+	 *                   moves (VET, 0) to its alternate address
 	 *
 	 *          (VET, 3) dirties (VET, 0)
 	 *                   resizes itself to VARIABLE_ENTRY_SIZE
@@ -10003,7 +10003,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
         add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RESIZE,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, VARIABLE_ENTRY_SIZE);
-        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__RENAME,
+        add_flush_op(VARIABLE_ENTRY_TYPE, 2, FLUSH_OP__MOVE,
                      VARIABLE_ENTRY_TYPE, 0, FALSE, (size_t)0);
 
         add_flush_op(VARIABLE_ENTRY_TYPE, 3, FLUSH_OP__DIRTY,
@@ -10030,7 +10030,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 *
 	 * (VET, 2)	Y	10 KB	N	N	0	dirty (VET, 0)
 	 * 							resize (VET, 0) to 10 KB
-	 * 							rename (VET, 0) to its alternate address
+	 * 							move (VET, 0) to its alternate address
 	 *
 	 * (VET, 3)	Y	 5 KB	Y	N	0, 7	dirty (VET, 0)
 	 * 							resize (VET, 3) to 10 KB
@@ -10104,7 +10104,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 	 *
 	 * (VET, 2)	Y	10 KB	N	N	0	dirty (VET, 0)
 	 * 							resize (VET, 0) to 10 KB
-	 * 							rename (VET, 0) to its alternate address
+	 * 							move (VET, 0) to its alternate address
 	 *
 	 * (VET, 3)	Y	 5 KB	Y	N	0, 7	dirty (VET, 0)
 	 * 							resize (VET, 3) to 10 KB
@@ -10156,7 +10156,7 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
 
 	/* Now load another large entry.  This should result in the eviction
 	 * of (VET, 2), the increase in the size of (VET, 0) from .75
-	 * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the renaming
+	 * VARIABLE_ENTRY_SIZE to 1.0 VARIABLE_ENTRY_SIZE, and the moving
 	 * of (VET, 0) to its alternate address.
 	 *
 	 * The following table shows the expected states of the variable
@@ -10839,9 +10839,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
              ( cache_ptr->clears[VARIABLE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->flushes[VARIABLE_ENTRY_TYPE] != 14 ) ||
              ( cache_ptr->evictions[VARIABLE_ENTRY_TYPE] != 9 ) ||
-             ( cache_ptr->renames[VARIABLE_ENTRY_TYPE] != 1 ) ||
-             ( cache_ptr->entry_flush_renames[VARIABLE_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->cache_flush_renames[VARIABLE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->moves[VARIABLE_ENTRY_TYPE] != 1 ) ||
+             ( cache_ptr->entry_flush_moves[VARIABLE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->cache_flush_moves[VARIABLE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->pins[VARIABLE_ENTRY_TYPE] != 2 ) ||
              ( cache_ptr->unpins[VARIABLE_ENTRY_TYPE] != 2 ) ||
              ( cache_ptr->dirty_pins[VARIABLE_ENTRY_TYPE] != 0 ) ||
@@ -10864,9 +10864,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
              ( cache_ptr->clears[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->flushes[LARGE_ENTRY_TYPE] != 38 ) ||
              ( cache_ptr->evictions[LARGE_ENTRY_TYPE] != 14 ) ||
-             ( cache_ptr->renames[LARGE_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->entry_flush_renames[LARGE_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->cache_flush_renames[LARGE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->moves[LARGE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->entry_flush_moves[LARGE_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->cache_flush_moves[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->pins[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->unpins[LARGE_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->dirty_pins[LARGE_ENTRY_TYPE] != 0 ) ||
@@ -10889,9 +10889,9 @@ check_flush_cache__flush_op_eviction_test(H5F_t * file_ptr)
              ( cache_ptr->clears[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->flushes[MONSTER_ENTRY_TYPE] != 93 ) ||
              ( cache_ptr->evictions[MONSTER_ENTRY_TYPE] != 31 ) ||
-             ( cache_ptr->renames[MONSTER_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->entry_flush_renames[MONSTER_ENTRY_TYPE] != 0 ) ||
-             ( cache_ptr->cache_flush_renames[MONSTER_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->entry_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
+             ( cache_ptr->cache_flush_moves[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->pins[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->unpins[MONSTER_ENTRY_TYPE] != 0 ) ||
              ( cache_ptr->dirty_pins[MONSTER_ENTRY_TYPE] != 0 ) ||
@@ -14465,9 +14465,9 @@ check_multiple_read_protect(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	check_rename_entry()
+ * Function:	check_move_entry()
  *
- * Purpose:	Verify that H5C_rename_entry behaves as expected.  In
+ * Purpose:	Verify that H5C_move_entry behaves as expected.  In
  * 		particular, verify that it works correctly with pinned
  * 		entries.
  *
@@ -14482,12 +14482,12 @@ check_multiple_read_protect(void)
  */
 
 static unsigned
-check_rename_entry(void)
+check_move_entry(void)
 {
-    const char * fcn_name = "check_rename_entry";
+    const char * fcn_name = "check_move_entry";
     int          i;
     H5F_t *      file_ptr = NULL;
-    struct rename_entry_test_spec test_specs[4] =
+    struct move_entry_test_spec test_specs[4] =
     {
       {
         /* int     entry_type  = */ PICO_ENTRY_TYPE,
@@ -14515,23 +14515,23 @@ check_rename_entry(void)
       }
     };
 
-    TESTING("H5C_rename_entry() functionality");
+    TESTING("H5C_move_entry() functionality");
 
     pass = TRUE;
 
-    /* allocate a cache, load entries into it, and then rename
+    /* allocate a cache, load entries into it, and then move
      * them.  To the extent possible, verify that the desired
      * actions took place.
      *
      * At present, we should do the following tests:
      *
-     * 1) Rename a clean, unprotected, unpinned entry.
+     * 1) move a clean, unprotected, unpinned entry.
      *
-     * 2) Rename a dirty, unprotected, unpinned entry.
+     * 2) move a dirty, unprotected, unpinned entry.
      *
-     * 3) Rename a clean, unprotected, pinned entry.
+     * 3) move a clean, unprotected, pinned entry.
      *
-     * 4) Rename a dirty, unprotected, pinned entry.
+     * 4) move a dirty, unprotected, pinned entry.
      *
      * In all cases, the entry should have moved to its
      * new location, and have been marked dirty if it wasn't
@@ -14555,7 +14555,7 @@ check_rename_entry(void)
     i = 0;
     while ( ( pass ) && ( i < 4 ) )
     {
-        check_rename_entry__run_test(file_ptr, i, &(test_specs[i]));
+        check_move_entry__run_test(file_ptr, i, &(test_specs[i]));
 	i++;
     }
 
@@ -14574,13 +14574,13 @@ check_rename_entry(void)
 
     return (unsigned)!pass;
 
-} /* check_rename_entry() */
+} /* check_move_entry() */
 
 
 /*-------------------------------------------------------------------------
- * Function:    check_rename_entry__run_test()
+ * Function:    check_move_entry__run_test()
  *
- * Purpose:     Run a rename entry test.
+ * Purpose:     Run a move entry test.
  *
  *		Do nothing if pass is FALSE on entry.
  *
@@ -14597,11 +14597,11 @@ check_rename_entry(void)
  */
 
 static void
-check_rename_entry__run_test(H5F_t * file_ptr,
+check_move_entry__run_test(H5F_t * file_ptr,
                              int test_num,
-                             struct rename_entry_test_spec * spec_ptr)
+                             struct move_entry_test_spec * spec_ptr)
 {
-    /* const char *   fcn_name = "check_rename_entry__run_test"; */
+    /* const char *   fcn_name = "check_move_entry__run_test"; */
     H5C_t *       cache_ptr = file_ptr->shared->cache;
     static char    msg[128];
     unsigned int   flags = H5C__NO_FLAGS_SET;
@@ -14625,7 +14625,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
             pass = FALSE;
             HDsnprintf(msg, (size_t)128,
-                       "bad entry_ptr in rename test #%d.",
+                       "bad entry_ptr in move test #%d.",
                        test_num);
             failure_mssg = msg;
 
@@ -14642,15 +14642,15 @@ check_rename_entry__run_test(H5F_t * file_ptr,
         unprotect_entry(file_ptr, spec_ptr->entry_type, spec_ptr->entry_index,
                         (int)(spec_ptr->is_dirty), flags);
 
-        rename_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, FALSE);
+        move_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, FALSE);
 
     }
 
     if ( pass ) {
 
-        /* verify that the rename took place, and that the cache's internal
+        /* verify that the move took place, and that the cache's internal
          * structures are as expected.  Note that some sanity checking is
-         * done by rename_entry(), so we don't have to repeat it here.
+         * done by move_entry(), so we don't have to repeat it here.
          */
 
         if ( spec_ptr->is_pinned ) {
@@ -14659,7 +14659,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
-                           "Pinned entry not pinned after rename in test #%d.",
+                           "Pinned entry not pinned after move in test #%d.",
                            test_num);
                 failure_mssg = msg;
             }
@@ -14678,7 +14678,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
                     pass = FALSE;
                     HDsnprintf(msg, (size_t)128,
-                           "Pinned entry not in pel after rename in test #%d.",
+                           "Pinned entry not in pel after move in test #%d.",
                            test_num);
                     failure_mssg = msg;
                 }
@@ -14692,7 +14692,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
 
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
-                           "Unpinned entry pinned after rename in test #%d.",
+                           "Unpinned entry pinned after move in test #%d.",
                            test_num);
                 failure_mssg = msg;
             }
@@ -14702,7 +14702,7 @@ check_rename_entry__run_test(H5F_t * file_ptr,
             {
                 pass = FALSE;
                 HDsnprintf(msg, (size_t)128,
-                           "Entry not at head of LRU after rename in test #%d.",
+                           "Entry not at head of LRU after move in test #%d.",
                            test_num);
                 failure_mssg = msg;
             }
@@ -14710,11 +14710,11 @@ check_rename_entry__run_test(H5F_t * file_ptr,
     }
 
     /* put the entry back where it started from */
-    rename_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, TRUE);
+    move_entry(cache_ptr, spec_ptr->entry_type, spec_ptr->entry_index, TRUE);
 
     return;
 
-} /* check_rename_entry__run_test() */
+} /* check_move_entry__run_test() */
 
 
 /*-------------------------------------------------------------------------
@@ -16855,9 +16855,9 @@ check_duplicate_insert_err(void)
 
 
 /*-------------------------------------------------------------------------
- * Function:	check_rename_err()
+ * Function:	check_move_err()
  *
- * Purpose:	Verify that an attempt to rename an entry to the address
+ * Purpose:	Verify that an attempt to move an entry to the address
  *		of an existing entry will generate an error.
  *
  * Return:	void
@@ -16871,9 +16871,9 @@ check_duplicate_insert_err(void)
  */
 
 static unsigned
-check_rename_err(void)
+check_move_err(void)
 {
-    const char * fcn_name = "check_rename_err()";
+    const char * fcn_name = "check_move_err()";
     herr_t result;
     H5F_t * file_ptr = NULL;
     H5C_t * cache_ptr = NULL;
@@ -16881,11 +16881,11 @@ check_rename_err(void)
     test_entry_t * entry_0_1_ptr;
     test_entry_t * entry_1_0_ptr;
 
-    TESTING("rename to existing entry errors");
+    TESTING("move to existing entry errors");
 
     pass = TRUE;
 
-    /* allocate a cache, and insert several entries.  Try to rename
+    /* allocate a cache, and insert several entries.  Try to move
      * entries to other entries resident in the cache.  This should
      * fail.  Destroy the cache -- should succeed.
      */
@@ -16909,25 +16909,25 @@ check_rename_err(void)
 
     if ( pass ) {
 
-        result = H5C_rename_entry(cache_ptr, &(types[0]),
+        result = H5C_move_entry(cache_ptr, &(types[0]),
                                   entry_0_0_ptr->addr, entry_0_1_ptr->addr);
 
         if ( result >= 0 ) {
 
             pass = FALSE;
-            failure_mssg = "rename to addr of same type succeeded.\n";
+            failure_mssg = "move to addr of same type succeeded.\n";
         }
     }
 
     if ( pass ) {
 
-        result = H5C_rename_entry(cache_ptr, &(types[0]),
+        result = H5C_move_entry(cache_ptr, &(types[0]),
                                   entry_0_0_ptr->addr, entry_1_0_ptr->addr);
 
         if ( result >= 0 ) {
 
             pass = FALSE;
-            failure_mssg = "rename to addr of different type succeeded.\n";
+            failure_mssg = "move to addr of different type succeeded.\n";
         }
     }
 
@@ -16946,7 +16946,7 @@ check_rename_err(void)
 
     return (unsigned)!pass;
 
-} /* check_rename_err() */
+} /* check_move_err() */
 
 
 /*-------------------------------------------------------------------------
@@ -29807,7 +29807,7 @@ main(void)
     nerrs += check_get_entry_status();
     nerrs += check_expunge_entry();
     nerrs += check_multiple_read_protect();
-    nerrs += check_rename_entry();
+    nerrs += check_move_entry();
     nerrs += check_pin_protected_entry();
     nerrs += check_resize_entry();
     nerrs += check_evictions_enabled();
@@ -29815,7 +29815,7 @@ main(void)
     nerrs += check_destroy_pinned_err();
     nerrs += check_destroy_protected_err();
     nerrs += check_duplicate_insert_err();
-    nerrs += check_rename_err();
+    nerrs += check_move_err();
     nerrs += check_double_pin_err();
     nerrs += check_double_unpin_err();
     nerrs += check_pin_entry_errs();
diff --git a/test/cache_common.c b/test/cache_common.c
index 090e102..145e9b5 100644
--- a/test/cache_common.c
+++ b/test/cache_common.c
@@ -1475,8 +1475,8 @@ execute_flush_op(H5F_t * file_ptr,
 		}
 		break;
 
-	    case FLUSH_OP__RENAME:
-		rename_entry(cache_ptr, op_ptr->type, op_ptr->idx,
+	    case FLUSH_OP__MOVE:
+		move_entry(cache_ptr, op_ptr->type, op_ptr->idx,
 			     op_ptr->flag);
 		break;
 
@@ -2873,9 +2873,9 @@ mark_entry_dirty(int32_t type,
 
 
 /*-------------------------------------------------------------------------
- * Function:	rename_entry()
+ * Function:	move_entry()
  *
- * Purpose:	Rename the entry indicated by the type and index to its
+ * Purpose:	move the entry indicated by the type and index to its
  *		main or alternate address as indicated.  If the entry is
  *		already at the desired entry, do nothing.
  *
@@ -2888,7 +2888,7 @@ mark_entry_dirty(int32_t type,
  */
 
 void
-rename_entry(H5C_t * cache_ptr,
+move_entry(H5C_t * cache_ptr,
              int32_t type,
              int32_t idx,
              hbool_t main_addr)
@@ -2917,7 +2917,7 @@ rename_entry(H5C_t * cache_ptr,
 
     if ( entry_ptr->at_main_addr && !main_addr ) {
 
-        /* rename to alt addr */
+        /* move to alt addr */
 
         HDassert( entry_ptr->addr == entry_ptr->main_addr );
 
@@ -2927,7 +2927,7 @@ rename_entry(H5C_t * cache_ptr,
 
     } else if ( !(entry_ptr->at_main_addr) && main_addr ) {
 
-        /* rename to main addr */
+        /* move to main addr */
 
         HDassert( entry_ptr->addr == entry_ptr->alt_addr );
 
@@ -2940,7 +2940,7 @@ rename_entry(H5C_t * cache_ptr,
 
         entry_ptr->is_dirty = TRUE;
 
-        result = H5C_rename_entry(cache_ptr, &(types[type]),
+        result = H5C_move_entry(cache_ptr, &(types[type]),
                                   old_addr, new_addr);
     }
 
@@ -2951,7 +2951,7 @@ rename_entry(H5C_t * cache_ptr,
 	       ( entry_ptr->header.addr != new_addr ) ) ) {
 
             pass = FALSE;
-            failure_mssg = "error in H5C_rename_entry().";
+            failure_mssg = "error in H5C_move_entry().";
 
         } else {
 
@@ -2967,7 +2967,7 @@ rename_entry(H5C_t * cache_ptr,
 
     return;
 
-} /* rename_entry() */
+} /* move_entry() */
 
 
 /*-------------------------------------------------------------------------
@@ -3499,7 +3499,7 @@ unprotect_entry_with_size_change(H5F_t * file_ptr,
 /*-------------------------------------------------------------------------
  * Function:	row_major_scan_forward()
  *
- * Purpose:	Do a sequence of inserts, protects, unprotects, renames,
+ * Purpose:	Do a sequence of inserts, protects, unprotects, moves,
  *		destroys while scanning through the set of entries.  If
  *		pass is false on entry, do nothing.
  *
@@ -3520,8 +3520,8 @@ row_major_scan_forward(H5F_t * file_ptr,
                        hbool_t display_detailed_stats,
                        hbool_t do_inserts,
                        hbool_t dirty_inserts,
-                       hbool_t do_renames,
-                       hbool_t rename_to_main_addr,
+                       hbool_t do_moves,
+                       hbool_t move_to_main_addr,
                        hbool_t do_destroys,
 		       hbool_t do_mult_ro_protects,
                        int dirty_destroys,
@@ -3595,12 +3595,12 @@ row_major_scan_forward(H5F_t * file_ptr,
             }
 
 
-            if ( ( pass ) && ( do_renames ) && ( (idx + lag - 2) >= 0 ) &&
+            if ( ( pass ) && ( do_moves ) && ( (idx + lag - 2) >= 0 ) &&
                  ( (idx + lag - 2) <= max_indices[type] ) &&
                  ( ( (idx + lag - 2) % 3 ) == 0 ) ) {
 
-                rename_entry(cache_ptr, type, (idx + lag - 2),
-                             rename_to_main_addr);
+                move_entry(cache_ptr, type, (idx + lag - 2),
+                             move_to_main_addr);
             }
 
 
@@ -3919,7 +3919,7 @@ hl_row_major_scan_forward(H5F_t * file_ptr,
 /*-------------------------------------------------------------------------
  * Function:	row_major_scan_backward()
  *
- * Purpose:	Do a sequence of inserts, protects, unprotects, renames,
+ * Purpose:	Do a sequence of inserts, protects, unprotects, moves,
  *		destroys while scanning backwards through the set of
  *		entries.  If pass is false on entry, do nothing.
  *
@@ -3940,8 +3940,8 @@ row_major_scan_backward(H5F_t * file_ptr,
                         hbool_t display_detailed_stats,
                         hbool_t do_inserts,
                         hbool_t dirty_inserts,
-                        hbool_t do_renames,
-                        hbool_t rename_to_main_addr,
+                        hbool_t do_moves,
+                        hbool_t move_to_main_addr,
                         hbool_t do_destroys,
 			hbool_t do_mult_ro_protects,
                         int dirty_destroys,
@@ -4009,12 +4009,12 @@ row_major_scan_backward(H5F_t * file_ptr,
             }
 
 
-            if ( ( pass ) && ( do_renames ) && ( (idx - lag + 2) >= 0 ) &&
+            if ( ( pass ) && ( do_moves ) && ( (idx - lag + 2) >= 0 ) &&
                  ( (idx - lag + 2) <= max_indices[type] ) &&
                  ( ( (idx - lag + 2) % 3 ) == 0 ) ) {
 
-                rename_entry(cache_ptr, type, (idx - lag + 2),
-                             rename_to_main_addr);
+                move_entry(cache_ptr, type, (idx - lag + 2),
+                             move_to_main_addr);
             }
 
 
diff --git a/test/cache_common.h b/test/cache_common.h
index ca651bf..c04d685 100644
--- a/test/cache_common.h
+++ b/test/cache_common.h
@@ -131,7 +131,7 @@
 #define FLUSH_OP__NO_OP		0
 #define FLUSH_OP__DIRTY		1
 #define FLUSH_OP__RESIZE	2
-#define FLUSH_OP__RENAME	3
+#define FLUSH_OP__MOVE		3
 #define FLUSH_OP__MAX_OP	3
 
 #define MAX_FLUSH_OPS		10	/* Maximum number of flush operations
@@ -148,7 +148,7 @@ typedef struct flush_op
 					 *   FLUSH_OP__NO_OP
 					 *   FLUSH_OP__DIRTY
 					 *   FLUSH_OP__RESIZE
-					 *   FLUSH_OP__RENAME
+					 *   FLUSH_OP__MOVE
 					 */
     int			type;		/* type code of the cache entry that
 					 * is the target of the operation.
@@ -180,12 +180,12 @@ typedef struct flush_op
 					 *   H5C_mark_entry_dirty()
 					 *   call.
 					 *
-					 * FLUSH_OP__RENAME: TRUE iff the
-					 *    target is to be renamed to
+					 * FLUSH_OP__MOVE: TRUE iff the
+					 *    target is to be moved to
 					 *    its main address.
 					 */
     size_t		size;		/* New target size in the
-					 * FLUSH_OP__RENAME operation.
+					 * FLUSH_OP__MOVE operation.
 					 * Unused elsewhere.
 					 */
 } flush_op;
@@ -213,7 +213,7 @@ typedef struct test_entry_t
     haddr_t		  main_addr;    /* initial location of the entry
                                          */
     haddr_t		  alt_addr;	/* location to which the entry
-					 * can be relocated or "renamed"
+					 * can be relocated or "moved"
                                          */
     size_t		  size;         /* how big the cache thinks this
                                          * entry is
@@ -451,7 +451,7 @@ struct fo_flush_cache_test_spec
     hbool_t			expected_destroyed;
 };
 
-struct rename_entry_test_spec
+struct move_entry_test_spec
 {
     int			entry_type;
     int			entry_index;
@@ -624,7 +624,7 @@ void insert_entry(H5F_t * file_ptr,
 void mark_entry_dirty(int32_t type,
 		              int32_t idx);
 
-void rename_entry(H5C_t * cache_ptr,
+void move_entry(H5C_t * cache_ptr,
                   int32_t type,
                   int32_t idx,
                   hbool_t main_addr);
@@ -670,8 +670,8 @@ void row_major_scan_forward(H5F_t * file_ptr,
                             hbool_t display_detailed_stats,
                             hbool_t do_inserts,
                             hbool_t dirty_inserts,
-                            hbool_t do_renames,
-                            hbool_t rename_to_main_addr,
+                            hbool_t do_moves,
+                            hbool_t move_to_main_addr,
                             hbool_t do_destroys,
                             hbool_t do_mult_ro_protects,
                             int dirty_destroys,
@@ -694,8 +694,8 @@ void row_major_scan_backward(H5F_t * file_ptr,
                              hbool_t display_detailed_stats,
                              hbool_t do_inserts,
                              hbool_t dirty_inserts,
-                             hbool_t do_renames,
-                             hbool_t rename_to_main_addr,
+                             hbool_t do_moves,
+                             hbool_t move_to_main_addr,
                              hbool_t do_destroys,
                              hbool_t do_mult_ro_protects,
                              int dirty_destroys,