Use range objects in the cbs interface instead of base, limit pairs. the idea is that freelist and cbs should offer similar interfaces so that the testing code can be shared.

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

7 files changed, 189 insertions, 187 deletions

diff --git a/mps/code/cbs.c b/mps/code/cbs.c
index 45a708f2ba7..8bf9a4300df 100644
--- a/mps/code/cbs.c
+++ b/mps/code/cbs.c
@@ -339,7 +339,7 @@ static void cbsBlockGrew(CBS cbs, CBSBlock block, Size oldSize)
 /* cbsBlockAlloc -- allocate a new block and set its base and limit,
    but do not insert it into the splay tree yet */
 
-static Res cbsBlockAlloc(CBSBlock *blockReturn, CBS cbs, Addr base, Addr limit)
+static Res cbsBlockAlloc(CBSBlock *blockReturn, CBS cbs, Range range)
 {
   Res res;
   CBSBlock block;
@@ -347,6 +347,7 @@ static Res cbsBlockAlloc(CBSBlock *blockReturn, CBS cbs, Addr base, Addr limit)
 
   AVER(blockReturn != NULL);
   AVERT(CBS, cbs);
+  AVERT(Range, range);
 
   res = PoolAlloc(&p, cbs->blockPool, sizeof(CBSBlockStruct),
                   /* withReservoirPermit */ FALSE);
@@ -355,8 +356,8 @@ static Res cbsBlockAlloc(CBSBlock *blockReturn, CBS cbs, Addr base, Addr limit)
   block = (CBSBlock)p;
 
   SplayNodeInit(splayNodeOfCBSBlock(block));
-  block->base = base;
-  block->limit = limit;
+  block->base = RangeBase(range);
+  block->limit = RangeLimit(range);
   block->maxSize = CBSBlockSize(block);
 
   AVERT(CBSBlock, block);
@@ -387,21 +388,22 @@ static void cbsBlockInsert(CBS cbs, CBSBlock block)
 
 /* cbsInsertIntoTree -- Insert a range into the splay tree */
 
-static Res cbsInsertIntoTree(Addr *baseReturn, Addr *limitReturn,
-                             CBS cbs, Addr base, Addr limit)
+static Res cbsInsertIntoTree(Range rangeReturn, CBS cbs, Range range)
 {
   Res res;
-  Addr newBase, newLimit;
+  Addr base, limit, newBase, newLimit;
   SplayNode leftSplay, rightSplay;
   CBSBlock leftCBS, rightCBS;
   Bool leftMerge, rightMerge;
   Size oldSize;
 
+  AVER(rangeReturn != NULL);
   AVERT(CBS, cbs);
-  AVER(base != (Addr)0);
-  AVER(base < limit);
-  AVER(AddrIsAligned(base, cbs->alignment));
-  AVER(AddrIsAligned(limit, cbs->alignment));
+  AVERT(Range, range);
+  AVER(RangeIsAligned(range, cbs->alignment));
+
+  base = RangeBase(range);
+  limit = RangeLimit(range);
 
   METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
   res = SplayTreeNeighbours(&leftSplay, &rightSplay,
@@ -461,7 +463,7 @@ static Res cbsInsertIntoTree(Addr *baseReturn, Addr *limitReturn,
 
   } else {
     CBSBlock block;
-    res = cbsBlockAlloc(&block, cbs, base, limit);
+    res = cbsBlockAlloc(&block, cbs, range);
     if (res != ResOK)
       goto fail;
     cbsBlockInsert(cbs, block);
@@ -469,8 +471,7 @@ static Res cbsInsertIntoTree(Addr *baseReturn, Addr *limitReturn,
 
   AVER(newBase <= base);
   AVER(newLimit >= limit);
-  *baseReturn = newBase;
-  *limitReturn = newLimit;
+  RangeInit(rangeReturn, newBase, newLimit);
 
   return ResOK;
 
@@ -485,29 +486,18 @@ fail:
  * See <design/cbs/#functions.cbs.insert>.
  */
 
-Res CBSInsert(Addr *baseReturn, Addr *limitReturn,
-              CBS cbs, Addr base, Addr limit)
+Res CBSInsert(Range rangeReturn, CBS cbs, Range range)
 {
-  Addr newBase, newLimit;
   Res res;
 
-  AVER(baseReturn != NULL);
-  AVER(limitReturn != NULL);
   AVERT(CBS, cbs);
   CBSEnter(cbs);
 
-  AVER(base != (Addr)0);
-  AVER(base < limit);
-  AVER(AddrIsAligned(base, cbs->alignment));
-  AVER(AddrIsAligned(limit, cbs->alignment));
-
-  res = cbsInsertIntoTree(&newBase, &newLimit, cbs, base, limit);
-  if (res == ResOK) {
-    AVER(newBase <= base);
-    AVER(limit <= newLimit);
-    *baseReturn = newBase;
-    *limitReturn = newLimit;
-  }
+  AVER(rangeReturn != NULL);
+  AVERT(Range, range);
+  AVER(RangeIsAligned(range, cbs->alignment));
+
+  res = cbsInsertIntoTree(rangeReturn, cbs, range);
 
   CBSLeave(cbs);
   return res;
@@ -516,22 +506,21 @@ Res CBSInsert(Addr *baseReturn, Addr *limitReturn,
 
 /* cbsDeleteFromTree -- delete blocks from the splay tree */
 
-static Res cbsDeleteFromTree(Addr *baseReturn, Addr *limitReturn,
-                             CBS cbs, Addr base, Addr limit)
+static Res cbsDeleteFromTree(Range rangeReturn, CBS cbs, Range range)
 {
   Res res;
   CBSBlock cbsBlock;
   SplayNode splayNode;
-  Addr oldBase, oldLimit;
+  Addr base, limit, oldBase, oldLimit;
   Size oldSize;
 
-  AVER(baseReturn != NULL);
-  AVER(limitReturn != NULL);
+  AVER(rangeReturn != NULL);
   AVERT(CBS, cbs);
-  AVER(base != NULL);
-  AVER(limit > base);
-  AVER(AddrIsAligned(base, cbs->alignment));
-  AVER(AddrIsAligned(limit, cbs->alignment));
+  AVERT(Range, range);
+  AVER(RangeIsAligned(range, cbs->alignment));
+
+  base = RangeBase(range);
+  limit = RangeLimit(range);
 
   METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
   res = SplayTreeSearch(&splayNode, splayTreeOfCBS(cbs), (void *)&base);
@@ -567,10 +556,12 @@ static Res cbsDeleteFromTree(Addr *baseReturn, Addr *limitReturn,
   } else {
     /* two remaining fragments. shrink block to represent fragment at
        left, and create new block for fragment at right. */
+    RangeStruct newRange;
     CBSBlock newBlock;
     AVER(base > oldBase);
     AVER(limit < oldLimit);
-    res = cbsBlockAlloc(&newBlock, cbs, limit, oldLimit);
+    RangeInit(&newRange, limit, oldLimit);
+    res = cbsBlockAlloc(&newBlock, cbs, &newRange);
     if (res != ResOK) {
       goto failAlloc;
     }
@@ -579,8 +570,7 @@ static Res cbsDeleteFromTree(Addr *baseReturn, Addr *limitReturn,
     cbsBlockInsert(cbs, newBlock);
   }
 
-  *baseReturn = oldBase;
-  *limitReturn = oldLimit;
+  RangeInit(rangeReturn, oldBase, oldLimit);
   return ResOK;
 
 failAlloc:
@@ -596,20 +586,18 @@ failSplayTreeSearch:
  * See <design/cbs/#function.cbs.delete>.
  */
 
-Res CBSDelete(Addr *baseReturn, Addr *limitReturn,
-              CBS cbs, Addr base, Addr limit)
+Res CBSDelete(Range rangeReturn, CBS cbs, Range range)
 {
   Res res;
 
   AVERT(CBS, cbs);
   CBSEnter(cbs);
 
-  AVER(base != NULL);
-  AVER(limit > base);
-  AVER(AddrIsAligned(base, cbs->alignment));
-  AVER(AddrIsAligned(limit, cbs->alignment));
+  AVER(rangeReturn != NULL);
+  AVERT(Range, range);
+  AVER(RangeIsAligned(range, cbs->alignment));
 
-  res = cbsDeleteFromTree(baseReturn, limitReturn, cbs, base, limit);
+  res = cbsDeleteFromTree(rangeReturn, cbs, range);
 
   CBSLeave(cbs);
   return res;
@@ -666,10 +654,11 @@ static void cbsIterateInternal(CBS cbs, CBSIterateMethod iterate,
   METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
   splayNode = SplayTreeFirst(splayTree, NULL);
   while(splayNode != NULL) {
+    RangeStruct range;
     cbsBlock = cbsBlockOfSplayNode(splayNode);
-    if (!(*iterate)(cbs, CBSBlockBase(cbsBlock), CBSBlockLimit(cbsBlock), closureP, closureS)) {
+    RangeInit(&range, CBSBlockBase(cbsBlock), CBSBlockLimit(cbsBlock));
+    if (!(*iterate)(cbs, &range, closureP, closureS))
       break;
-    }
     METER_ACC(cbs->splaySearch, cbs->splayTreeSize);
     splayNode = SplayTreeNext(splayTree, splayNode, keyOfCBSBlock(cbsBlock));
   }
@@ -680,9 +669,10 @@ void CBSIterate(CBS cbs, CBSIterateMethod iterate,
                 void *closureP, Size closureS)
 {
   AVERT(CBS, cbs);
-  AVER(FUNCHECK(iterate));
   CBSEnter(cbs);
 
+  AVER(FUNCHECK(iterate));
+
   cbsIterateInternal(cbs, iterate, closureP, closureS);
 
   CBSLeave(cbs);
@@ -706,21 +696,26 @@ Bool FindDeleteCheck(FindDelete findDelete)
 
 /* cbsFindDeleteRange -- delete appropriate range of block found */
 
-static void cbsFindDeleteRange(Addr *baseReturn, Addr *limitReturn,
-                               Addr *oldBaseReturn, Addr *oldLimitReturn,
-                               CBS cbs, Addr base, Addr limit, Size size,
+static void cbsFindDeleteRange(Range rangeReturn, Range oldRangeReturn,
+                               CBS cbs, Range range, Size size,
                                FindDelete findDelete)
 {
   Bool callDelete = TRUE;
+  Addr base, limit;
 
-  AVER(baseReturn != NULL);
-  AVER(limitReturn != NULL);
+  AVER(rangeReturn != NULL);
+  AVER(oldRangeReturn != NULL);
   AVERT(CBS, cbs);
-  AVER(base < limit);
+  AVERT(Range, range);
+  AVER(RangeIsAligned(range, cbs->alignment));
   AVER(size > 0);
-  AVER(AddrOffset(base, limit) >= size);
+  AVER(SizeIsAligned(size, cbs->alignment));
+  AVER(RangeSize(range) >= size);
   AVERT(FindDelete, findDelete);
 
+  base = RangeBase(range);
+  limit = RangeLimit(range);
+
   switch(findDelete) {
 
   case FindDeleteNONE:
@@ -744,25 +739,23 @@ static void cbsFindDeleteRange(Addr *baseReturn, Addr *limitReturn,
     break;
   }
 
+  RangeInit(rangeReturn, base, limit);
+
   if (callDelete) {
     Res res;
-    res = cbsDeleteFromTree(oldBaseReturn, oldLimitReturn, cbs, base, limit);
+    res = cbsDeleteFromTree(oldRangeReturn, cbs, rangeReturn);
     /* Can't have run out of memory, because all our callers pass in
        blocks that were just found in the splay tree, and we only
        deleted from one end of the block, so cbsDeleteFromTree did not
        need to allocate a new block. */
     AVER(res == ResOK);
   }
-
-  *baseReturn = base;
-  *limitReturn = limit;
 }
 
 
 /* CBSFindFirst -- find the first block of at least the given size */
 
-Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
-                  Addr *oldBaseReturn, Addr *oldLimitReturn,
+Bool CBSFindFirst(Range rangeReturn, Range oldRangeReturn,
                   CBS cbs, Size size, FindDelete findDelete)
 {
   Bool found;
@@ -771,8 +764,8 @@ Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
   AVERT(CBS, cbs);
   CBSEnter(cbs);
 
-  AVER(baseReturn != NULL);
-  AVER(limitReturn != NULL);
+  AVER(rangeReturn != NULL);
+  AVER(oldRangeReturn != NULL);
   AVER(size > 0);
   AVER(SizeIsAligned(size, cbs->alignment));
   AVER(cbs->fastFind);
@@ -783,14 +776,13 @@ Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
                          &cbsTestTree, NULL, size);
   if (found) {
     CBSBlock block;
-    Addr base, limit;
+    RangeStruct range;
     block = cbsBlockOfSplayNode(node);
     AVER(CBSBlockSize(block) >= size);
-    base = CBSBlockBase(block);
-    limit = CBSBlockLimit(block);
-    AVER(AddrOffset(base, limit) >= size);
-    cbsFindDeleteRange(baseReturn, limitReturn, oldBaseReturn, oldLimitReturn,
-                       cbs, base, limit, size, findDelete);
+    RangeInit(&range, CBSBlockBase(block), CBSBlockLimit(block));
+    AVER(RangeSize(&range) >= size);
+    cbsFindDeleteRange(rangeReturn, oldRangeReturn, cbs, &range,
+                       size, findDelete);
   }
 
   CBSLeave(cbs);
@@ -800,8 +792,7 @@ Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
 
 /* CBSFindLast -- find the last block of at least the given size */
 
-Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
-                 Addr *oldBaseReturn, Addr *oldLimitReturn,
+Bool CBSFindLast(Range rangeReturn, Range oldRangeReturn,
                  CBS cbs, Size size, FindDelete findDelete)
 {
   Bool found;
@@ -810,8 +801,8 @@ Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
   AVERT(CBS, cbs);
   CBSEnter(cbs);
 
-  AVER(baseReturn != NULL);
-  AVER(limitReturn != NULL);
+  AVER(rangeReturn != NULL);
+  AVER(oldRangeReturn != NULL);
   AVER(size > 0);
   AVER(SizeIsAligned(size, cbs->alignment));
   AVER(cbs->fastFind);
@@ -822,14 +813,13 @@ Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
                         &cbsTestTree, NULL, size);
   if (found) {
     CBSBlock block;
-    Addr base, limit;
+    RangeStruct range;
     block = cbsBlockOfSplayNode(node);
     AVER(CBSBlockSize(block) >= size);
-    base = CBSBlockBase(block);
-    limit = CBSBlockLimit(block);
-    AVER(AddrOffset(base, limit) >= size);
-    cbsFindDeleteRange(baseReturn, limitReturn, oldBaseReturn, oldLimitReturn,
-                       cbs, base, limit, size, findDelete);
+    RangeInit(&range, CBSBlockBase(block), CBSBlockLimit(block));
+    AVER(RangeSize(&range) >= size);
+    cbsFindDeleteRange(rangeReturn, oldRangeReturn, cbs, &range,
+                       size, findDelete);
   }
 
   CBSLeave(cbs);
@@ -839,8 +829,7 @@ Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
 
 /* CBSFindLargest -- find the largest block in the CBS */
 
-Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
-                    Addr *oldBaseReturn, Addr *oldLimitReturn,
+Bool CBSFindLargest(Range rangeReturn, Range oldRangeReturn,
                     CBS cbs, FindDelete findDelete)
 {
   Bool found = FALSE;
@@ -850,16 +839,16 @@ Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
   AVERT(CBS, cbs);
   CBSEnter(cbs);
 
-  AVER(baseReturn != NULL);
-  AVER(limitReturn != NULL);
+  AVER(rangeReturn != NULL);
+  AVER(oldRangeReturn != NULL);
   AVER(cbs->fastFind);
   AVERT(FindDelete, findDelete);
 
   notEmpty = SplayRoot(&root, splayTreeOfCBS(cbs));
   if (notEmpty) {
+    RangeStruct range;
     CBSBlock block;
     SplayNode node = NULL;    /* suppress "may be used uninitialized" */
-    Addr base, limit;
     Size size;
 
     size = cbsBlockOfSplayNode(root)->maxSize;
@@ -869,10 +858,10 @@ Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
     AVER(found); /* maxSize is exact, so we will find it. */
     block = cbsBlockOfSplayNode(node);
     AVER(CBSBlockSize(block) >= size);
-    base = CBSBlockBase(block);
-    limit = CBSBlockLimit(block);
-    cbsFindDeleteRange(baseReturn, limitReturn, oldBaseReturn, oldLimitReturn,
-                       cbs, base, limit, size, findDelete);
+    RangeInit(&range, CBSBlockBase(block), CBSBlockLimit(block));
+    AVER(RangeSize(&range) >= size);
+    cbsFindDeleteRange(rangeReturn, oldRangeReturn, cbs, &range,
+                       size, findDelete);
   }
 
   CBSLeave(cbs);
diff --git a/mps/code/cbs.h b/mps/code/cbs.h
index 544df0a0586..5b651c1aaf8 100644
--- a/mps/code/cbs.h
+++ b/mps/code/cbs.h
@@ -11,12 +11,13 @@
 
 #include "arg.h"
 #include "meter.h"
-#include "splay.h"
 #include "mpmtypes.h"
+#include "range.h"
+#include "splay.h"
 
 
 typedef struct CBSStruct *CBS;
-typedef Bool (*CBSIterateMethod)(CBS cbs, Addr base, Addr limit,
+typedef Bool (*CBSIterateMethod)(CBS cbs, Range range,
                                  void *closureP, Size closureS);
 
 
@@ -40,23 +41,18 @@ extern Res CBSInit(Arena arena, CBS cbs, void *owner,
                    Align alignment, Bool fastFind, ArgList args);
 extern void CBSFinish(CBS cbs);
 
-extern Res CBSInsert(Addr *baseReturn, Addr *limitReturn,
-                     CBS cbs, Addr base, Addr limit);
-extern Res CBSDelete(Addr *baseReturn, Addr *limitReturn,
-                     CBS cbs, Addr base, Addr limit);
+extern Res CBSInsert(Range rangeReturn, CBS cbs, Range range);
+extern Res CBSDelete(Range rangeReturn, CBS cbs, Range range);
 extern void CBSIterate(CBS cbs, CBSIterateMethod iterate,
                        void *closureP, Size closureS);
 
 extern Res CBSDescribe(CBS cbs, mps_lib_FILE *stream);
 
-extern Bool CBSFindFirst(Addr *baseReturn, Addr *limitReturn,
-                         Addr *oldBaseReturn, Addr *oldLimitReturn,
+extern Bool CBSFindFirst(Range rangeReturn, Range oldRangeReturn,
                          CBS cbs, Size size, FindDelete findDelete);
-extern Bool CBSFindLast(Addr *baseReturn, Addr *limitReturn,
-                        Addr *oldBaseReturn, Addr *oldLimitReturn,
+extern Bool CBSFindLast(Range rangeReturn, Range oldRangeReturn,
                         CBS cbs, Size size, FindDelete findDelete);
-extern Bool CBSFindLargest(Addr *baseReturn, Addr *limitReturn,
-                           Addr *oldBaseReturn, Addr *oldLimitReturn,
+extern Bool CBSFindLargest(Range rangeReturn, Range oldRangeReturn,
                            CBS cbs, FindDelete findDelete);
 
 
diff --git a/mps/code/cbstest.c b/mps/code/cbstest.c
index 3588d488204..4f60880a756 100644
--- a/mps/code/cbstest.c
+++ b/mps/code/cbstest.c
@@ -47,9 +47,9 @@ static Index (indexOfAddr)(Addr block, Addr a)
 }
 
 
-static Bool checkCBSAction(CBS cbs, Addr base, Addr limit, void *closureP,
-                           Size closureS)
+static Bool checkCBSAction(CBS cbs, Range range, void *closureP, Size closureS)
 {
+  Addr base, limit;
   CheckCBSClosure closure = (CheckCBSClosure)closureP;
 
   /* Don't need to check cbs every time */
@@ -57,6 +57,9 @@ static Bool checkCBSAction(CBS cbs, Addr base, Addr limit, void *closureP,
   UNUSED(closureS);
   Insist(closure != NULL);
 
+  base = RangeBase(range);
+  limit = RangeLimit(range);
+
   if (base > closure->oldLimit) {
     Insist(BTIsSetRange(closure->allocTable,
                       indexOfAddr(closure->base, closure->oldLimit),
@@ -70,7 +73,6 @@ static Bool checkCBSAction(CBS cbs, Addr base, Addr limit, void *closureP,
                       indexOfAddr(closure->base, base),
                       indexOfAddr(closure->base, limit)));
 
-
   closure->oldLimit = limit;
 
   return TRUE;
@@ -201,7 +203,7 @@ static void allocate(CBS cbs, Addr block, BT allocTable,
   Res res;
   Index ib, il;                  /* Indexed for base and limit */
   Bool isFree;
-  Addr oldBase, oldLimit;
+  RangeStruct range, oldRange;
   Addr outerBase, outerLimit;    /* interval containing [ib, il) */
 
   ib = indexOfAddr(block, base);
@@ -234,7 +236,8 @@ static void allocate(CBS cbs, Addr block, BT allocTable,
     UNUSED(total);
   }
 
-  res = CBSDelete(&oldBase, &oldLimit, cbs, base, limit);
+  RangeInit(&range, base, limit);
+  res = CBSDelete(&oldRange, cbs, &range);
 
   if (!isFree) {
     die_expect((mps_res_t)res, MPS_RES_FAIL,
@@ -242,8 +245,8 @@ static void allocate(CBS cbs, Addr block, BT allocTable,
   } else { /* isFree */
     die_expect((mps_res_t)res, MPS_RES_OK,
                "failed to delete free block");
-    Insist(oldBase == outerBase);
-    Insist(oldLimit == outerLimit);
+    Insist(RangeBase(&oldRange) == outerBase);
+    Insist(RangeLimit(&oldRange) == outerLimit);
     NAllocateSucceeded++;
     BTSetRange(allocTable, ib, il);
   }
@@ -257,7 +260,7 @@ static void deallocate(CBS cbs, Addr block, BT allocTable,
   Index ib, il;
   Bool isAllocated;
   Addr outerBase = base, outerLimit = limit; /* interval containing [ib, il) */
-  Addr freeBase, freeLimit;                  /* interval returned by CBS */
+  RangeStruct range, freeRange; /* interval returned by CBS */
 
   ib = indexOfAddr(block, base);
   il = indexOfAddr(block, limit);
@@ -299,7 +302,8 @@ static void deallocate(CBS cbs, Addr block, BT allocTable,
     UNUSED(total);
   }
 
-  res = CBSInsert(&freeBase, &freeLimit, cbs, base, limit);
+  RangeInit(&range, base, limit);
+  res = CBSInsert(&freeRange, cbs, &range);
 
   if (!isAllocated) {
     die_expect((mps_res_t)res, MPS_RES_FAIL,
@@ -310,8 +314,8 @@ static void deallocate(CBS cbs, Addr block, BT allocTable,
 
     NDeallocateSucceeded++;
     BTResRange(allocTable, ib, il);
-    Insist(freeBase == outerBase);
-    Insist(freeLimit == outerLimit);
+    Insist(RangeBase(&freeRange) == outerBase);
+    Insist(RangeLimit(&freeRange) == outerLimit);
   }
 }
 
@@ -321,8 +325,9 @@ static void find(CBS cbs, void *block, BT alloc, Size size, Bool high,
 {
   Bool expected, found;
   Index expectedBase, expectedLimit;
-  Addr foundBase, foundLimit, remainderBase, remainderLimit;
-  Addr oldBase, oldLimit, origBase, origLimit;
+  RangeStruct foundRange, oldRange;
+  Addr remainderBase, remainderLimit;
+  Addr origBase, origLimit;
   Size oldSize, newSize;
 
   origBase = origLimit = NULL;
@@ -362,18 +367,17 @@ static void find(CBS cbs, void *block, BT alloc, Size size, Bool high,
   }
 
   found = (high ? CBSFindLast : CBSFindFirst)
-    (&foundBase, &foundLimit, &oldBase, &oldLimit, 
-     cbs, size * Alignment, findDelete);
+    (&foundRange, &oldRange, cbs, size * Alignment, findDelete);
 
   Insist(found == expected);
 
   if (found) {
-    Insist(expectedBase == indexOfAddr(block, foundBase));
-    Insist(expectedLimit == indexOfAddr(block, foundLimit));
+    Insist(expectedBase == indexOfAddr(block, RangeBase(&foundRange)));
+    Insist(expectedLimit == indexOfAddr(block, RangeLimit(&foundRange)));
 
     if (findDelete != FindDeleteNONE) {
-      Insist(oldBase == origBase);
-      Insist(oldLimit == origLimit);
+      Insist(RangeBase(&oldRange) == origBase);
+      Insist(RangeLimit(&oldRange) == origLimit);
       BTSetRange(alloc, expectedBase, expectedLimit);
     }
   }
diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c
index e2642f23c43..bdcfd2a69ae 100644
--- a/mps/code/poolmv2.c
+++ b/mps/code/poolmv2.c
@@ -46,10 +46,10 @@ static Bool MVTReturnRangeSegs(MVT mvt, Range range, Arena arena);
 static Res MVTInsert(MVT mvt, Addr base, Addr limit);
 static Res MVTDelete(MVT mvt, Addr base, Addr limit);
 static void ABQRefillIfNecessary(MVT mvt, Size size);
-static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit,
+static Bool ABQRefillCallback(CBS cbs, Range range,
                               void *closureP, Size closureS);
 static Res MVTContingencySearch(Addr *baseReturn, Addr *limitReturn, CBS cbs, Size min);
-static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit,
+static Bool MVTContingencyCallback(CBS cbs, Range range,
                                    void *closureP, Size closureS);
 static Bool MVTCheckFit(Addr base, Addr limit, Size min, Arena arena);
 static ABQ MVTABQ(MVT mvt);
@@ -652,24 +652,23 @@ failOverflow:
 static Res MVTInsert(MVT mvt, Addr base, Addr limit)
 {
   Res res;
-  Addr newBase, newLimit;
-  RangeStruct range;
+  RangeStruct range, newRange;
 
   AVERT(MVT, mvt);
   AVER(base < limit);
   
-  res = CBSInsert(&newBase, &newLimit, MVTCBS(mvt), base, limit);
+  RangeInit(&range, base, limit);
+  res = CBSInsert(&newRange, MVTCBS(mvt), &range);
   if (res != ResOK)
     return res;
 
-  RangeInit(&range, newBase, newLimit);
-  if (RangeSize(&range) >= mvt->reuseSize) {
+  if (RangeSize(&newRange) >= mvt->reuseSize) {
     /* The new range is big enough that it might have been coalesced
      * with ranges on the ABQ, so ensure that they are removed before
      * reserving the new range.
      */
-    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &range, 0);
-    MVTReserve(mvt, &range);
+    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &newRange, 0);
+    MVTReserve(mvt, &newRange);
   }
 
   return ResOK;
@@ -681,32 +680,31 @@ static Res MVTInsert(MVT mvt, Addr base, Addr limit)
  */
 static Res MVTDelete(MVT mvt, Addr base, Addr limit)
 {
-  Addr oldBase, oldLimit;
-  RangeStruct range, rangeLeft, rangeRight;
+  RangeStruct range, rangeOld, rangeLeft, rangeRight;
   Res res;
 
   AVERT(MVT, mvt);
   AVER(base < limit);
 
-  res = CBSDelete(&oldBase, &oldLimit, MVTCBS(mvt), base, limit);
+  RangeInit(&range, base, limit);
+  res = CBSDelete(&rangeOld, MVTCBS(mvt), &range);
   if (res != ResOK)
     return res;
 
   /* If the old address range was larger than the reuse size, then it
    * might be on the ABQ, so ensure it is removed.
    */
-  RangeInit(&range, oldBase, oldLimit);
-  if (RangeSize(&range) >= mvt->reuseSize)
-    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &range, 0);
+  if (RangeSize(&rangeOld) >= mvt->reuseSize)
+    ABQIterate(MVTABQ(mvt), MVTDeleteOverlapping, &rangeOld, 0);
 
   /* There might be fragments at the left or the right of the deleted
    * range, and either might be big enough to go back on the ABQ.
    */
-  RangeInit(&rangeLeft, oldBase, base);
+  RangeInit(&rangeLeft, RangeBase(&rangeOld), base);
   if (RangeSize(&rangeLeft) >= mvt->reuseSize)
     MVTReserve(mvt, &rangeLeft);
 
-  RangeInit(&rangeRight, limit, oldLimit);
+  RangeInit(&rangeRight, limit, RangeLimit(&rangeOld));
   if (RangeSize(&rangeRight) >= mvt->reuseSize)
     MVTReserve(mvt, &rangeRight);
 
@@ -1109,29 +1107,25 @@ static void ABQRefillIfNecessary(MVT mvt, Size size)
 /* ABQRefillCallback -- called from CBSIterate at the behest of
  * ABQRefillIfNecessary
  */
-static Bool ABQRefillCallback(CBS cbs, Addr base, Addr limit,
+static Bool ABQRefillCallback(CBS cbs, Range range,
                               void *closureP, Size closureS)
 {
   Res res;
   MVT mvt;
-  Size size;
-  RangeStruct range;
 
   AVERT(CBS, cbs);
   mvt = CBSMVT(cbs);
   AVERT(MVT, mvt);
   AVERT(ABQ, MVTABQ(mvt));
-  AVER(base < limit);
+  AVERT(Range, range);
   UNUSED(closureP);
   UNUSED(closureS);
 
-  size = AddrOffset(base, limit);
-  if (size < mvt->reuseSize)
+  if (RangeSize(range) < mvt->reuseSize)
     return TRUE;
 
   METER_ACC(mvt->refillPushes, ABQDepth(MVTABQ(mvt)));
-  RangeInit(&range, base, limit);
-  res = MVTReserve(mvt, &range);
+  res = MVTReserve(mvt, range);
   if (res != ResOK)
     return FALSE;
 
@@ -1145,8 +1139,7 @@ typedef struct MVTContigencyStruct *MVTContigency;
 typedef struct MVTContigencyStruct
 {
   Bool found;
-  Addr base;
-  Addr limit;
+  RangeStruct range;
   Arena arena;
   Size min;
   /* meters */
@@ -1169,13 +1162,13 @@ static Res MVTContingencySearch(Addr *baseReturn, Addr *limitReturn, CBS cbs, Si
  
   CBSIterate(cbs, MVTContingencyCallback, (void *)&cls, 0);
   if (cls.found) {
-    AVER(AddrOffset(cls.base, cls.limit) >= min);
+    AVER(RangeSize(&cls.range) >= min);
     METER_ACC(CBSMVT(cbs)->contingencySearches, cls.steps);
     if (cls.hardSteps) {
       METER_ACC(CBSMVT(cbs)->contingencyHardSearches, cls.hardSteps);
     }
-    *baseReturn = cls.base;
-    *limitReturn = cls.limit;
+    *baseReturn = RangeBase(&cls.range);
+    *limitReturn = RangeLimit(&cls.range);
     return ResOK;
   }
    
@@ -1186,28 +1179,30 @@ static Res MVTContingencySearch(Addr *baseReturn, Addr *limitReturn, CBS cbs, Si
 /* MVTContingencyCallback -- called from CBSIterate at the behest of
  * MVTContingencySearch
  */
-static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit,
+static Bool MVTContingencyCallback(CBS cbs, Range range,
                                    void *closureP, Size closureS)
 {
   MVTContigency cl;
   Size size;
+  Addr base, limit;
  
   AVERT(CBS, cbs);
-  AVER(base < limit);
+  AVERT(Range, range);
   AVER(closureP != NULL);
   UNUSED(closureS);
 
   cl = (MVTContigency)closureP;
-  size = AddrOffset(base, limit);
- 
+  base = RangeBase(range);
+  limit = RangeLimit(range);
+  size = RangeSize(range);
+
   cl->steps++;
   if (size < cl->min)
     return TRUE;
 
   /* verify that min will fit when seg-aligned */
   if (size >= 2 * cl->min) {
-    cl->base = base;
-    cl->limit = limit;
+    RangeInit(&cl->range, base, limit);
     cl->found = TRUE;
     return FALSE;
   }
@@ -1215,8 +1210,7 @@ static Bool MVTContingencyCallback(CBS cbs, Addr base, Addr limit,
   /* do it the hard way */
   cl->hardSteps++;
   if (MVTCheckFit(base, limit, cl->min, cl->arena)) {
-    cl->base = base;
-    cl->limit = limit;
+    RangeInit(&cl->range, base, limit);
     cl->found = TRUE;
     return FALSE;
   }
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index e5335377175..89b0160105d 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -84,22 +84,22 @@ typedef MVFFDebugStruct *MVFFDebug;
  */
 static void MVFFAddToFreeList(Addr *baseIO, Addr *limitIO, MVFF mvff) {
   Res res;
-  Addr base, limit;
+  RangeStruct range, newRange;
 
   AVER(baseIO != NULL);
   AVER(limitIO != NULL);
   AVERT(MVFF, mvff);
-  base = *baseIO;
-  limit = *limitIO;
-  AVER(limit > base);
+  RangeInit(&range, *baseIO, *limitIO);
 
-  res = CBSInsert(baseIO, limitIO, CBSOfMVFF(mvff), base, limit);
+  res = CBSInsert(&newRange, CBSOfMVFF(mvff), &range);
   if (ResIsAllocFailure(res))
     /* CBS ran out of memory for splay nodes: lose freed range. */
     return;
 
   AVER(res == ResOK);
-  mvff->free += AddrOffset(base, limit);
+  mvff->free += RangeSize(&range);
+  *baseIO = RangeBase(&newRange);
+  *limitIO = RangeLimit(&newRange);
 
   return;
 }
@@ -140,15 +140,15 @@ static void MVFFFreeSegs(MVFF mvff, Addr base, Addr limit)
 
   while(segLimit <= limit) { /* segment ends in range */
     if (segBase >= base) { /* segment starts in range */
-      Addr oldBase, oldLimit;
-      res = CBSDelete(&oldBase, &oldLimit, CBSOfMVFF(mvff), segBase, segLimit);
+      RangeStruct range, oldRange;
+      RangeInit(&range, segBase, segLimit);
+      res = CBSDelete(&oldRange, CBSOfMVFF(mvff), &range);
       if (ResIsAllocFailure(res))
         /* CBS ran out of memory for splay nodes: can't delete. */
         return;
 
       AVER(res == ResOK);
-      AVER(oldBase <= segBase);
-      AVER(segLimit <= oldLimit);
+      AVER(RangesNest(&oldRange, &range));
       mvff->free -= AddrOffset(segBase, segLimit);
       mvff->total -= AddrOffset(segBase, segLimit);
       SegFree(seg);
@@ -248,7 +248,7 @@ static Bool MVFFFindFirstFree(Addr *baseReturn, Addr *limitReturn,
 {
   Bool foundBlock;
   FindDelete findDelete;
-  Addr oldBase, oldLimit;
+  RangeStruct range, oldRange;
 
   AVER(baseReturn != NULL);
   AVER(limitReturn != NULL);
@@ -260,11 +260,13 @@ static Bool MVFFFindFirstFree(Addr *baseReturn, Addr *limitReturn,
 
   foundBlock =
     (mvff->firstFit ? CBSFindFirst : CBSFindLast)
-    (baseReturn, limitReturn, &oldBase, &oldLimit, 
-     CBSOfMVFF(mvff), size, findDelete);
+    (&range, &oldRange, CBSOfMVFF(mvff), size, findDelete);
 
-  if (foundBlock)
+  if (foundBlock) {
+    *baseReturn = RangeBase(&range);
+    *limitReturn = RangeLimit(&range);
     mvff->free -= size;
+  }
 
   return foundBlock;
 }
@@ -354,7 +356,7 @@ static Res MVFFBufferFill(Addr *baseReturn, Addr *limitReturn,
 {
   Res res;
   MVFF mvff;
-  Addr base, limit, oldBase, oldLimit;
+  RangeStruct range, oldRange;
   Bool foundBlock;
   Seg seg = NULL;
 
@@ -369,34 +371,33 @@ static Res MVFFBufferFill(Addr *baseReturn, Addr *limitReturn,
   AVERT(Bool, withReservoirPermit);
 
   /* Hoping the largest is big enough, delete it and return if small. */
-  foundBlock = CBSFindLargest(&base, &limit, &oldBase, &oldLimit,
+  foundBlock = CBSFindLargest(&range, &oldRange,
                               CBSOfMVFF(mvff), FindDeleteENTIRE);
-  if (foundBlock && AddrOffset(base, limit) < size) {
-    Addr newBase, newLimit;
+  if (foundBlock && RangeSize(&range) < size) {
+    RangeStruct newRange;
     foundBlock = FALSE;
-    res = CBSInsert(&newBase, &newLimit, CBSOfMVFF(mvff), base, limit);
+    res = CBSInsert(&newRange, CBSOfMVFF(mvff), &range);
     if (ResIsAllocFailure(res))
       /* CBS ran out of memory for splay nodes: lose block. */
       return res;
 
-    AVER(newBase == base);
-    AVER(newLimit == limit);
     AVER(res == ResOK);
+    AVER(RangesEqual(&newRange, &range));
   }
   if (!foundBlock) {
     res = MVFFAddSeg(&seg, mvff, size, withReservoirPermit);
     if (res != ResOK)
       return res;
-    foundBlock = CBSFindLargest(&base, &limit, &oldBase, &oldLimit,
+    foundBlock = CBSFindLargest(&range, &oldRange,
                                 CBSOfMVFF(mvff), FindDeleteENTIRE);
     AVER(foundBlock); /* We will find the new segment. */
   }
 
-  AVER(AddrOffset(base, limit) >= size);
-  mvff->free -= AddrOffset(base, limit);
+  AVER(RangeSize(&range) >= size);
+  mvff->free -= RangeSize(&range);
 
-  *baseReturn = base;
-  *limitReturn = limit;
+  *baseReturn = RangeBase(&range);
+  *limitReturn = RangeLimit(&range);
   return ResOK;
 }
 
diff --git a/mps/code/range.c b/mps/code/range.c
index 60a8b0da367..4cd61d7b04d 100644
--- a/mps/code/range.c
+++ b/mps/code/range.c
@@ -70,6 +70,22 @@ Bool RangesOverlap(Range range1, Range range2)
       && RangeBase(range2) < RangeLimit(range1);
 }
 
+Bool RangesNest(Range outer, Range inner)
+{
+  AVERT(Range, outer);
+  AVERT(Range, inner);
+  return RangeBase(outer) <= RangeBase(inner)
+      && RangeLimit(inner) <= RangeLimit(outer);
+}
+
+Bool RangesEqual(Range range1, Range range2)
+{
+  AVERT(Range, range1);
+  AVERT(Range, range2);
+  return RangeBase(range1) == RangeBase(range2)
+      && RangeLimit(range1) == RangeLimit(range2);
+}
+
 Bool RangeIsAligned(Range range, Align alignment)
 {
   AVERT(Range, range);
diff --git a/mps/code/range.h b/mps/code/range.h
index c6c70ddb1c4..42ab4167715 100644
--- a/mps/code/range.h
+++ b/mps/code/range.h
@@ -33,6 +33,8 @@ extern Res RangeDescribe(Range range, mps_lib_FILE *stream);
 extern Bool RangeCheck(Range range);
 extern Bool RangeIsAligned(Range range, Align align);
 extern Bool RangesOverlap(Range range1, Range range2);
+extern Bool RangesNest(Range outer, Range inner);
+extern Bool RangesEqual(Range range1, Range range2);
 extern Addr (RangeBase)(Range range);
 extern Addr (RangeLimit)(Range range);
 extern Size (RangeSize)(Range range);