Pushing varargs decoding into a pool class method. much simpler.

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

18 files changed, 228 insertions, 111 deletions

diff --git a/mps/code/config.h b/mps/code/config.h
index 3165ef193cd..03d265c4dba 100644
--- a/mps/code/config.h
+++ b/mps/code/config.h
@@ -259,6 +259,16 @@
 #define MVFF_FIRST_FIT_DEFAULT   TRUE
 
 
+/* Pool MVT Configuration -- see <code.poolmv2.c> */
+/* FIXME: These numbers were lifted from mv2test and need thought. */
+
+#define MVT_MIN_SIZE_DEFAULT      MPS_PF_ALIGN
+#define MVT_MEAN_SIZE_DEFAULT     32
+#define MVT_MAX_SIZE_DEFAULT      8192
+#define MVT_RESERVE_DEPTH_DEFAULT 1024
+#define MVT_FRAG_LIMIT_DEFAULT    30
+
+
 /* Arena Configuration -- see <code/arena.c>
  *
  * .client.seg-size: ARENA_CLIENT_PAGE_SIZE is the size in bytes of a
diff --git a/mps/code/mpm.h b/mps/code/mpm.h
index cb9a6f49fa2..5346078c214 100644
--- a/mps/code/mpm.h
+++ b/mps/code/mpm.h
@@ -230,6 +230,7 @@ extern void PoolTraceEnd(Pool pool, Trace trace);
 extern void PoolWalk(Pool pool, Seg seg, FormattedObjectsStepMethod f,
                      void *v, size_t s);
 extern void PoolFreeWalk(Pool pool, FreeBlockStepMethod f, void *p);
+extern void PoolTrivVarargs(ArgStruct args[], va_list varargs);
 extern Res PoolTrivInit(Pool pool, ArgList arg);
 extern void PoolTrivFinish(Pool pool);
 extern Res PoolNoAlloc(Addr *pReturn, Pool pool, Size size,
diff --git a/mps/code/mpmst.h b/mps/code/mpmst.h
index 5c5ca542074..93eda47809d 100644
--- a/mps/code/mpmst.h
+++ b/mps/code/mpmst.h
@@ -52,6 +52,7 @@ typedef struct mps_class_s {
   size_t size;                  /* size of outer structure */
   size_t offset;                /* offset of generic struct in outer struct */
   Attr attr;                    /* attributes */
+  PoolVarargsMethod varargs;    /* convert deprecated varargs into keywords */
   PoolInitMethod init;          /* initialize the pool descriptor */
   PoolFinishMethod finish;      /* finish the pool descriptor */
   PoolAllocMethod alloc;        /* allocate memory from pool */
diff --git a/mps/code/mpmtypes.h b/mps/code/mpmtypes.h
index cadb8f2bff1..587dd3dbb76 100644
--- a/mps/code/mpmtypes.h
+++ b/mps/code/mpmtypes.h
@@ -182,6 +182,7 @@ typedef Res (*BufferDescribeMethod)(Buffer buffer, mps_lib_FILE *stream);
 
 /* Order of types corresponds to PoolClassStruct in <code/mpmst.h> */
 
+typedef void (*PoolVarargsMethod)(ArgStruct args[], va_list varargs);
 typedef Res (*PoolInitMethod)(Pool pool, ArgList args);
 typedef void (*PoolFinishMethod)(Pool pool);
 typedef Res (*PoolAllocMethod)(Addr *pReturn, Pool pool, Size size,
diff --git a/mps/code/mps.h b/mps/code/mps.h
index 3fb066e1752..f713d8d9229 100644
--- a/mps/code/mps.h
+++ b/mps/code/mps.h
@@ -111,6 +111,7 @@ typedef struct mps_arg_s {
     struct mps_pool_debug_option_s *pool_debug_option;
     mps_addr_t (*addr_method)(mps_addr_t);
     mps_align_t align;
+    mps_word_t count;
   } val;
 } mps_arg_s;
 
diff --git a/mps/code/mps.xcodeproj/project.pbxproj b/mps/code/mps.xcodeproj/project.pbxproj
index 20510f2cf75..8a47451f8a7 100644
--- a/mps/code/mps.xcodeproj/project.pbxproj
+++ b/mps/code/mps.xcodeproj/project.pbxproj
@@ -1101,6 +1101,7 @@
                 31CD33BB173A9F1500524741 /* mpscams.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = mpscams.h; sourceTree = "<group>"; };
                 31CD33BC173A9F1500524741 /* poolams.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = poolams.c; sourceTree = "<group>"; };
                 31CD33BD173A9F1500524741 /* poolams.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = poolams.h; sourceTree = "<group>"; };
+                31CD33BE173ABB3000524741 /* poolmv2.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = poolmv2.h; sourceTree = "<group>"; };
                 31D60006156D3C5F00337B26 /* segsmss.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = segsmss.c; sourceTree = "<group>"; };
                 31D6000D156D3CB200337B26 /* awluthe */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = awluthe; sourceTree = BUILT_PRODUCTS_DIR; };
                 31D60017156D3CC300337B26 /* awluthe.c */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.c; path = awluthe.c; sourceTree = "<group>"; };
@@ -1726,6 +1727,7 @@
                 31EEAC5A156AB40800714D05 /* Extra pools */ = {
                         isa = PBXGroup;
                         children = (
+                                31CD33BE173ABB3000524741 /* poolmv2.h */,
                                 311F2F5D17398B0400C15B6A /* lo.h */,
                                 31F6CCA91739B0CF00C48748 /* mpscamc.h */,
                                 31CD33BB173A9F1500524741 /* mpscams.h */,
diff --git a/mps/code/mpscmvt.h b/mps/code/mpscmvt.h
index be273177304..efc52b98e9e 100644
--- a/mps/code/mpscmvt.h
+++ b/mps/code/mpscmvt.h
@@ -9,6 +9,17 @@
 
 #include "mps.h"
 
+extern const struct mps_key_s _mps_key_mvt_min_size;
+#define MPS_KEY_MVT_MIN_SIZE (&_mps_key_mvt_min_size)
+extern const struct mps_key_s _mps_key_mvt_mean_size;
+#define MPS_KEY_MVT_MEAN_SIZE (&_mps_key_mvt_mean_size)
+extern const struct mps_key_s _mps_key_mvt_max_size;
+#define MPS_KEY_MVT_MAX_SIZE (&_mps_key_mvt_max_size)
+extern const struct mps_key_s _mps_key_mvt_reserve_depth;
+#define MPS_KEY_MVT_RESERVE_DEPTH (&_mps_key_mvt_reserve_depth)
+extern const struct mps_key_s _mps_key_mvt_frag_limit;
+#define MPS_KEY_MVT_FRAG_LIMIT (&_mps_key_mvt_frag_limit)
+
 /* The mvt pool class has five extra parameters to mps_pool_create:
  *  mps_res_t mps_pool_create(mps_pool_t * pool, mps_arena_t arena,
  *                            mps_class_t mvt_class,
diff --git a/mps/code/mpsi.c b/mps/code/mpsi.c
index 404bb115360..2efa608389d 100644
--- a/mps/code/mpsi.c
+++ b/mps/code/mpsi.c
@@ -55,14 +55,6 @@
 /* TODO: Remove these includes when varargs support is removed. */
 #include "mpsacl.h"
 #include "mpsavm.h"
-#include "mpscamc.h"
-#include "mpscmfs.h"
-#include "mpscmv.h"
-#include "mpscams.h"
-#include "mpscawl.h"
-#include "mpsclo.h"
-#include "mpscsnc.h"
-#include "mpscmvff.h"
 
 #include <stdarg.h>
 #include <string.h>
@@ -658,95 +650,15 @@ mps_res_t mps_pool_create(mps_pool_t *mps_pool_o, mps_arena_t arena,
   return mps_pool_create_v(mps_pool_o, arena, mps_class, varargs);
 }
 
-/* Decode deprecated varargs.  TODO: This can be deleted when varargs go. */
-
-static void mps_pool_create_v_decode(mps_arg_s args[],
-                                     mps_class_t class,
-                                     va_list varargs) {
-  if (class == mps_class_amc()) {
-    args[0].key = MPS_KEY_FORMAT;
-    args[0].val.format = va_arg(varargs, Format);
-    args[1].key = MPS_KEY_CHAIN;
-    args[1].val.chain = va_arg(varargs, Chain);
-    args[2].key = MPS_KEY_ARGS_END;
-  } else if (class == mps_class_mfs()) {
-    args[0].key = MPS_KEY_MFS_EXTEND_BY;
-    args[0].val.size = va_arg(varargs, Size);
-    args[1].key = MPS_KEY_MFS_UNIT_SIZE;
-    args[1].val.size = va_arg(varargs, Size);
-    args[2].key = MPS_KEY_ARGS_END;
-  } else if (class == mps_class_mv()) {
-    args[0].key = MPS_KEY_MV_EXTEND_BY;
-    args[0].val.size = va_arg(varargs, Size);
-    args[1].key = MPS_KEY_MV_AVG_SIZE;
-    args[1].val.size = va_arg(varargs, Size);
-    args[2].key = MPS_KEY_MV_MAX_SIZE;
-    args[2].val.size = va_arg(varargs, Size);
-    args[3].key = MPS_KEY_ARGS_END;
-  } else if (class == mps_class_ams()) {
-    args[0].key = MPS_KEY_FORMAT;
-    args[0].val.format = va_arg(varargs, Format);
-    args[1].key = MPS_KEY_CHAIN;
-    args[1].val.chain = va_arg(varargs, Chain);
-    args[2].key = MPS_KEY_AMS_SUPPORT_AMBIGUOUS;
-    args[2].val.b = va_arg(varargs, Bool);
-    args[3].key = MPS_KEY_ARGS_END;
-  } else if (class == mps_class_awl()) {
-    args[0].key = MPS_KEY_FORMAT;
-    args[0].val.format = va_arg(varargs, Format);
-    args[1].key = MPS_KEY_AWL_FIND_DEPENDENT;
-    args[1].val.addr_method = va_arg(varargs, mps_awl_find_dependent_t);
-    args[2].key = MPS_KEY_ARGS_END;
-  } else if (class == mps_class_lo() || class == mps_class_snc()) {
-    args[0].key = MPS_KEY_FORMAT;
-    args[0].val.format = va_arg(varargs, Format);
-    args[1].key = MPS_KEY_ARGS_END;
-  } else if (class == mps_class_mvff()) {
-    args[0].key = MPS_KEY_MVFF_EXTEND_BY;
-    args[0].val.size = va_arg(varargs, Size);
-    args[1].key = MPS_KEY_MVFF_AVG_SIZE;
-    args[1].val.size = va_arg(varargs, Size);
-    args[2].key = MPS_KEY_MVFF_ALIGN;
-    args[2].val.align = va_arg(varargs, Size); /* promoted type */
-    args[3].key = MPS_KEY_MVFF_SLOT_HIGH;
-    args[3].val.b = va_arg(varargs, Bool);
-    args[4].key = MPS_KEY_MVFF_ARENA_HIGH;
-    args[4].val.b = va_arg(varargs, Bool);
-    args[5].key = MPS_KEY_MVFF_FIRST_FIT;
-    args[5].val.b = va_arg(varargs, Bool);
-  } else {
-    args[0].key = MPS_KEY_ARGS_END;
-  }
-  /* Do not extend this list.  Future pools should not take varargs. */
-}
-
 mps_res_t mps_pool_create_v(mps_pool_t *mps_pool_o, mps_arena_t arena,
                             mps_class_t class, va_list varargs)
 {
-  mps_arg_s args[16];
-  
-  if (class == mps_class_mv_debug()) {
-    args[0].key = MPS_KEY_POOL_DEBUG_OPTION;
-    args[1].val.pool_debug_option = va_arg(varargs, mps_pool_debug_option_s *);
-    mps_pool_create_v_decode(args + 1, mps_class_mv(), varargs);
-  } else if (class == mps_class_ams_debug()) {
-    args[0].key = MPS_KEY_POOL_DEBUG_OPTION;
-    args[1].val.pool_debug_option = va_arg(varargs, mps_pool_debug_option_s *);
-    mps_pool_create_v_decode(args + 1, mps_class_ams(), varargs);
-  } else if (class == mps_class_mvff_debug()) {
-    args[0].key = MPS_KEY_POOL_DEBUG_OPTION;
-    args[1].val.pool_debug_option = va_arg(varargs, mps_pool_debug_option_s *);
-    mps_pool_create_v_decode(args + 1, mps_class_mvff(), varargs);
-  } else
-    mps_pool_create_v_decode(args, class, varargs);
-  /* Do not extend this list.  Future pools should not take varargs. */
-  
+  mps_arg_s args[16]; /* FIXME: Have a maximum in config.h */
+  class->varargs(args, varargs);
   va_end(varargs);
-  
   return mps_pool_create_k(mps_pool_o, arena, class, args);
 }
 
-
 mps_res_t mps_pool_create_k(mps_pool_t *mps_pool_o, mps_arena_t arena,
                             mps_class_t class, mps_arg_s args[])
 {
diff --git a/mps/code/pool.c b/mps/code/pool.c
index 283f3244ff4..865bf3ec2bf 100644
--- a/mps/code/pool.c
+++ b/mps/code/pool.c
@@ -47,6 +47,7 @@ Bool PoolClassCheck(PoolClass class)
   /* greater than the size of the class-specific portion of the instance */
   CHECKL(class->offset <= (size_t)(class->size - sizeof(PoolStruct)));
   CHECKL(AttrCheck(class->attr));
+  CHECKL(FUNCHECK(class->varargs));
   CHECKL(FUNCHECK(class->init));
   CHECKL(FUNCHECK(class->finish));
   CHECKL(FUNCHECK(class->alloc));
diff --git a/mps/code/poolabs.c b/mps/code/poolabs.c
index 1456ec66143..6fc0e279cb8 100644
--- a/mps/code/poolabs.c
+++ b/mps/code/poolabs.c
@@ -122,6 +122,7 @@ DEFINE_CLASS(AbstractPoolClass, class)
   class->size = 0;
   class->offset = 0;
   class->attr = 0;
+  class->varargs = PoolTrivVarargs;
   class->init = PoolTrivInit;
   class->finish = PoolTrivFinish;
   class->alloc = PoolNoAlloc;
@@ -194,6 +195,13 @@ void PoolTrivFinish(Pool pool)
   NOOP;
 }
 
+void PoolTrivVarargs(ArgStruct args[], va_list varargs)
+{
+  UNUSED(varargs);
+  args[0].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
 Res PoolTrivInit(Pool pool, ArgList args)
 {
   AVERT(Pool, pool);
diff --git a/mps/code/poolamc.c b/mps/code/poolamc.c
index 10679263343..d15404aad26 100644
--- a/mps/code/poolamc.c
+++ b/mps/code/poolamc.c
@@ -928,6 +928,19 @@ static Bool amcNailRangeIsMarked(Seg seg, Addr base, Addr limit)
 }
 
 
+/* amcVarargs -- decode obsolete varargs */
+
+static void AMCVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_FORMAT;
+  args[0].val.format = va_arg(varargs, Format);
+  args[1].key = MPS_KEY_CHAIN;
+  args[1].val.chain = va_arg(varargs, Chain);
+  args[2].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+
 /* amcInitComm -- initialize AMC/Z pool
  *
  * See <design/poolamc/#init>.
@@ -2409,6 +2422,7 @@ DEFINE_POOL_CLASS(AMCPoolClass, this)
   this->size = sizeof(AMCStruct);
   this->offset = offsetof(AMCStruct, poolStruct);
   this->attr |= AttrMOVINGGC;
+  this->varargs = AMCVarargs;
   this->init = AMCInit;
   this->finish = AMCFinish;
   this->bufferFill = AMCBufferFill;
diff --git a/mps/code/poolams.c b/mps/code/poolams.c
index bc4b4606a3d..757e0a45d17 100644
--- a/mps/code/poolams.c
+++ b/mps/code/poolams.c
@@ -728,6 +728,28 @@ static void AMSSegsDestroy(AMS ams)
 }
 
 
+/* AMSVarargs -- decode obsolete varargs */
+
+static void AMSVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_FORMAT;
+  args[0].val.format = va_arg(varargs, Format);
+  args[1].key = MPS_KEY_CHAIN;
+  args[1].val.chain = va_arg(varargs, Chain);
+  args[2].key = MPS_KEY_AMS_SUPPORT_AMBIGUOUS;
+  args[2].val.b = va_arg(varargs, Bool);
+  args[3].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+static void AMSDebugVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_POOL_DEBUG_OPTION;
+  args[0].val.pool_debug_option = va_arg(varargs, mps_pool_debug_option_s *);
+  AMSVarargs(args + 1, varargs);
+}
+
+
 /* AMSInit -- the pool class initialization method
  *
  *  Takes one additional argument: the format of the objects
@@ -1668,6 +1690,7 @@ DEFINE_CLASS(AMSPoolClass, this)
   this->name = "AMS";
   this->size = sizeof(AMSStruct);
   this->offset = offsetof(AMSStruct, poolStruct);
+  this->varargs = AMSVarargs;
   this->init = AMSInit;
   this->finish = AMSFinish;
   this->bufferClass = RankBufClassGet;
@@ -1706,6 +1729,7 @@ DEFINE_POOL_CLASS(AMSDebugPoolClass, this)
   PoolClassMixInDebug(this);
   this->name = "AMSDBG";
   this->size = sizeof(AMSDebugStruct);
+  this->varargs = AMSDebugVarargs;
   this->debugMixin = AMSDebugMixin;
 }
 
diff --git a/mps/code/poolawl.c b/mps/code/poolawl.c
index 382105455ab..5321e164953 100644
--- a/mps/code/poolawl.c
+++ b/mps/code/poolawl.c
@@ -509,6 +509,19 @@ static Bool AWLSegAlloc(Addr *baseReturn, Addr *limitReturn,
 }
 
 
+/* AWLVarargs -- decode obsolete varargs */
+
+static void AWLVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_FORMAT;
+  args[0].val.format = va_arg(varargs, Format);
+  args[1].key = MPS_KEY_AWL_FIND_DEPENDENT;
+  args[1].val.addr_method = va_arg(varargs, mps_awl_find_dependent_t);
+  args[2].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+
 /* AWLInit -- initialize an AWL pool */
 
 const KeyStruct _mps_key_awl_find_dependent = {
@@ -1258,6 +1271,7 @@ DEFINE_POOL_CLASS(AWLPoolClass, this)
   this->name = "AWL";
   this->size = sizeof(AWLStruct);
   this->offset = offsetof(AWLStruct, poolStruct);
+  this->varargs = AWLVarargs;
   this->init = AWLInit;
   this->finish = AWLFinish;
   this->bufferClass = RankBufClassGet;
diff --git a/mps/code/poollo.c b/mps/code/poollo.c
index 4e5aee2aac3..541f0901781 100644
--- a/mps/code/poollo.c
+++ b/mps/code/poollo.c
@@ -467,6 +467,17 @@ static void LOWalk(Pool pool, Seg seg,
 }
 
 
+/* LOVarargs -- decode obsolete varargs */
+
+static void LOVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_FORMAT;
+  args[0].val.format = va_arg(varargs, Format);
+  args[1].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+
 /* LOInit -- initialize an LO pool */
 
 static Res LOInit(Pool pool, ArgList args)
@@ -787,6 +798,7 @@ DEFINE_POOL_CLASS(LOPoolClass, this)
   this->size = sizeof(LOStruct);
   this->offset = offsetof(LOStruct, poolStruct);
   this->attr &= ~(AttrSCAN | AttrINCR_RB);
+  this->varargs = LOVarargs;
   this->init = LOInit;
   this->finish = LOFinish;
   this->bufferFill = LOBufferFill;
diff --git a/mps/code/poolmfs.c b/mps/code/poolmfs.c
index a103bea543c..8a9b3ff1c7d 100644
--- a/mps/code/poolmfs.c
+++ b/mps/code/poolmfs.c
@@ -77,6 +77,19 @@ Pool (MFSPool)(MFS mfs)
 }
 
 
+/* MFSVarargs -- decode obsolete varargs */
+
+static void MFSVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_MFS_EXTEND_BY;
+  args[0].val.size = va_arg(varargs, Size);
+  args[1].key = MPS_KEY_MFS_UNIT_SIZE;
+  args[1].val.size = va_arg(varargs, Size);
+  args[2].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+
 const KeyStruct _mps_mfs_extend_by = {KeySig, "MFS_EXTEND_BY", ArgCheckCant};
 const KeyStruct _mps_mfs_unit_size = {KeySig, "MFS_UNIT_SIZE", ArgCheckCant};
 
@@ -289,6 +302,7 @@ DEFINE_POOL_CLASS(MFSPoolClass, this)
   this->name = "MFS";
   this->size = sizeof(MFSStruct);
   this->offset = offsetof(MFSStruct, poolStruct);
+  this->varargs = MFSVarargs;
   this->init = MFSInit;
   this->finish = MFSFinish;
   this->alloc = MFSAlloc;
diff --git a/mps/code/poolmv.c b/mps/code/poolmv.c
index b9b5470b9a6..fc37530390c 100644
--- a/mps/code/poolmv.c
+++ b/mps/code/poolmv.c
@@ -182,6 +182,28 @@ static Bool MVSpanCheck(MVSpan span)
 }
 
 
+/* MVVarargs -- decode obsolete varargs */
+
+static void MVVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_MV_EXTEND_BY;
+  args[0].val.size = va_arg(varargs, Size);
+  args[1].key = MPS_KEY_MV_AVG_SIZE;
+  args[1].val.size = va_arg(varargs, Size);
+  args[2].key = MPS_KEY_MV_MAX_SIZE;
+  args[2].val.size = va_arg(varargs, Size);
+  args[3].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+static void MVDebugVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_POOL_DEBUG_OPTION;
+  args[0].val.pool_debug_option = va_arg(varargs, mps_pool_debug_option_s *);
+  MVVarargs(args + 1, varargs);
+}
+
+
 /* MVInit -- init method for class MV */
 
 const KeyStruct _mps_key_mv_extend_by = {KeySig, "MV_EXTEND_BY", ArgCheckCant};
@@ -771,6 +793,7 @@ DEFINE_POOL_CLASS(MVPoolClass, this)
   this->name = "MV";
   this->size = sizeof(MVStruct);
   this->offset = offsetof(MVStruct, poolStruct);
+  this->varargs = MVVarargs;
   this->init = MVInit;
   this->finish = MVFinish;
   this->alloc = MVAlloc;
@@ -793,6 +816,7 @@ DEFINE_POOL_CLASS(MVDebugPoolClass, this)
   PoolClassMixInDebug(this);
   this->name = "MVDBG";
   this->size = sizeof(MVDebugStruct);
+  this->varargs = MVDebugVarargs;
   this->debugMixin = MVDebugMixin;
 }
 
diff --git a/mps/code/poolmv2.c b/mps/code/poolmv2.c
index 9c537171ff0..f2c0cc38f32 100644
--- a/mps/code/poolmv2.c
+++ b/mps/code/poolmv2.c
@@ -27,6 +27,7 @@ SRCID(poolmv2, "$Id$");
 /* Private prototypes */
 
 typedef struct MVTStruct *MVT;
+static void MVTVarargs(ArgStruct args[], va_list varargs);
 static Res MVTInit(Pool pool, ArgList arg);
 static Bool MVTCheck(MVT mvt);
 static void MVTFinish(Pool pool);
@@ -139,6 +140,7 @@ DEFINE_POOL_CLASS(MVTPoolClass, this)
   this->size = sizeof(MVTStruct);
   this->offset = offsetof(MVTStruct, poolStruct);
   this->attr |= AttrFREE;
+  this->varargs = MVTVarargs;
   this->init = MVTInit;
   this->finish = MVTFinish;
   this->free = MVTFree;
@@ -189,16 +191,47 @@ static SegPref MVTSegPref(MVT mvt)
 /* Methods */
 
 
+/* MVTVarargs -- decode obsolete varargs */
+
+static void MVTVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_MVT_MIN_SIZE;
+  args[0].val.size = va_arg(varargs, Size);
+  args[1].key = MPS_KEY_MVT_MEAN_SIZE;
+  args[1].val.size = va_arg(varargs, Size);
+  args[2].key = MPS_KEY_MVT_MAX_SIZE;
+  args[2].val.size = va_arg(varargs, Size);
+  args[3].key = MPS_KEY_MVT_RESERVE_DEPTH;
+  args[3].val.count = va_arg(varargs, Count);
+  args[4].key = MPS_KEY_MVT_FRAG_LIMIT;
+  args[4].val.count = va_arg(varargs, Count);
+  args[5].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+
 /* MVTInit -- initialize an MVT pool
  *
  * Parameters are:
  * minSize, meanSize, maxSize, reserveDepth, fragLimit
  */
+
+const KeyStruct _mps_key_mvt_min_size = {KeySig, "MVT_MIN_SIZE", ArgCheckCant};
+const KeyStruct _mps_key_mvt_mean_size = {KeySig, "MVT_MEAN_SIZE", ArgCheckCant};
+const KeyStruct _mps_key_mvt_max_size = {KeySig, "MVT_MAX_SIZE", ArgCheckCant};
+const KeyStruct _mps_key_mvt_reserve_depth = {KeySig, "MVT_RESERVE_DEPTH", ArgCheckCant};
+const KeyStruct _mps_key_mvt_frag_limit = {KeySig, "MVT_FRAG_LIMIT", ArgCheckCant};
+
 static Res MVTInit(Pool pool, ArgList args)
 {
   Arena arena;
-  Size minSize, meanSize, maxSize, reuseSize, fillSize;
-  Count reserveDepth, abqDepth, fragLimit;
+  Size minSize = MVT_MIN_SIZE_DEFAULT;
+  Size meanSize = MVT_MEAN_SIZE_DEFAULT;
+  Size maxSize = MVT_MAX_SIZE_DEFAULT;
+  Count reserveDepth = MVT_RESERVE_DEPTH_DEFAULT;
+  Count fragLimit = MVT_FRAG_LIMIT_DEFAULT;
+  Size reuseSize, fillSize;
+  Count abqDepth;
   MVT mvt;
   Res res;
   ArgStruct arg;
@@ -209,30 +242,35 @@ static Res MVTInit(Pool pool, ArgList args)
   arena = PoolArena(pool);
   AVERT(Arena, arena);
   
-  if (ArgPick(&arg, args, MPS_KEY_VARARGS)) {
-    /* FIXME: Inconsistent reporting of bad arguments.  Elsewhere we assert or return ResPARAM. */
-    /* --- Should there be a ResBADARG ? */
-    minSize = va_arg(arg.val.varargs, Size);
+
+  /* FIXME: Inconsistent reporting of bad arguments.  Elsewhere we assert or return ResPARAM. */
+  /* --- Should there be a ResBADARG ? */
+  if (ArgPick(&arg, args, MPS_KEY_MVT_MIN_SIZE)) {
+    minSize = arg.val.size;
     unless (minSize > 0)
       return ResLIMIT;
-    meanSize = va_arg(arg.val.varargs, Size);
+  }
+  if (ArgPick(&arg, args, MPS_KEY_MVT_MEAN_SIZE)) {
+    meanSize = arg.val.size;
     unless (meanSize >= minSize)
       return ResLIMIT;
-    maxSize = va_arg(arg.val.varargs, Size);
+  }
+  if (ArgPick(&arg, args, MPS_KEY_MVT_MAX_SIZE)) {
+    maxSize = arg.val.size;
     unless (maxSize >= meanSize)
       return ResLIMIT;
+  }
+  if (ArgPick(&arg, args, MPS_KEY_MVT_RESERVE_DEPTH)) {
     /* --- check that maxSize is not too large */
-    reserveDepth = va_arg(arg.val.varargs, Count);
+    reserveDepth = arg.val.count;
     unless (reserveDepth > 0)
       return ResLIMIT;
+  }
+  if (ArgPick(&arg, args, MPS_KEY_MVT_FRAG_LIMIT)) {
     /* --- check that reserveDepth is not too large or small */
-    fragLimit = va_arg(arg.val.varargs, Count);
+    fragLimit = arg.val.count;
     unless (fragLimit <= 100)
       return ResLIMIT;
-  } else {
-    /* FIXME: Keywords not yet supported. */
-    res = ResPARAM;
-    goto failParam;
   }
 
   /* see <design/poolmvt/#arch.parameters> */
@@ -327,7 +365,6 @@ static Res MVTInit(Pool pool, ArgList args)
 failABQ:
   CBSFinish(MVTCBS(mvt));
 failCBS:
-failParam:
   AVER(res != ResOK);
   return res;
 }
diff --git a/mps/code/poolmvff.c b/mps/code/poolmvff.c
index 9b17dc7252e..8cc31a5e45c 100644
--- a/mps/code/poolmvff.c
+++ b/mps/code/poolmvff.c
@@ -407,14 +407,42 @@ static void MVFFBufferEmpty(Pool pool, Buffer buffer,
 }
 
 
+/* MVFFVarargs -- decode obsolete varargs */
+
+static void MVFFVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_MVFF_EXTEND_BY;
+  args[0].val.size = va_arg(varargs, Size);
+  args[1].key = MPS_KEY_MVFF_AVG_SIZE;
+  args[1].val.size = va_arg(varargs, Size);
+  args[2].key = MPS_KEY_MVFF_ALIGN;
+  args[2].val.align = va_arg(varargs, Size); /* promoted type */
+  args[3].key = MPS_KEY_MVFF_SLOT_HIGH;
+  args[3].val.b = va_arg(varargs, Bool);
+  args[4].key = MPS_KEY_MVFF_ARENA_HIGH;
+  args[4].val.b = va_arg(varargs, Bool);
+  args[5].key = MPS_KEY_MVFF_FIRST_FIT;
+  args[5].val.b = va_arg(varargs, Bool);
+  args[6].key = MPS_KEY_ARGS_END;
+  AVER(ArgListCheck(args));
+}
+
+static void MVFFDebugVarargs(ArgStruct args[], va_list varargs)
+{
+  args[0].key = MPS_KEY_POOL_DEBUG_OPTION;
+  args[0].val.pool_debug_option = va_arg(varargs, mps_pool_debug_option_s *);
+  MVFFVarargs(args + 1, varargs);
+}
+
+
 /* MVFFInit -- initialize method for MVFF */
 
-const KeyStruct _mps_key_mvff_extend_by = {KeySig, "EXTEND_BY", ArgCheckCant};
-const KeyStruct _mps_key_mvff_avg_size = {KeySig, "AVG_SIZE", ArgCheckCant};
-const KeyStruct _mps_key_mvff_align = {KeySig, "ALIGN", ArgCheckCant}; /* FIXME: ArgCheckAlign */
-const KeyStruct _mps_key_mvff_slot_high = {KeySig, "SLOT_HIGH", ArgCheckCant}; /* FIXME: ArgCheckBool */
-const KeyStruct _mps_key_mvff_arena_high = {KeySig, "ARENA_HIGH", ArgCheckCant}; /* FIXME: ArgCheckBool */
-const KeyStruct _mps_key_mvff_first_fit = {KeySig, "FIRST_FIT", ArgCheckCant}; /* FIXME: ArgCheckBool */
+const KeyStruct _mps_key_mvff_extend_by = {KeySig, "MVFF_EXTEND_BY", ArgCheckCant};
+const KeyStruct _mps_key_mvff_avg_size = {KeySig, "MVFF_AVG_SIZE", ArgCheckCant};
+const KeyStruct _mps_key_mvff_align = {KeySig, "MVFF_ALIGN", ArgCheckCant}; /* FIXME: ArgCheckAlign */
+const KeyStruct _mps_key_mvff_slot_high = {KeySig, "MVFF_SLOT_HIGH", ArgCheckCant}; /* FIXME: ArgCheckBool */
+const KeyStruct _mps_key_mvff_arena_high = {KeySig, "MVFF_ARENA_HIGH", ArgCheckCant}; /* FIXME: ArgCheckBool */
+const KeyStruct _mps_key_mvff_first_fit = {KeySig, "MVFF_FIRST_FIT", ArgCheckCant}; /* FIXME: ArgCheckBool */
 
 static Res MVFFInit(Pool pool, ArgList args)
 {
@@ -597,6 +625,7 @@ DEFINE_POOL_CLASS(MVFFPoolClass, this)
   this->name = "MVFF";
   this->size = sizeof(MVFFStruct);
   this->offset = offsetof(MVFFStruct, poolStruct);
+  this->varargs = MVFFVarargs;
   this->init = MVFFInit;
   this->finish = MVFFFinish;
   this->alloc = MVFFAlloc;
@@ -621,6 +650,7 @@ DEFINE_POOL_CLASS(MVFFDebugPoolClass, this)
   PoolClassMixInDebug(this);
   this->name = "MVFFDBG";
   this->size = sizeof(MVFFDebugStruct);
+  this->varargs = MVFFDebugVarargs;
   this->debugMixin = MVFFDebugMixin;
 }