diff --git a/mps/code/arena.c b/mps/code/arena.c
index d270adf7499..a9dec4cd267 100644
--- a/mps/code/arena.c
+++ b/mps/code/arena.c
@@ -18,8 +18,8 @@ SRCID(arena, "$Id$");
 
 
 #define ArenaControlPool(arena) MV2Pool(&(arena)->controlPoolStruct)
-#define ArenaCBSBlockPool(arena)  (&(arena)->freeCBSBlockPoolStruct.poolStruct)
-#define ArenaFreeLand(arena) (&(arena)->freeLandStruct.landStruct)
+#define ArenaCBSBlockPool(arena) MFSPool(&(arena)->freeCBSBlockPoolStruct)
+#define ArenaFreeLand(arena) CBSLand(&(arena)->freeLandStruct)
 
 
 /* Forward declarations */
@@ -409,7 +409,7 @@ Res ControlInit(Arena arena)
   AVERT(Arena, arena);
   MPS_ARGS_BEGIN(args) {
     MPS_ARGS_ADD(args, MPS_KEY_EXTEND_BY, CONTROL_EXTEND_BY);
-    res = PoolInit(&arena->controlPoolStruct.poolStruct, arena,
+    res = PoolInit(MV2Pool(&arena->controlPoolStruct), arena,
                    PoolClassMV(), args);
   } MPS_ARGS_END(args);
   if (res != ResOK)
@@ -425,7 +425,7 @@ void ControlFinish(Arena arena)
 {
   AVERT(Arena, arena);
   arena->poolReady = FALSE;
-  PoolFinish(&arena->controlPoolStruct.poolStruct);
+  PoolFinish(MV2Pool(&arena->controlPoolStruct));
 }
 
 
diff --git a/mps/code/cbs.c b/mps/code/cbs.c
index 2cb93d1dc64..28d0ae3a6d4 100644
--- a/mps/code/cbs.c
+++ b/mps/code/cbs.c
@@ -26,7 +26,6 @@ SRCID(cbs, "$Id$");
 #define CBSBlockSize(block) AddrOffset((block)->base, (block)->limit)
 
 
-#define cbsLand(cbs) (&((cbs)->landStruct))
 #define cbsOfLand(land) PARENT(CBSStruct, landStruct, land)
 #define cbsSplay(cbs) (&((cbs)->splayTreeStruct))
 #define cbsOfSplay(_splay) PARENT(CBSStruct, splayTreeStruct, _splay)
@@ -54,7 +53,7 @@ Bool CBSCheck(CBS cbs)
   /* See .enter-leave.simple. */
   Land land;
   CHECKS(CBS, cbs);
-  land = cbsLand(cbs);
+  land = CBSLand(cbs);
   CHECKD(Land, land);
   CHECKD(SplayTree, cbsSplay(cbs));
   CHECKD(Pool, cbs->blockPool);
@@ -126,7 +125,7 @@ static Bool cbsTestNode(SplayTree splay, Tree tree,
   AVERT(Tree, tree);
   AVER(closureP == NULL);
   AVER(size > 0);
-  AVER(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSFastLandClass));
+  AVER(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSFastLandClass));
 
   block = cbsBlockOfTree(tree);
 
@@ -142,7 +141,7 @@ static Bool cbsTestTree(SplayTree splay, Tree tree,
   AVERT(Tree, tree);
   AVER(closureP == NULL);
   AVER(size > 0);
-  AVER(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSFastLandClass));
+  AVER(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSFastLandClass));
 
   block = cbsFastBlockOfTree(tree);
 
@@ -158,7 +157,7 @@ static void cbsUpdateFastNode(SplayTree splay, Tree tree)
 
   AVERT_CRITICAL(SplayTree, splay);
   AVERT_CRITICAL(Tree, tree);
-  AVER_CRITICAL(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSFastLandClass));
+  AVER_CRITICAL(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSFastLandClass));
 
   maxSize = CBSBlockSize(cbsBlockOfTree(tree));
 
@@ -189,13 +188,13 @@ static void cbsUpdateZonedNode(SplayTree splay, Tree tree)
 
   AVERT_CRITICAL(SplayTree, splay);
   AVERT_CRITICAL(Tree, tree);
-  AVER_CRITICAL(IsLandSubclass(cbsLand(cbsOfSplay(splay)), CBSZonedLandClass));
+  AVER_CRITICAL(IsLandSubclass(CBSLand(cbsOfSplay(splay)), CBSZonedLandClass));
 
   cbsUpdateFastNode(splay, tree);
 
   zonedBlock = cbsZonedBlockOfTree(tree);
   block = &zonedBlock->cbsFastBlockStruct.cbsBlockStruct;
-  arena = LandArena(cbsLand(cbsOfSplay(splay)));
+  arena = LandArena(CBSLand(cbsOfSplay(splay)));
   zones = ZoneSetOfRange(arena, CBSBlockBase(block), CBSBlockLimit(block));
 
   if (TreeHasLeft(tree))
@@ -840,7 +839,7 @@ static Bool cbsFindFirst(Range rangeReturn, Range oldRangeReturn,
   AVERT(Land, land);
   cbs = cbsOfLand(land);
   AVERT(CBS, cbs);
-  AVER(IsLandSubclass(cbsLand(cbs), CBSFastLandClass));
+  AVER(IsLandSubclass(CBSLand(cbs), CBSFastLandClass));
 
   AVER(rangeReturn != NULL);
   AVER(oldRangeReturn != NULL);
@@ -925,7 +924,7 @@ static Bool cbsFindLast(Range rangeReturn, Range oldRangeReturn,
   AVERT(Land, land);
   cbs = cbsOfLand(land);
   AVERT(CBS, cbs);
-  AVER(IsLandSubclass(cbsLand(cbs), CBSFastLandClass));
+  AVER(IsLandSubclass(CBSLand(cbs), CBSFastLandClass));
 
   AVER(rangeReturn != NULL);
   AVER(oldRangeReturn != NULL);
@@ -962,7 +961,7 @@ static Bool cbsFindLargest(Range rangeReturn, Range oldRangeReturn,
   AVERT(Land, land);
   cbs = cbsOfLand(land);
   AVERT(CBS, cbs);
-  AVER(IsLandSubclass(cbsLand(cbs), CBSFastLandClass));
+  AVER(IsLandSubclass(CBSLand(cbs), CBSFastLandClass));
 
   AVER(rangeReturn != NULL);
   AVER(oldRangeReturn != NULL);
@@ -1013,7 +1012,7 @@ static Res cbsFindInZones(Bool *foundReturn, Range rangeReturn,
   AVERT(Land, land);
   cbs = cbsOfLand(land);
   AVERT(CBS, cbs);
-  AVER(IsLandSubclass(cbsLand(cbs), CBSZonedLandClass));
+  AVER(IsLandSubclass(CBSLand(cbs), CBSZonedLandClass));
   /* AVERT(ZoneSet, zoneSet); */
   AVER(BoolCheck(high));
 
diff --git a/mps/code/cbs.h b/mps/code/cbs.h
index e6bc276f067..a1496b3f771 100644
--- a/mps/code/cbs.h
+++ b/mps/code/cbs.h
@@ -37,6 +37,7 @@ typedef struct CBSZonedBlockStruct {
 typedef struct CBSStruct *CBS;
 
 extern Bool CBSCheck(CBS cbs);
+#define CBSLand(cbs) (&(cbs)->landStruct)
 
 extern LandClass CBSLandClassGet(void);
 extern LandClass CBSFastLandClassGet(void);
diff --git a/mps/code/failover.h b/mps/code/failover.h
index 56e6149e05e..3676bade103 100644
--- a/mps/code/failover.h
+++ b/mps/code/failover.h
@@ -13,6 +13,8 @@
 
 typedef struct FailoverStruct *Failover;
 
+#define FailoverLand(fo) (&(fo)->landStruct)
+
 extern Bool FailoverCheck(Failover failover);
 
 extern LandClass FailoverLandClassGet(void);
diff --git a/mps/code/freelist.c b/mps/code/freelist.c
index 2be00189aa8..ffd21b347bc 100644
--- a/mps/code/freelist.c
+++ b/mps/code/freelist.c
@@ -14,7 +14,7 @@ SRCID(freelist, "$Id$");
 
 
 #define freelistOfLand(land) PARENT(FreelistStruct, landStruct, land)
-#define freelistAlignment(fl) LandAlignment(&(fl)->landStruct)
+#define freelistAlignment(fl) LandAlignment(FreelistLand(fl))
 
 
 typedef union FreelistBlockUnion {
@@ -178,7 +178,7 @@ Bool FreelistCheck(Freelist fl)
 {
   Land land;
   CHECKS(Freelist, fl);
-  land = &fl->landStruct;
+  land = FreelistLand(fl);
   CHECKD(Land, land);
   /* See <design/freelist/#impl.grain.align> */
   CHECKL(AlignIsAligned(freelistAlignment(fl), freelistMinimumAlignment));
diff --git a/mps/code/freelist.h b/mps/code/freelist.h
index c46ab57bc15..8e46f085626 100644
--- a/mps/code/freelist.h
+++ b/mps/code/freelist.h
@@ -13,6 +13,8 @@
 
 typedef struct FreelistStruct *Freelist;
 
+#define FreelistLand(fl) (&(fl)->landStruct)
+
 extern Bool FreelistCheck(Freelist freelist);
 
 extern LandClass FreelistLandClassGet(void);
diff --git a/mps/code/landtest.c b/mps/code/landtest.c
index af6beff29ac..78e828ad225 100644
--- a/mps/code/landtest.c
+++ b/mps/code/landtest.c
@@ -486,10 +486,10 @@ extern int main(int argc, char *argv[])
   CBSStruct cbsStruct;
   FreelistStruct flStruct;
   FailoverStruct foStruct;
-  Land cbs = &cbsStruct.landStruct;
-  Land fl = &flStruct.landStruct;
-  Land fo = &foStruct.landStruct;
-  Pool mfs = &blockPool.poolStruct;
+  Land cbs = CBSLand(&cbsStruct);
+  Land fl = FreelistLand(&flStruct);
+  Land fo = FailoverLand(&foStruct);
+  Pool mfs = MFSPool(&blockPool);
   Align align;
   int i;
 
diff --git a/mps/code/poolmfs.c b/mps/code/poolmfs.c
index c203c5697b6..18ffb1f1dec 100644
--- a/mps/code/poolmfs.c
+++ b/mps/code/poolmfs.c
@@ -60,13 +60,6 @@ typedef struct MFSHeaderStruct {
 #define UNIT_MIN        sizeof(HeaderStruct)
 
 
-Pool (MFSPool)(MFS mfs)
-{
-  AVERT(MFS, mfs);
-  return &mfs->poolStruct;
-}
-
-
 /* MFSVarargs -- decode obsolete varargs */
 
 static void MFSVarargs(ArgStruct args[MPS_ARGS_MAX], va_list varargs)
diff --git a/mps/code/poolmfs.h b/mps/code/poolmfs.h
index 5f2fd0780ed..e08682329b0 100644
--- a/mps/code/poolmfs.h
+++ b/mps/code/poolmfs.h
@@ -33,11 +33,11 @@
 
 typedef struct MFSStruct *MFS;
 
+#define MFSPool(mfs) (&(mfs)->poolStruct)
+
 extern PoolClass PoolClassMFS(void);
 
 extern Bool MFSCheck(MFS mfs);
-extern Pool (MFSPool)(MFS mfs);
-
 
 extern const struct mps_key_s _mps_key_MFSExtendSelf;
 #define MFSExtendSelf (&_mps_key_MFSExtendSelf)
diff --git a/mps/code/poolmv.c b/mps/code/poolmv.c
index 88addcd5722..d619ca1566a 100644
--- a/mps/code/poolmv.c
+++ b/mps/code/poolmv.c
@@ -252,7 +252,7 @@ static Res MVInit(Pool pool, ArgList args)
   MPS_ARGS_BEGIN(piArgs) {
     MPS_ARGS_ADD(piArgs, MPS_KEY_EXTEND_BY, blockExtendBy);
     MPS_ARGS_ADD(piArgs, MPS_KEY_MFS_UNIT_SIZE, sizeof(MVBlockStruct));
-    res = PoolInit(&mv->blockPoolStruct.poolStruct, arena, PoolClassMFS(), piArgs);
+    res = PoolInit(mvBlockPool(mv), arena, PoolClassMFS(), piArgs);
   } MPS_ARGS_END(piArgs);
   if(res != ResOK)
     return res;
@@ -262,7 +262,7 @@ static Res MVInit(Pool pool, ArgList args)
   MPS_ARGS_BEGIN(piArgs) {
     MPS_ARGS_ADD(piArgs, MPS_KEY_EXTEND_BY, spanExtendBy);
     MPS_ARGS_ADD(piArgs, MPS_KEY_MFS_UNIT_SIZE, sizeof(MVSpanStruct));
-    res = PoolInit(&mv->spanPoolStruct.poolStruct, arena, PoolClassMFS(), piArgs);
+    res = PoolInit(mvSpanPool(mv), arena, PoolClassMFS(), piArgs);
   } MPS_ARGS_END(piArgs);
   if(res != ResOK)
     return res;
@@ -304,8 +304,8 @@ static void MVFinish(Pool pool)
 
   mv->sig = SigInvalid;
 
-  PoolFinish(&mv->blockPoolStruct.poolStruct);
-  PoolFinish(&mv->spanPoolStruct.poolStruct);
+  PoolFinish(mvBlockPool(mv));
+  PoolFinish(mvSpanPool(mv));
 }
 
 
diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c
index 4dd85c184e5..c6dcb28dae2 100644
--- a/mps/code/poolmv2.c
+++ b/mps/code/poolmv2.c
@@ -167,19 +167,19 @@ static ABQ MVTABQ(MVT mvt)
 
 static Land MVTCBS(MVT mvt)
 {
-  return &mvt->cbsStruct.landStruct;
+  return CBSLand(&mvt->cbsStruct);
 }
 
 
 static Land MVTFreelist(MVT mvt)
 {
-  return &mvt->flStruct.landStruct;
+  return FreelistLand(&mvt->flStruct);
 }
 
 
 static Land MVTFailover(MVT mvt)
 {
-  return &mvt->foStruct.landStruct;
+  return FailoverLand(&mvt->foStruct);
 }
 
 
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index fd61da0d341..def8438f51f 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -65,13 +65,13 @@ typedef struct MVFFStruct {     /* MVFF pool outer structure */
 
 
 #define Pool2MVFF(pool)     PARENT(MVFFStruct, poolStruct, pool)
-#define MVFF2Pool(mvff)     (&((mvff)->poolStruct))
-#define MVFFTotalCBS(mvff)  (&((mvff)->totalCBSStruct.landStruct))
-#define MVFFFreeCBS(mvff)   (&((mvff)->freeCBSStruct.landStruct))
-#define MVFFFreelist(mvff)  (&((mvff)->flStruct.landStruct))
-#define MVFFFailover(mvff)  (&((mvff)->foStruct.landStruct))
-#define MVFFSegPref(mvff)   (&((mvff)->segPrefStruct))
-#define MVFFBlockPool(mvff) (&((mvff)->cbsBlockPoolStruct.poolStruct))
+#define MVFF2Pool(mvff)     (&(mvff)->poolStruct)
+#define MVFFTotalCBS(mvff)  CBSLand(&(mvff)->totalCBSStruct)
+#define MVFFFreeCBS(mvff)   CBSLand(&(mvff)->freeCBSStruct)
+#define MVFFFreelist(mvff)  FreelistLand(&(mvff)->flStruct)
+#define MVFFFreeLand(mvff)  FailoverLand(&(mvff)->foStruct)
+#define MVFFSegPref(mvff)   (&(mvff)->segPrefStruct)
+#define MVFFBlockPool(mvff) MFSPool(&(mvff)->cbsBlockPoolStruct)
 
 static Bool MVFFCheck(MVFF mvff);
 
@@ -125,7 +125,7 @@ static void MVFFReduce(MVFF mvff)
      stored at the root node. */
 
   freeLimit = (Size)(LandSize(MVFFTotalCBS(mvff)) * mvff->spare);
-  freeSize = LandSize(MVFFFailover(mvff));
+  freeSize = LandSize(MVFFFreeLand(mvff));
   if (freeSize < freeLimit)
     return;
 
@@ -138,7 +138,7 @@ static void MVFFReduce(MVFF mvff)
      loop will terminate */
 
   while (freeSize > targetFree
-         && LandFindLargest(&freeRange, &oldFreeRange, MVFFFailover(mvff),
+         && LandFindLargest(&freeRange, &oldFreeRange, MVFFFreeLand(mvff),
                             align, FindDeleteNONE))
   {
     RangeStruct pageRange, oldRange;
@@ -177,16 +177,16 @@ static void MVFFReduce(MVFF mvff)
        to delete from the TotalCBS we add back to the free list, which
        can't fail. */
 
-    res = LandDelete(&oldRange, MVFFFailover(mvff), &pageRange);
+    res = LandDelete(&oldRange, MVFFFreeLand(mvff), &pageRange);
     if (res != ResOK)
       break;
     freeSize -= RangeSize(&pageRange);
-    AVER(freeSize == LandSize(MVFFFailover(mvff)));
+    AVER(freeSize == LandSize(MVFFFreeLand(mvff)));
 
     res = LandDelete(&oldRange, MVFFTotalCBS(mvff), &pageRange);
     if (res != ResOK) {
       RangeStruct coalescedRange;
-      res = LandInsert(&coalescedRange, MVFFFailover(mvff), &pageRange);
+      res = LandInsert(&coalescedRange, MVFFFreeLand(mvff), &pageRange);
       AVER(res == ResOK);
       break;
     }
@@ -253,7 +253,7 @@ static Res MVFFExtend(Range rangeReturn, MVFF mvff, Size size,
   }
 
   DebugPoolFreeSplat(pool, RangeBase(&range), RangeLimit(&range));
-  res = LandInsert(rangeReturn, MVFFFailover(mvff), &range);
+  res = LandInsert(rangeReturn, MVFFFreeLand(mvff), &range);
   AVER(res == ResOK);
 
   /* Don't call MVFFReduce; that would be silly. */
@@ -287,7 +287,7 @@ static Bool MVFFFindFree(Range rangeReturn, MVFF mvff, Size size)
 
   foundBlock =
     (mvff->firstFit ? LandFindFirst : LandFindLast)
-    (rangeReturn, &oldRange, MVFFFailover(mvff), size, findDelete);
+    (rangeReturn, &oldRange, MVFFFreeLand(mvff), size, findDelete);
 
   return foundBlock;
 }
@@ -352,7 +352,7 @@ static void MVFFFree(Pool pool, Addr old, Size size)
   AVER(size > 0);
 
   RangeInitSize(&range, old, SizeAlignUp(size, PoolAlignment(pool)));
-  res = LandInsert(&coalescedRange, MVFFFailover(mvff), &range);
+  res = LandInsert(&coalescedRange, MVFFFreeLand(mvff), &range);
   AVER(res == ResOK);
   MVFFReduce(mvff);
 }
@@ -381,14 +381,14 @@ static Res MVFFBufferFill(Addr *baseReturn, Addr *limitReturn,
   AVER(SizeIsAligned(size, PoolAlignment(pool)));
   AVERT(Bool, withReservoirPermit);
 
-  found = LandFindLargest(&range, &oldRange, MVFFFailover(mvff), size,
+  found = LandFindLargest(&range, &oldRange, MVFFFreeLand(mvff), size,
                           FindDeleteENTIRE);
   if (!found) {
     /* Add a new range to the free lists and try again. */
     res = MVFFExtend(&newRange, mvff, size, withReservoirPermit);
     if (res != ResOK)
       return res;
-    found = LandFindLargest(&range, &oldRange, MVFFFailover(mvff), size,
+    found = LandFindLargest(&range, &oldRange, MVFFFreeLand(mvff), size,
                             FindDeleteENTIRE);
     AVER(found && RangesOverlap(&range, &newRange));
   }
@@ -421,7 +421,7 @@ static void MVFFBufferEmpty(Pool pool, Buffer buffer,
   if (RangeIsEmpty(&range))
     return;
 
-  res = LandInsert(&coalescedRange, MVFFFailover(mvff), &range);
+  res = LandInsert(&coalescedRange, MVFFFreeLand(mvff), &range);
   AVER(res == ResOK);
   MVFFReduce(mvff);
 }
@@ -563,7 +563,7 @@ static Res MVFFInit(Pool pool, ArgList args)
   MPS_ARGS_BEGIN(foArgs) {
     MPS_ARGS_ADD(foArgs, FailoverPrimary, MVFFFreeCBS(mvff));
     MPS_ARGS_ADD(foArgs, FailoverSecondary, MVFFFreelist(mvff));
-    res = LandInit(MVFFFailover(mvff), FailoverLandClassGet(), arena, align,
+    res = LandInit(MVFFFreeLand(mvff), FailoverLandClassGet(), arena, align,
                    mvff, foArgs);
   } MPS_ARGS_END(foArgs);
   if (res != ResOK)
@@ -621,7 +621,7 @@ static void MVFFFinish(Pool pool)
    * now, but CBS doesn't support deletion while iterating. See
    * job003826. */
 
-  LandFinish(MVFFFailover(mvff));
+  LandFinish(MVFFFreeLand(mvff));
   LandFinish(MVFFFreelist(mvff));
   LandFinish(MVFFFreeCBS(mvff));
   LandFinish(MVFFTotalCBS(mvff));
@@ -750,7 +750,7 @@ size_t mps_mvff_free_size(mps_pool_t mps_pool)
   mvff = Pool2MVFF(pool);
   AVERT(MVFF, mvff);
 
-  return (size_t)LandSize(MVFFFailover(mvff));
+  return (size_t)LandSize(MVFFFreeLand(mvff));
 }
 
 /* Total owned bytes. See <design/poolmvff/#design.arena-enter> */
@@ -786,9 +786,9 @@ static Bool MVFFCheck(MVFF mvff)
   CHECKD(Land, MVFFTotalCBS(mvff));
   CHECKD(Land, MVFFFreeCBS(mvff));
   CHECKD(Land, MVFFFreelist(mvff));
-  CHECKD(Land, MVFFFailover(mvff));
-  CHECKL(LandSize(MVFFTotalCBS(mvff)) >= LandSize(MVFFFailover(mvff)));
-  CHECKL(SizeIsAligned(LandSize(MVFFFailover(mvff)), PoolAlignment(MVFF2Pool(mvff))));
+  CHECKD(Land, MVFFFreeLand(mvff));
+  CHECKL(LandSize(MVFFTotalCBS(mvff)) >= LandSize(MVFFFreeLand(mvff)));
+  CHECKL(SizeIsAligned(LandSize(MVFFFreeLand(mvff)), PoolAlignment(MVFF2Pool(mvff))));
   CHECKL(SizeIsAligned(LandSize(MVFFTotalCBS(mvff)), ArenaAlign(PoolArena(MVFF2Pool(mvff)))));
   CHECKL(BoolCheck(mvff->slotHigh));
   CHECKL(BoolCheck(mvff->firstFit));