Renaming some check* macros with more accurate names, making remaining check* macros similar in function.

Copied from Perforce
 Change: 179155
 ServerID: perforce.ravenbrook.com

21 files changed, 128 insertions, 134 deletions

diff --git a/mps/code/arena.c b/mps/code/arena.c
index 704d13f60db..c3fe88ebf19 100644
--- a/mps/code/arena.c
+++ b/mps/code/arena.c
@@ -26,7 +26,7 @@ static void ArenaTrivCompact(Arena arena, Trace trace);
 
 static Res ArenaTrivDescribe(Arena arena, mps_lib_FILE *stream)
 {
-  if (!CHECKT(Arena, arena)) return ResFAIL;
+  if (!TESTT(Arena, arena)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   /* .describe.triv.never-called-from-subclass-method:
@@ -324,7 +324,7 @@ Res ArenaDescribe(Arena arena, mps_lib_FILE *stream)
   Res res;
   Size reserved;
 
-  if (!CHECKT(Arena, arena)) return ResFAIL;
+  if (!TESTT(Arena, arena)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream, "Arena $P {\n", (WriteFP)arena,
@@ -396,7 +396,7 @@ Res ArenaDescribeTracts(Arena arena, mps_lib_FILE *stream)
   Addr oldLimit, base, limit;
   Size size;
 
-  if (!CHECKT(Arena, arena)) return ResFAIL;
+  if (!TESTT(Arena, arena)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   b = TractFirst(&tract, arena);
@@ -481,7 +481,7 @@ Res ControlDescribe(Arena arena, mps_lib_FILE *stream)
 {
   Res res;
 
-  if (!CHECKT(Arena, arena)) return ResFAIL;
+  if (!TESTT(Arena, arena)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = PoolDescribe(ArenaControlPool(arena), stream);
diff --git a/mps/code/arenavm.c b/mps/code/arenavm.c
index 81caf8bead5..87d7a797d37 100644
--- a/mps/code/arenavm.c
+++ b/mps/code/arenavm.c
@@ -202,10 +202,10 @@ static Res VMArenaDescribe(Arena arena, mps_lib_FILE *stream)
   VMArena vmArena;
   Index gen;
 
-  if (!CHECKT(Arena, arena)) return ResFAIL;
+  if (!TESTT(Arena, arena)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
   vmArena = Arena2VMArena(arena);
-  if (!CHECKT(VMArena, vmArena)) return ResFAIL;
+  if (!TESTT(VMArena, vmArena)) return ResFAIL;
 
   /* Describe the superclass fields first via next-method call */
   /* ...but the next method is ArenaTrivDescribe, so don't call it;
diff --git a/mps/code/buffer.c b/mps/code/buffer.c
index d8346c49e9c..9b7748c6572 100644
--- a/mps/code/buffer.c
+++ b/mps/code/buffer.c
@@ -149,7 +149,7 @@ Res BufferDescribe(Buffer buffer, mps_lib_FILE *stream)
   Res res;
   char abzMode[5];
 
-  if (!CHECKT(Buffer, buffer)) return ResFAIL;
+  if (!TESTT(Buffer, buffer)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   abzMode[0] = (char)( (buffer->mode & BufferModeTRANSITION)  ? 't' : '_' );
@@ -1185,7 +1185,7 @@ static void bufferNoReassignSeg (Buffer buffer, Seg seg)
 
 static Res bufferTrivDescribe(Buffer buffer, mps_lib_FILE *stream)
 {
-  if (!CHECKT(Buffer, buffer)) return ResFAIL;
+  if (!TESTT(Buffer, buffer)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
   /* dispatching function does it all */
   return ResOK;
@@ -1444,10 +1444,10 @@ static Res segBufDescribe(Buffer buffer, mps_lib_FILE *stream)
   BufferClass super;
   Res res;
 
-  if (!CHECKT(Buffer, buffer)) return ResFAIL;
+  if (!TESTT(Buffer, buffer)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
   segbuf = BufferSegBuf(buffer);
-  if (!CHECKT(SegBuf, segbuf)) return ResFAIL;
+  if (!TESTT(SegBuf, segbuf)) return ResFAIL;
 
   /* Describe the superclass fields first via next-method call */
   super = BUFFER_SUPERCLASS(SegBufClass);
diff --git a/mps/code/cbs.c b/mps/code/cbs.c
index e3f5204e03e..df1a359e59a 100644
--- a/mps/code/cbs.c
+++ b/mps/code/cbs.c
@@ -1627,7 +1627,7 @@ Res CBSDescribe(CBS cbs, mps_lib_FILE *stream)
 {
   Res res;
 
-  if (!CHECKT(CBS, cbs)) return ResFAIL;
+  if (!TESTT(CBS, cbs)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
diff --git a/mps/code/check.h b/mps/code/check.h
index 78334f8d7d3..c43dcc1c3d2 100644
--- a/mps/code/check.h
+++ b/mps/code/check.h
@@ -155,16 +155,13 @@ enum {
 #endif
 
 
-/* CHECKT -- check type simply
+/* TESTT -- check type simply
  *
  * Must be thread safe.  See <design/interface-c/#thread-safety>
  * and <design/interface-c/#check.space>.
- *
- * @@@@ This is a test, not a CHECK macro -- it does not assert.
- * It should be renamed TESTSIG.  RHSK 2006-12-13.
  */
 
-#define CHECKT(type, val)       ((val) != NULL && (val)->sig == type ## Sig)
+#define TESTT(type, val)       ((val) != NULL && (val)->sig == type ## Sig)
 
 
 /* CHECKS -- Check Signature
@@ -173,10 +170,10 @@ enum {
  */
 
 #if defined(AVER_AND_CHECK_NONE)
-#define CHECKS(type, val)       DISCARD(CHECKT(type, val))
+#define CHECKS(type, val)       DISCARD(TESTT(type, val))
 #else
 #define CHECKS(type, val) \
-  ASSERT(CHECKT(type, val), "SigCheck " #type ": " #val)
+  ASSERT(TESTT(type, val), "SigCheck " #type ": " #val)
 #endif
 
 
@@ -272,43 +269,40 @@ enum {
    too minimal?  How much do we rely on check methods? */
 
 #define CHECKL(cond)            DISCARD(cond)
-#define CHECKD(type, val)       DISCARD(CHECKT(type, val))
+#define CHECKD(type, val)       DISCARD(TESTT(type, val))
 #define CHECKD_NOSIG(type, val) DISCARD((val) != NULL)
-#define CHECKU(type, val)       DISCARD(CHECKT(type, val))
+#define CHECKU(type, val)       DISCARD(TESTT(type, val))
 #define CHECKU_NOSIG(type, val) DISCARD((val) != NULL)
 
 #endif /* AVER_AND_CHECK_ALL */
 
 
-/* CHECKLVALUE &c -- type compatibility checking
+/* COMPAT* -- type compatibility checking
  *
- * .check.macros: The CHECK* macros use some C trickery to attempt to
+ * .check.macros: The COMPAT* macros use some C trickery to attempt to
  * verify that certain types and fields are equivalent.  They do not
  * do a complete job.  This trickery is justified by the security gained
  * in knowing that <code/mps.h> matches the MPM.  See also
  * mail.richard.1996-08-07.09-49.  [This paragraph is intended to
  * satisfy rule.impl.trick.]
- *
- * @@@@ These are tests, not CHECK macros -- they do not assert.
- * They should be renamed TESTTYPE etc.  RHSK 2006-12-13.
  */
 
 /* compile-time check */
-#define CHECKLVALUE(lv1, lv2) \
+#define COMPATLVALUE(lv1, lv2) \
   ((void)sizeof((lv1) = (lv2)), (void)sizeof((lv2) = (lv1)), TRUE)
 
 /* aims to test whether t1 and t2 are assignment-compatible */
-#define CHECKTYPE(t1, t2) \
+#define COMPATTYPE(t1, t2) \
   (sizeof(t1) == sizeof(t2) && \
-   CHECKLVALUE(*((t1 *)0), *((t2 *)0)))
+   COMPATLVALUE(*((t1 *)0), *((t2 *)0)))
 
-#define CHECKFIELDAPPROX(s1, f1, s2, f2) \
+#define COMPATFIELDAPPROX(s1, f1, s2, f2) \
   (sizeof(((s1 *)0)->f1) == sizeof(((s2 *)0)->f2) && \
    offsetof(s1, f1) == offsetof(s2, f2))
 
-#define CHECKFIELD(s1, f1, s2, f2) \
-  (CHECKFIELDAPPROX(s1, f1, s2, f2) && \
-   CHECKLVALUE(((s1 *)0)->f1, ((s2 *)0)->f2))
+#define COMPATFIELD(s1, f1, s2, f2) \
+  (COMPATFIELDAPPROX(s1, f1, s2, f2) && \
+   COMPATLVALUE(((s1 *)0)->f1, ((s2 *)0)->f2))
 
 
 #endif /* check_h */
diff --git a/mps/code/dbgpool.c b/mps/code/dbgpool.c
index 79d14a77727..765372fae64 100644
--- a/mps/code/dbgpool.c
+++ b/mps/code/dbgpool.c
@@ -72,7 +72,7 @@ Bool PoolDebugMixinCheck(PoolDebugMixin debug)
     CHECKL(TagInitMethodCheck(debug->tagInit));
     /* Nothing to check about tagSize */
     CHECKD(Pool, debug->tagPool);
-    CHECKL(CHECKTYPE(Addr, void*)); /* tagPool relies on this */
+    CHECKL(COMPATTYPE(Addr, void*)); /* tagPool relies on this */
     /* Nothing to check about missingTags */
     CHECKL(SplayTreeCheck(&debug->index));
   }
diff --git a/mps/code/dbgpooli.c b/mps/code/dbgpooli.c
index 52b6e7d3916..ebc8733e3c2 100644
--- a/mps/code/dbgpooli.c
+++ b/mps/code/dbgpooli.c
@@ -21,8 +21,8 @@ void mps_pool_check_fenceposts(mps_pool_t mps_pool)
   Pool pool = (Pool)mps_pool;
   Arena arena;
   
-  /* CHECKT not AVERT, see <design/interface-c/#check.space */
-  AVER(CHECKT(Pool, pool));
+  /* TESTT not AVERT, see <design/interface-c/#check.space */
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -41,8 +41,8 @@ void mps_pool_check_free_space(mps_pool_t mps_pool)
   Pool pool = (Pool)mps_pool;
   Arena arena;
   
-  /* CHECKT not AVERT, see <design/interface-c/#check.space */
-  AVER(CHECKT(Pool, pool));
+  /* TESTT not AVERT, see <design/interface-c/#check.space */
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
diff --git a/mps/code/eventpro.c b/mps/code/eventpro.c
index 5655d35171b..16cbf41d3c9 100644
--- a/mps/code/eventpro.c
+++ b/mps/code/eventpro.c
@@ -356,20 +356,20 @@ void EventDestroy(EventProc proc, Event event)
 
 /* Checking macros, copied from check.h */
 
-#define CHECKLVALUE(lv1, lv2) \
+#define COMPATLVALUE(lv1, lv2) \
   ((void)sizeof((lv1) = (lv2)), (void)sizeof((lv2) = (lv1)), TRUE)
 
-#define CHECKTYPE(t1, t2) \
+#define COMPATTYPE(t1, t2) \
   (sizeof(t1) == sizeof(t2) && \
-   CHECKLVALUE(*((t1 *)0), *((t2 *)0)))
+   COMPATLVALUE(*((t1 *)0), *((t2 *)0)))
 
-#define CHECKFIELDAPPROX(s1, f1, s2, f2) \
+#define COMPATFIELDAPPROX(s1, f1, s2, f2) \
   (sizeof(((s1 *)0)->f1) == sizeof(((s2 *)0)->f2) && \
    offsetof(s1, f1) == offsetof(s2, f2))
 
-#define CHECKFIELD(s1, f1, s2, f2) \
-  (CHECKFIELDAPPROX(s1, f1, s2, f2) && \
-   CHECKLVALUE(((s1 *)0)->f1, ((s2 *)0)->f2))
+#define COMPATFIELD(s1, f1, s2, f2) \
+  (COMPATFIELDAPPROX(s1, f1, s2, f2) && \
+   COMPATLVALUE(((s1 *)0)->f1, ((s2 *)0)->f2))
 
 
 /* EventProcCreate -- initialize the module */
@@ -383,8 +383,8 @@ Res EventProcCreate(EventProc *procReturn, Bool partial,
   if (proc == NULL) return ResMEMORY;
 
   /* check event struct access */
-  assert(CHECKFIELD(EventUnion, any.code, EventWSStruct, code));
-  assert(CHECKFIELD(EventUnion, any.clock, EventWSStruct, clock));
+  assert(COMPATFIELD(EventUnion, any.code, EventWSStruct, code));
+  assert(COMPATFIELD(EventUnion, any.clock, EventWSStruct, clock));
   /* check use of labelTable */
 #if !defined(MPS_OS_FR)
   /* GCC -ansi -pedantic -Werror on FreeBSD will fail here
diff --git a/mps/code/eventrep.c b/mps/code/eventrep.c
index 7bbf2828eb2..75437f532b4 100644
--- a/mps/code/eventrep.c
+++ b/mps/code/eventrep.c
@@ -682,12 +682,12 @@ void EventReplay(Event event, Word etime)
 
 /* Checking macros, copied from check.h */
 
-#define CHECKLVALUE(lv1, lv2) \
+#define COMPATLVALUE(lv1, lv2) \
   ((void)sizeof((lv1) = (lv2)), (void)sizeof((lv2) = (lv1)), TRUE)
 
-#define CHECKTYPE(t1, t2) \
+#define COMPATTYPE(t1, t2) \
   (sizeof(t1) == sizeof(t2) && \
-   CHECKLVALUE(*((t1 *)0), *((t2 *)0)))
+   COMPATLVALUE(*((t1 *)0), *((t2 *)0)))
 
 
 /* CHECKCONV -- check t2 can be cast to t1 without loss */
@@ -705,8 +705,8 @@ Res EventRepInit(Bool partial)
   /* Check using pointers as keys in the tables. */
   verify(CHECKCONV(Word, void *));
   /* Check storage of MPS opaque handles in the tables. */
-  verify(CHECKTYPE(mps_arena_t, void *));
-  verify(CHECKTYPE(mps_ap_t, void *));
+  verify(COMPATTYPE(mps_arena_t, void *));
+  verify(COMPATTYPE(mps_ap_t, void *));
   /* .event-conv: Conversion of event fields into the types required */
   /* by the MPS functions is justified by the reverse conversion */
   /* being acceptable (which is upto the event log generator). */
diff --git a/mps/code/global.c b/mps/code/global.c
index ede40309f4a..806da8dfbaa 100644
--- a/mps/code/global.c
+++ b/mps/code/global.c
@@ -484,7 +484,7 @@ void arenaEnterLock(Arena arena, int recursive)
   /* This check is safe to do outside the lock.  Unless the client
      is also calling ArenaDestroy, but that's a protocol violation by
      the client if so. */
-  AVER(CHECKT(Arena, arena));
+  AVER(TESTT(Arena, arena));
 
   StackProbe(StackProbeDEPTH);
   lock = ArenaGlobals(arena)->lock;
@@ -946,7 +946,7 @@ Res GlobalsDescribe(Globals arenaGlobals, mps_lib_FILE *stream)
   Ring node, nextNode;
   Index i;
 
-  if (!CHECKT(Globals, arenaGlobals)) return ResFAIL;
+  if (!TESTT(Globals, arenaGlobals)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   arena = GlobalsArena(arenaGlobals);
diff --git a/mps/code/mpsi.c b/mps/code/mpsi.c
index 3a356f5d50a..06b2e50cc15 100644
--- a/mps/code/mpsi.c
+++ b/mps/code/mpsi.c
@@ -73,7 +73,7 @@ static Bool mpsi_check(void)
   /* .check.rc: Check that external and internal result codes match. */
   /* See <code/mps.h#result-codes> and <code/mpmtypes.h#result-codes>. */
   /* Also see .check.enum.cast. */
-  CHECKL(CHECKTYPE(mps_res_t, Res));
+  CHECKL(COMPATTYPE(mps_res_t, Res));
   CHECKL((int)MPS_RES_OK == (int)ResOK);
   CHECKL((int)MPS_RES_FAIL == (int)ResFAIL);
   CHECKL((int)MPS_RES_RESOURCE == (int)ResRESOURCE);
@@ -86,7 +86,7 @@ static Bool mpsi_check(void)
   /* Check that external and internal rank numbers match. */
   /* See <code/mps.h#ranks> and <code/mpmtypes.h#ranks>. */
   /* Also see .check.enum.cast. */
-  CHECKL(CHECKTYPE(mps_rank_t, Rank));
+  CHECKL(COMPATTYPE(mps_rank_t, Rank));
   CHECKL((int)MPS_RANK_AMBIG == (int)RankAMBIG);
   CHECKL((int)MPS_RANK_EXACT == (int)RankEXACT);
   CHECKL((int)MPS_RANK_WEAK == (int)RankWEAK);
@@ -95,7 +95,7 @@ static Bool mpsi_check(void)
   /* See <code/mps.h#message.types> and */
   /* <code/mpmtypes.h#message.types>. */
   /* Also see .check.enum.cast. */
-  CHECKL(CHECKTYPE(mps_message_type_t, MessageType));
+  CHECKL(COMPATTYPE(mps_message_type_t, MessageType));
   CHECKL((int)MessageTypeFINALIZATION
          == (int)MPS_MESSAGE_TYPE_FINALIZATION);
   CHECKL((int)MessageTypeGC
@@ -106,74 +106,74 @@ static Bool mpsi_check(void)
   /* The external idea of a word width and the internal one */
   /* had better match.  See <design/interface-c/#cons>. */
   CHECKL(sizeof(mps_word_t) == sizeof(void *));
-  CHECKL(CHECKTYPE(mps_word_t, Word));
+  CHECKL(COMPATTYPE(mps_word_t, Word));
 
   /* The external idea of an address and the internal one */
   /* had better match. */
-  CHECKL(CHECKTYPE(mps_addr_t, Addr));
+  CHECKL(COMPATTYPE(mps_addr_t, Addr));
 
   /* The external idea of size and the internal one had */
   /* better match.  See <design/interface-c/#cons.size> */
   /* and <design/interface-c/#pun.size>. */
-  CHECKL(CHECKTYPE(size_t, Size));
+  CHECKL(COMPATTYPE(size_t, Size));
 
   /* Clock values are passed from external to internal and back */
   /* out to external. */
-  CHECKL(CHECKTYPE(mps_clock_t, Clock));
+  CHECKL(COMPATTYPE(mps_clock_t, Clock));
 
   /* Check ap_s/APStruct compatibility by hand */
   /* .check.ap: See <code/mps.h#ap> and <code/buffer.h#ap>. */
   CHECKL(sizeof(mps_ap_s) == sizeof(APStruct));
-  CHECKL(CHECKFIELD(mps_ap_s, init,  APStruct, init));
-  CHECKL(CHECKFIELD(mps_ap_s, alloc, APStruct, alloc));
-  CHECKL(CHECKFIELD(mps_ap_s, limit, APStruct, limit));
+  CHECKL(COMPATFIELD(mps_ap_s, init,  APStruct, init));
+  CHECKL(COMPATFIELD(mps_ap_s, alloc, APStruct, alloc));
+  CHECKL(COMPATFIELD(mps_ap_s, limit, APStruct, limit));
 
   /* Check sac_s/ExternalSACStruct compatibility by hand */
   /* See <code/mps.h#sac> and <code/sac.h#sac>. */
   CHECKL(sizeof(mps_sac_s) == sizeof(ExternalSACStruct));
-  CHECKL(CHECKFIELD(mps_sac_s, mps_middle, ExternalSACStruct, middle));
-  CHECKL(CHECKFIELD(mps_sac_s, mps_trapped,
+  CHECKL(COMPATFIELD(mps_sac_s, mps_middle, ExternalSACStruct, middle));
+  CHECKL(COMPATFIELD(mps_sac_s, mps_trapped,
                     ExternalSACStruct, trapped));
-  CHECKL(CHECKFIELDAPPROX(mps_sac_s, mps_freelists,
+  CHECKL(COMPATFIELDAPPROX(mps_sac_s, mps_freelists,
                           ExternalSACStruct, freelists));
   CHECKL(sizeof(mps_sac_freelist_block_s)
          == sizeof(SACFreeListBlockStruct));
-  CHECKL(CHECKFIELD(mps_sac_freelist_block_s, mps_size,
+  CHECKL(COMPATFIELD(mps_sac_freelist_block_s, mps_size,
                     SACFreeListBlockStruct, size));
-  CHECKL(CHECKFIELD(mps_sac_freelist_block_s, mps_count,
+  CHECKL(COMPATFIELD(mps_sac_freelist_block_s, mps_count,
                     SACFreeListBlockStruct, count));
-  CHECKL(CHECKFIELD(mps_sac_freelist_block_s, mps_count_max,
+  CHECKL(COMPATFIELD(mps_sac_freelist_block_s, mps_count_max,
                     SACFreeListBlockStruct, countMax));
-  CHECKL(CHECKFIELD(mps_sac_freelist_block_s, mps_blocks,
+  CHECKL(COMPATFIELD(mps_sac_freelist_block_s, mps_blocks,
                     SACFreeListBlockStruct, blocks));
 
   /* Check sac_classes_s/SACClassesStruct compatibility by hand */
   /* See <code/mps.h#sacc> and <code/sac.h#sacc>. */
   CHECKL(sizeof(mps_sac_classes_s) == sizeof(SACClassesStruct));
-  CHECKL(CHECKFIELD(mps_sac_classes_s, mps_block_size,
+  CHECKL(COMPATFIELD(mps_sac_classes_s, mps_block_size,
                     SACClassesStruct, blockSize));
-  CHECKL(CHECKFIELD(mps_sac_classes_s, mps_cached_count,
+  CHECKL(COMPATFIELD(mps_sac_classes_s, mps_cached_count,
                     SACClassesStruct, cachedCount));
-  CHECKL(CHECKFIELD(mps_sac_classes_s, mps_frequency,
+  CHECKL(COMPATFIELD(mps_sac_classes_s, mps_frequency,
                     SACClassesStruct, frequency));
 
   /* Check ss_s/ScanStateStruct compatibility by hand */
   /* .check.ss: See <code/mps.h#ss> and <code/mpmst.h#ss>. */
   /* Note that the size of the mps_ss_s and ScanStateStruct */
-  /* are not equal.  See <code/mpmst.h#ss>.  CHECKFIELDAPPROX */
+  /* are not equal.  See <code/mpmst.h#ss>.  COMPATFIELDAPPROX */
   /* is used on the fix field because its type is punned and */
   /* therefore isn't exactly checkable.  See */
   /* <design/interface-c/#pun.addr>. */
-  CHECKL(CHECKFIELDAPPROX(mps_ss_s, fix, ScanStateStruct, fix));
-  CHECKL(CHECKFIELD(mps_ss_s, w0, ScanStateStruct, zoneShift));
-  CHECKL(CHECKFIELD(mps_ss_s, w1, ScanStateStruct, white));
-  CHECKL(CHECKFIELD(mps_ss_s, w2, ScanStateStruct, unfixedSummary));
+  CHECKL(COMPATFIELDAPPROX(mps_ss_s, fix, ScanStateStruct, fix));
+  CHECKL(COMPATFIELD(mps_ss_s, w0, ScanStateStruct, zoneShift));
+  CHECKL(COMPATFIELD(mps_ss_s, w1, ScanStateStruct, white));
+  CHECKL(COMPATFIELD(mps_ss_s, w2, ScanStateStruct, unfixedSummary));
 
   /* Check ld_s/LDStruct compatibility by hand */
   /* .check.ld: See also <code/mpmst.h#ld.struct> and <code/mps.h#ld> */
   CHECKL(sizeof(mps_ld_s) == sizeof(LDStruct));
-  CHECKL(CHECKFIELD(mps_ld_s, w0, LDStruct, epoch));
-  CHECKL(CHECKFIELD(mps_ld_s, w1, LDStruct, rs));
+  CHECKL(COMPATFIELD(mps_ld_s, w0, LDStruct, epoch));
+  CHECKL(COMPATFIELD(mps_ld_s, w1, LDStruct, rs));
 
   return TRUE;
 }
@@ -726,7 +726,7 @@ void mps_fmt_destroy(mps_fmt_t mps_fmt)
   Format format = (Format)mps_fmt;
   Arena arena;
 
-  AVER(CHECKT(Format, format));
+  AVER(TESTT(Format, format));
   arena = FormatArena(format);
 
   ArenaEnter(arena);
@@ -776,7 +776,7 @@ void mps_pool_destroy(mps_pool_t mps_pool)
   Pool pool = (Pool)mps_pool;
   Arena arena;
 
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -794,7 +794,7 @@ mps_res_t mps_alloc(mps_addr_t *p_o, mps_pool_t mps_pool, size_t size, ...)
   Addr p;
   Res res;
 
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -836,7 +836,7 @@ void mps_free(mps_pool_t mps_pool, mps_addr_t p, size_t size)
   Pool pool = (Pool)mps_pool;
   Arena arena;
 
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -864,7 +864,7 @@ mps_res_t mps_ap_create(mps_ap_t *mps_ap_o, mps_pool_t mps_pool, ...)
   va_list args;
 
   AVER(mps_ap_o != NULL);
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -897,7 +897,7 @@ mps_res_t mps_ap_create_v(mps_ap_t *mps_ap_o, mps_pool_t mps_pool,
   Res res;
 
   AVER(mps_ap_o != NULL);
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -921,7 +921,7 @@ void mps_ap_destroy(mps_ap_t mps_ap)
   Arena arena;
 
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
   arena = BufferArena(buf);
 
   ArenaEnter(arena);
@@ -945,7 +945,7 @@ mps_res_t (mps_reserve)(mps_addr_t *p_o, mps_ap_t mps_ap, size_t size)
 
   AVER(p_o != NULL);
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, BufferOfAP((AP)mps_ap)));
+  AVER(TESTT(Buffer, BufferOfAP((AP)mps_ap)));
   AVER(mps_ap->init == mps_ap->alloc);
   AVER(size > 0);
 
@@ -964,7 +964,7 @@ mps_res_t mps_reserve_with_reservoir_permit(mps_addr_t *p_o,
   AVER(p_o != NULL);
   AVER(size > 0);
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, BufferOfAP((AP)mps_ap)));
+  AVER(TESTT(Buffer, BufferOfAP((AP)mps_ap)));
   AVER(mps_ap->init == mps_ap->alloc);
 
   MPS_RESERVE_WITH_RESERVOIR_PERMIT_BLOCK(res, *p_o, mps_ap, size);
@@ -985,7 +985,7 @@ mps_res_t mps_reserve_with_reservoir_permit(mps_addr_t *p_o,
 mps_bool_t (mps_commit)(mps_ap_t mps_ap, mps_addr_t p, size_t size)
 {
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, BufferOfAP((AP)mps_ap)));
+  AVER(TESTT(Buffer, BufferOfAP((AP)mps_ap)));
   AVER(p != NULL);
   AVER(size > 0);
   AVER(p == mps_ap->init);
@@ -1027,7 +1027,7 @@ mps_res_t (mps_ap_frame_push)(mps_frame_t *frame_o, mps_ap_t mps_ap)
     AllocFrame frame;
     Res res;
 
-    AVER(CHECKT(Buffer, buf));
+    AVER(TESTT(Buffer, buf));
     arena = BufferArena(buf);
 
     ArenaEnter(arena);
@@ -1070,7 +1070,7 @@ mps_res_t (mps_ap_frame_pop)(mps_ap_t mps_ap, mps_frame_t frame)
     Arena arena;
     Res res;
 
-    AVER(CHECKT(Buffer, buf));
+    AVER(TESTT(Buffer, buf));
     arena = BufferArena(buf);
 
     ArenaEnter(arena);
@@ -1097,7 +1097,7 @@ mps_res_t mps_ap_fill(mps_addr_t *p_o, mps_ap_t mps_ap, size_t size)
   Res res;
 
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
   arena = BufferArena(buf);
 
   ArenaEnter(arena);
@@ -1128,7 +1128,7 @@ mps_res_t mps_ap_fill_with_reservoir_permit(mps_addr_t *p_o, mps_ap_t mps_ap,
   Res res;
 
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
   arena = BufferArena(buf);
 
   ArenaEnter(arena);
@@ -1162,7 +1162,7 @@ mps_bool_t mps_ap_trip(mps_ap_t mps_ap, mps_addr_t p, size_t size)
   Bool b;
 
   AVER(mps_ap != NULL);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
   arena = BufferArena(buf);
 
   ArenaEnter(arena);
@@ -1191,7 +1191,7 @@ mps_res_t mps_sac_create(mps_sac_t *mps_sac_o, mps_pool_t mps_pool,
   Res res;
 
   AVER(mps_sac_o != NULL);
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
 
   ArenaEnter(arena);
@@ -1214,7 +1214,7 @@ void mps_sac_destroy(mps_sac_t mps_sac)
   SAC sac = SACOfExternalSAC((ExternalSAC)mps_sac);
   Arena arena;
 
-  AVER(CHECKT(SAC, sac));
+  AVER(TESTT(SAC, sac));
   arena = SACArena(sac);
 
   ArenaEnter(arena);
@@ -1232,7 +1232,7 @@ void mps_sac_flush(mps_sac_t mps_sac)
   SAC sac = SACOfExternalSAC((ExternalSAC)mps_sac);
   Arena arena;
 
-  AVER(CHECKT(SAC, sac));
+  AVER(TESTT(SAC, sac));
   arena = SACArena(sac);
 
   ArenaEnter(arena);
@@ -1254,7 +1254,7 @@ mps_res_t mps_sac_fill(mps_addr_t *p_o, mps_sac_t mps_sac, size_t size,
   Res res;
 
   AVER(p_o != NULL);
-  AVER(CHECKT(SAC, sac));
+  AVER(TESTT(SAC, sac));
   arena = SACArena(sac);
 
   ArenaEnter(arena);
@@ -1276,7 +1276,7 @@ void mps_sac_empty(mps_sac_t mps_sac, mps_addr_t p, size_t size)
   SAC sac = SACOfExternalSAC((ExternalSAC)mps_sac);
   Arena arena;
 
-  AVER(CHECKT(SAC, sac));
+  AVER(TESTT(SAC, sac));
   arena = SACArena(sac);
 
   ArenaEnter(arena);
@@ -1295,7 +1295,7 @@ mps_res_t mps_sac_alloc(mps_addr_t *p_o, mps_sac_t mps_sac, size_t size,
   Res res;
 
   AVER(p_o != NULL);
-  AVER(CHECKT(SAC, SACOfExternalSAC((ExternalSAC)mps_sac)));
+  AVER(TESTT(SAC, SACOfExternalSAC((ExternalSAC)mps_sac)));
   AVER(size > 0);
 
   MPS_SAC_ALLOC_FAST(res, *p_o, mps_sac, size, (has_reservoir_permit != 0));
@@ -1307,7 +1307,7 @@ mps_res_t mps_sac_alloc(mps_addr_t *p_o, mps_sac_t mps_sac, size_t size,
 
 void mps_sac_free(mps_sac_t mps_sac, mps_addr_t p, size_t size)
 {
-  AVER(CHECKT(SAC, SACOfExternalSAC((ExternalSAC)mps_sac)));
+  AVER(TESTT(SAC, SACOfExternalSAC((ExternalSAC)mps_sac)));
   /* Can't check p outside arena lock */
   AVER(size > 0);
 
@@ -1940,7 +1940,7 @@ mps_res_t mps_ap_alloc_pattern_begin(mps_ap_t mps_ap,
 
   AVER(mps_ap != NULL);
   buf = BufferOfAP((AP)mps_ap);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
 
   arena = BufferArena(buf);
   ArenaEnter(arena);
@@ -1961,7 +1961,7 @@ mps_res_t mps_ap_alloc_pattern_end(mps_ap_t mps_ap,
 
   AVER(mps_ap != NULL);
   buf = BufferOfAP((AP)mps_ap);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
   UNUSED(alloc_pattern); /* .ramp.hack */
 
   arena = BufferArena(buf);
@@ -1982,7 +1982,7 @@ mps_res_t mps_ap_alloc_pattern_reset(mps_ap_t mps_ap)
 
   AVER(mps_ap != NULL);
   buf = BufferOfAP((AP)mps_ap);
-  AVER(CHECKT(Buffer, buf));
+  AVER(TESTT(Buffer, buf));
 
   arena = BufferArena(buf);
   ArenaEnter(arena);
@@ -2074,7 +2074,7 @@ void mps_chain_destroy(mps_chain_t mps_chain)
   Arena arena;
   Chain chain = (Chain)mps_chain;
 
-  AVER(CHECKT(Chain, chain));
+  AVER(TESTT(Chain, chain));
   arena = chain->arena;
 
   ArenaEnter(arena);
diff --git a/mps/code/pool.c b/mps/code/pool.c
index e2578cf3497..802acf01d6a 100644
--- a/mps/code/pool.c
+++ b/mps/code/pool.c
@@ -515,7 +515,7 @@ Res PoolDescribe(Pool pool, mps_lib_FILE *stream)
   Res res;
   Ring node, nextNode;
 
-  if (!CHECKT(Pool, pool)) return ResFAIL;
+  if (!TESTT(Pool, pool)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
  
   res = WriteF(stream,
diff --git a/mps/code/poolamc.c b/mps/code/poolamc.c
index bea60caa03e..3698f328b90 100644
--- a/mps/code/poolamc.c
+++ b/mps/code/poolamc.c
@@ -258,12 +258,12 @@ static Res AMCSegDescribe(Seg seg, mps_lib_FILE *stream)
   Size row;
   char abzSketch[5];
 
-  if(!CHECKT(Seg, seg))
+  if(!TESTT(Seg, seg))
     return ResFAIL;
   if(stream == NULL)
     return ResFAIL;
   amcseg = Seg2amcSeg(seg);
-  if(!CHECKT(amcSeg, amcseg))
+  if(!TESTT(amcSeg, amcseg))
     return ResFAIL;
 
   /* Describe the superclass fields first via next-method call */
@@ -745,7 +745,7 @@ static Res amcGenDescribe(amcGen gen, mps_lib_FILE *stream)
 {
   Res res;
 
-  if(!CHECKT(amcGen, gen))
+  if(!TESTT(amcGen, gen))
     return ResFAIL;
 
   res = WriteF(stream,
@@ -2330,10 +2330,10 @@ static Res AMCDescribe(Pool pool, mps_lib_FILE *stream)
   Ring node, nextNode;
   char *rampmode;
 
-  if(!CHECKT(Pool, pool))
+  if(!TESTT(Pool, pool))
     return ResFAIL;
   amc = Pool2AMC(pool);
-  if(!CHECKT(AMC, amc))
+  if(!TESTT(AMC, amc))
     return ResFAIL;
   if(stream == NULL)
     return ResFAIL;
@@ -2485,7 +2485,7 @@ void mps_amc_apply(mps_pool_t mps_pool,
   mps_amc_apply_closure_s closure_s;
   Arena arena;
 
-  AVER(CHECKT(Pool, pool));
+  AVER(TESTT(Pool, pool));
   arena = PoolArena(pool);
   ArenaEnter(arena);
   AVERT(Pool, pool);
diff --git a/mps/code/poolams.c b/mps/code/poolams.c
index 913195aab7c..4fbaba79b7d 100644
--- a/mps/code/poolams.c
+++ b/mps/code/poolams.c
@@ -524,10 +524,10 @@ static Res AMSSegDescribe(Seg seg, mps_lib_FILE *stream)
   Buffer buffer;               /* the segment's buffer, if it has one */
   Index i;
 
-  if (!CHECKT(Seg, seg)) return ResFAIL;
+  if (!TESTT(Seg, seg)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
   amsseg = Seg2AMSSeg(seg);
-  if (!CHECKT(AMSSeg, amsseg)) return ResFAIL;
+  if (!TESTT(AMSSeg, amsseg)) return ResFAIL;
 
   /* Describe the superclass fields first via next-method call */
   super = SEG_SUPERCLASS(AMSSegClass);
@@ -1366,7 +1366,7 @@ static Res AMSFix(Pool pool, ScanState ss, Seg seg, Ref *refIO)
   Format format;
 
   AVERT_CRITICAL(Pool, pool);
-  AVER_CRITICAL(CHECKT(AMS, Pool2AMS(pool)));
+  AVER_CRITICAL(TESTT(AMS, Pool2AMS(pool)));
   AVERT_CRITICAL(ScanState, ss);
   AVERT_CRITICAL(Seg, seg);
   AVER_CRITICAL(refIO != NULL);
@@ -1591,9 +1591,9 @@ static Res AMSDescribe(Pool pool, mps_lib_FILE *stream)
   Ring node, nextNode;
   Res res;
 
-  if (!CHECKT(Pool, pool)) return ResFAIL;
+  if (!TESTT(Pool, pool)) return ResFAIL;
   ams = Pool2AMS(pool);
-  if (!CHECKT(AMS, ams)) return ResFAIL;
+  if (!TESTT(AMS, ams)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
diff --git a/mps/code/poolmrg.c b/mps/code/poolmrg.c
index 73ec8ac81f1..6abba410f72 100644
--- a/mps/code/poolmrg.c
+++ b/mps/code/poolmrg.c
@@ -792,9 +792,9 @@ static Res MRGDescribe(Pool pool, mps_lib_FILE *stream)
   RefPart refPart;
   Res res;
 
-  if (!CHECKT(Pool, pool)) return ResFAIL;
+  if (!TESTT(Pool, pool)) return ResFAIL;
   mrg = Pool2MRG(pool);
-  if (!CHECKT(MRG, mrg)) return ResFAIL;
+  if (!TESTT(MRG, mrg)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   arena = PoolArena(pool);
diff --git a/mps/code/poolmv.c b/mps/code/poolmv.c
index ae71bb40804..a7026276008 100644
--- a/mps/code/poolmv.c
+++ b/mps/code/poolmv.c
@@ -646,9 +646,9 @@ static Res MVDescribe(Pool pool, mps_lib_FILE *stream)
   char c;
   Ring spans, node = NULL, nextNode; /* gcc whinge stop */
 
-  if(!CHECKT(Pool, pool)) return ResFAIL;
+  if(!TESTT(Pool, pool)) return ResFAIL;
   mv = Pool2MV(pool);
-  if(!CHECKT(MV, mv)) return ResFAIL;
+  if(!TESTT(MV, mv)) return ResFAIL;
   if(stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c
index 974112b7abe..b67b236d1b4 100644
--- a/mps/code/poolmv2.c
+++ b/mps/code/poolmv2.c
@@ -685,9 +685,9 @@ static Res MVTDescribe(Pool pool, mps_lib_FILE *stream)
   Res res;
   MVT mvt;
 
-  if (!CHECKT(Pool, pool)) return ResFAIL;
+  if (!TESTT(Pool, pool)) return ResFAIL;
   mvt = Pool2MVT(pool);
-  if (!CHECKT(MVT, mvt)) return ResFAIL;
+  if (!TESTT(MVT, mvt)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index f13c94893aa..1bbe1e85806 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -537,9 +537,9 @@ static Res MVFFDescribe(Pool pool, mps_lib_FILE *stream)
   Res res;
   MVFF mvff;
 
-  if (!CHECKT(Pool, pool)) return ResFAIL;
+  if (!TESTT(Pool, pool)) return ResFAIL;
   mvff = Pool2MVFF(pool);
-  if (!CHECKT(MVFF, mvff)) return ResFAIL;
+  if (!TESTT(MVFF, mvff)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
diff --git a/mps/code/root.c b/mps/code/root.c
index bd2dd21f5ea..e746d3c1b61 100644
--- a/mps/code/root.c
+++ b/mps/code/root.c
@@ -380,7 +380,7 @@ void RootDestroy(Root root)
 
 Arena RootArena(Root root)
 {
-  AVER(CHECKT(Root, root));
+  AVER(TESTT(Root, root));
   return root->arena;
 }
 
@@ -584,7 +584,7 @@ Res RootDescribe(Root root, mps_lib_FILE *stream)
 {
   Res res;
 
-  if (!CHECKT(Root, root)) return ResFAIL;
+  if (!TESTT(Root, root)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
diff --git a/mps/code/seg.c b/mps/code/seg.c
index 3f95ba4ec88..6c194881bb8 100644
--- a/mps/code/seg.c
+++ b/mps/code/seg.c
@@ -353,7 +353,7 @@ Res SegDescribe(Seg seg, mps_lib_FILE *stream)
   Res res;
   Pool pool;
 
-  if (!CHECKT(Seg, seg)) return ResFAIL;
+  if (!TESTT(Seg, seg)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   pool = SegPool(seg);
@@ -964,7 +964,7 @@ static Res segTrivDescribe(Seg seg, mps_lib_FILE *stream)
 {
   Res res;
 
-  if (!CHECKT(Seg, seg)) return ResFAIL;
+  if (!TESTT(Seg, seg)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
 
   res = WriteF(stream,
@@ -1550,10 +1550,10 @@ static Res gcSegDescribe(Seg seg, mps_lib_FILE *stream)
   SegClass super;
   GCSeg gcseg;
 
-  if (!CHECKT(Seg, seg)) return ResFAIL;
+  if (!TESTT(Seg, seg)) return ResFAIL;
   if (stream == NULL) return ResFAIL;
   gcseg = SegGCSeg(seg);
-  if (!CHECKT(GCSeg, gcseg)) return ResFAIL;
+  if (!TESTT(GCSeg, gcseg)) return ResFAIL;
 
   /* Describe the superclass fields first via next-method call */
   super = SEG_SUPERCLASS(GCSegClass);
diff --git a/mps/code/vmw3.c b/mps/code/vmw3.c
index 554209687d3..e1e05b4ab2a 100644
--- a/mps/code/vmw3.c
+++ b/mps/code/vmw3.c
@@ -103,8 +103,8 @@ Res VMCreate(VM *vmReturn, Size size)
 
   AVER(vmReturn != NULL);
 
-  AVER(CHECKTYPE(LPVOID, Addr));  /* .assume.lpvoid-addr */
-  AVER(CHECKTYPE(SIZE_T, Size));
+  AVER(COMPATTYPE(LPVOID, Addr));  /* .assume.lpvoid-addr */
+  AVER(COMPATTYPE(SIZE_T, Size));
 
   GetSystemInfo(&si);
   align = (Align)si.dwPageSize;