From 78d5f049f0e60bd0c903bc331c253f681d082cea Mon Sep 17 00:00:00 2001 From: Richard Brooksby Date: Fri, 7 Sep 2012 12:58:57 +0100 Subject: [PATCH] Eliminating type puns on scan states, location dependencies, and allocation points through the mps interface. Now that we're recommending inlining with client code and optimising with -O2 or -O3, we can't afford any bug introduced by the strict aliasing rule. Copied from Perforce Change: 179322 ServerID: perforce.ravenbrook.com --- mps/code/amcss.c | 8 +- mps/code/amcsshe.c | 10 +- mps/code/amcssth.c | 10 +- mps/code/amsss.c | 8 +- mps/code/amssshe.c | 8 +- mps/code/apss.c | 2 +- mps/code/awlut.c | 10 +- mps/code/awluthe.c | 10 +- mps/code/awlutth.c | 10 +- mps/code/buffer.c | 172 +++++++++++++++-------------- mps/code/exposet0.c | 8 +- mps/code/expt825.c | 4 +- mps/code/finalcv.c | 6 +- mps/code/finaltest.c | 4 +- mps/code/ld.c | 38 +++---- mps/code/locv.c | 4 +- mps/code/mpm.h | 46 +++++--- mps/code/mpmst.h | 74 ++++--------- mps/code/mpmtypes.h | 4 +- mps/code/mps.h | 69 +++++++----- mps/code/mpsi.c | 257 ++++++++++++++----------------------------- mps/code/mpsicv.c | 10 +- mps/code/mv2test.c | 2 +- mps/code/poolamc.c | 8 +- mps/code/qs.c | 6 +- mps/code/segsmss.c | 10 +- mps/code/steptest.c | 6 +- mps/code/testlib.h | 2 +- mps/code/trace.c | 36 +++--- mps/code/walkt0.c | 4 +- mps/code/zcoll.c | 6 +- mps/code/zmess.c | 4 +- 32 files changed, 379 insertions(+), 477 deletions(-) diff --git a/mps/code/amcss.c b/mps/code/amcss.c index a6b47bf1914..236713cdf12 100644 --- a/mps/code/amcss.c +++ b/mps/code/amcss.c @@ -182,8 +182,8 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "pool_create(amc)"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; @@ -191,12 +191,12 @@ static void *test(void *arg, size_t s) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); diff --git a/mps/code/amcsshe.c b/mps/code/amcsshe.c index 646f6c4f90b..1b8d3696b88 100644 --- a/mps/code/amcsshe.c +++ b/mps/code/amcsshe.c @@ -127,8 +127,8 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "pool_create(amc)"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; @@ -136,16 +136,16 @@ static void *test(void *arg, size_t s) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); die(mps_root_create_table(&bogusRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &bogusRoots[0], bogusRootsCOUNT), "root_create_table(bogus)"); diff --git a/mps/code/amcssth.c b/mps/code/amcssth.c index 08597be51a4..81eb0ad9b0d 100644 --- a/mps/code/amcssth.c +++ b/mps/code/amcssth.c @@ -133,12 +133,12 @@ static void init(void) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); } @@ -196,8 +196,8 @@ static void *test(void *arg, size_t s) arena = (mps_arena_t)arg; (void)s; /* unused */ - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); /* create an ap, and leave it busy */ die(mps_reserve(&busy_init, busy_ap, 64), "mps_reserve busy"); @@ -281,7 +281,7 @@ static void *fooey2(void *arg, size_t s) mps_ap_t ap; (void)arg; (void)s; /* unused */ - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate(fooey)"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate(fooey)"); while(mps_collections(arena) < collectionsCOUNT) { churn(ap); } diff --git a/mps/code/amsss.c b/mps/code/amsss.c index 956bd4f58a0..27d6d69d9a3 100644 --- a/mps/code/amsss.c +++ b/mps/code/amsss.c @@ -126,8 +126,8 @@ static void *test(void *arg, size_t haveAmbigous) pool = (mps_pool_t)arg; - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; @@ -136,13 +136,13 @@ static void *test(void *arg, size_t haveAmbigous) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); if (haveAmbigous) die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); diff --git a/mps/code/amssshe.c b/mps/code/amssshe.c index cc37010fe20..5457c13ee25 100644 --- a/mps/code/amssshe.c +++ b/mps/code/amssshe.c @@ -83,8 +83,8 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool, arena, mps_class_ams(), format, chain, TRUE), "pool_create(ams)"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; @@ -92,12 +92,12 @@ static void *test(void *arg, size_t s) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); diff --git a/mps/code/apss.c b/mps/code/apss.c index 7b6472a5099..e23aee22f24 100644 --- a/mps/code/apss.c +++ b/mps/code/apss.c @@ -57,7 +57,7 @@ static mps_res_t stress(mps_class_t class, size_t (*size)(int i), if (res != MPS_RES_OK) return res; - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); /* allocate a load of objects */ for (i=0; iarena; thr = guff->thr; - die(mps_root_create_reg(&stack, arena, MPS_RANK_AMBIG, 0, thr, + die(mps_root_create_reg(&stack, arena, mps_rank_ambig(), 0, thr, mps_stack_scan_ambig, v, 0), "Root Create\n"); die(mps_fmt_create_A(&dylanfmt, arena, dylan_fmt_A()), @@ -269,13 +269,13 @@ static void *setup(void *v, size_t s) die(mps_pool_create(&tablepool, arena, mps_class_awl(), dylanweakfmt, dylan_weak_dependent), "Table Pool Create\n"); - die(mps_ap_create(&leafap, leafpool, MPS_RANK_EXACT), + die(mps_ap_create(&leafap, leafpool, mps_rank_exact()), "Leaf AP Create\n"); - die(mps_ap_create(&exactap, tablepool, MPS_RANK_EXACT), + die(mps_ap_create(&exactap, tablepool, mps_rank_exact()), "Exact AP Create\n"); - die(mps_ap_create(&weakap, tablepool, MPS_RANK_WEAK), + die(mps_ap_create(&weakap, tablepool, mps_rank_weak()), "Weak AP Create\n"); - die(mps_ap_create(&bogusap, tablepool, MPS_RANK_EXACT), + die(mps_ap_create(&bogusap, tablepool, mps_rank_exact()), "Bogus AP Create\n"); test(leafap, exactap, weakap, bogusap); diff --git a/mps/code/awluthe.c b/mps/code/awluthe.c index 4b8d96df371..ea08a3bdef7 100644 --- a/mps/code/awluthe.c +++ b/mps/code/awluthe.c @@ -262,7 +262,7 @@ static void *setup(void *v, size_t s) arena = guff->arena; thr = guff->thr; - die(mps_root_create_reg(&stack, arena, MPS_RANK_AMBIG, 0, thr, + die(mps_root_create_reg(&stack, arena, mps_rank_ambig(), 0, thr, mps_stack_scan_ambig, v, 0), "Root Create\n"); EnsureHeaderFormat(&dylanfmt, arena); @@ -272,13 +272,13 @@ static void *setup(void *v, size_t s) die(mps_pool_create(&tablepool, arena, mps_class_awl(), dylanweakfmt, dylan_weak_dependent), "Table Pool Create\n"); - die(mps_ap_create(&leafap, leafpool, MPS_RANK_EXACT), + die(mps_ap_create(&leafap, leafpool, mps_rank_exact()), "Leaf AP Create\n"); - die(mps_ap_create(&exactap, tablepool, MPS_RANK_EXACT), + die(mps_ap_create(&exactap, tablepool, mps_rank_exact()), "Exact AP Create\n"); - die(mps_ap_create(&weakap, tablepool, MPS_RANK_WEAK), + die(mps_ap_create(&weakap, tablepool, mps_rank_weak()), "Weak AP Create\n"); - die(mps_ap_create(&bogusap, tablepool, MPS_RANK_EXACT), + die(mps_ap_create(&bogusap, tablepool, mps_rank_exact()), "Bogus AP Create\n"); test(leafap, exactap, weakap, bogusap); diff --git a/mps/code/awlutth.c b/mps/code/awlutth.c index 26ef8c2c70d..3a5c9ee0fb1 100644 --- a/mps/code/awlutth.c +++ b/mps/code/awlutth.c @@ -255,7 +255,7 @@ static void *setup(void *v, size_t s) arena = guff->arena; thr = guff->thr; - die(mps_root_create_reg(&stack, arena, MPS_RANK_AMBIG, 0, thr, + die(mps_root_create_reg(&stack, arena, mps_rank_ambig(), 0, thr, mps_stack_scan_ambig, v, 0), "Root Create\n"); die(mps_fmt_create_A(&dylanfmt, arena, dylan_fmt_A()), @@ -267,13 +267,13 @@ static void *setup(void *v, size_t s) die(mps_pool_create(&tablepool, arena, mps_class_awl(), dylanweakfmt, dylan_weak_dependent), "Table Pool Create\n"); - die(mps_ap_create(&leafap, leafpool, MPS_RANK_EXACT), + die(mps_ap_create(&leafap, leafpool, mps_rank_exact()), "Leaf AP Create\n"); - die(mps_ap_create(&exactap, tablepool, MPS_RANK_EXACT), + die(mps_ap_create(&exactap, tablepool, mps_rank_exact()), "Exact AP Create\n"); - die(mps_ap_create(&weakap, tablepool, MPS_RANK_WEAK), + die(mps_ap_create(&weakap, tablepool, mps_rank_weak()), "Weak AP Create\n"); - die(mps_ap_create(&bogusap, tablepool, MPS_RANK_EXACT), + die(mps_ap_create(&bogusap, tablepool, mps_rank_exact()), "Bogus AP Create\n"); test(leafap, exactap, weakap, bogusap); diff --git a/mps/code/buffer.c b/mps/code/buffer.c index f446ab5b9a0..b33c08dc239 100644 --- a/mps/code/buffer.c +++ b/mps/code/buffer.c @@ -51,14 +51,14 @@ Bool BufferCheck(Buffer buffer) CHECKL(buffer->emptySize <= buffer->fillSize); CHECKL(buffer->alignment == buffer->pool->alignment); CHECKL(AlignCheck(buffer->alignment)); - CHECKL(BoolCheck(buffer->apStruct.enabled)); + CHECKL(BoolCheck(buffer->ap_s._enabled)); - if (buffer->apStruct.enabled) { + if (buffer->ap_s._enabled) { /* no useful check for frameptr - mutator may be updating it */ - CHECKL(BoolCheck(buffer->apStruct.lwPopPending)); + CHECKL(BoolCheck(buffer->ap_s._lwpoppending)); } else { - CHECKL(buffer->apStruct.lwPopPending == FALSE); - CHECKL(buffer->apStruct.frameptr == NULL); + CHECKL(buffer->ap_s._lwpoppending == FALSE); + CHECKL(buffer->ap_s._frameptr == NULL); } /* If any of the buffer's fields indicate that it is reset, make */ @@ -68,15 +68,15 @@ Bool BufferCheck(Buffer buffer) /* nothing to check */ } else if ((buffer->mode & BufferModeATTACHED) == 0 || buffer->base == (Addr)0 - || buffer->apStruct.init == (Addr)0 - || buffer->apStruct.alloc == (Addr)0 + || buffer->ap_s.init == (Addr)0 + || buffer->ap_s.alloc == (Addr)0 || buffer->poolLimit == (Addr)0) { CHECKL((buffer->mode & BufferModeATTACHED) == 0); CHECKL(buffer->base == (Addr)0); CHECKL(buffer->initAtFlip == (Addr)0); - CHECKL(buffer->apStruct.init == (Addr)0); - CHECKL(buffer->apStruct.alloc == (Addr)0); - CHECKL(buffer->apStruct.limit == (Addr)0); + CHECKL(buffer->ap_s.init == (Addr)0); + CHECKL(buffer->ap_s.alloc == (Addr)0); + CHECKL(buffer->ap_s.limit == (Addr)0); /* Nothing reliable to check for lightweight frame state */ CHECKL(buffer->poolLimit == (Addr)0); } else { @@ -88,16 +88,16 @@ Bool BufferCheck(Buffer buffer) /* These fields should obey the ordering */ /* base <= init <= alloc <= poolLimit */ - CHECKL(buffer->base <= buffer->apStruct.init); - CHECKL(buffer->apStruct.init <= buffer->apStruct.alloc); - CHECKL(buffer->apStruct.alloc <= buffer->poolLimit); + CHECKL((mps_addr_t)buffer->base <= buffer->ap_s.init); + CHECKL(buffer->ap_s.init <= buffer->ap_s.alloc); + CHECKL(buffer->ap_s.alloc <= (mps_addr_t)buffer->poolLimit); /* Check that the fields are aligned to the buffer alignment. */ CHECKL(AddrIsAligned(buffer->base, buffer->alignment)); CHECKL(AddrIsAligned(buffer->initAtFlip, buffer->alignment)); - CHECKL(AddrIsAligned(buffer->apStruct.init, buffer->alignment)); - CHECKL(AddrIsAligned(buffer->apStruct.alloc, buffer->alignment)); - CHECKL(AddrIsAligned(buffer->apStruct.limit, buffer->alignment)); + CHECKL(AddrIsAligned(buffer->ap_s.init, buffer->alignment)); + CHECKL(AddrIsAligned(buffer->ap_s.alloc, buffer->alignment)); + CHECKL(AddrIsAligned(buffer->ap_s.limit, buffer->alignment)); CHECKL(AddrIsAligned(buffer->poolLimit, buffer->alignment)); /* .lwcheck: If LW frames are enabled, the buffer may become */ @@ -106,7 +106,7 @@ Bool BufferCheck(Buffer buffer) /* Read a snapshot value of the limit field. Use this to determine */ /* if we are trapped, and to permit more useful checking when not */ /* yet trapped. */ - aplimit = buffer->apStruct.limit; + aplimit = buffer->ap_s.limit; /* If the buffer isn't trapped then "limit" should be the limit */ /* set by the owning pool. Otherwise, "init" is either at the */ @@ -117,17 +117,17 @@ Bool BufferCheck(Buffer buffer) /* is kept at zero to avoid misuse (see */ /* request.dylan.170429.sol.zero). */ - if ((buffer->apStruct.enabled && aplimit == (Addr)0) /* see .lwcheck */ - || (!buffer->apStruct.enabled && BufferIsTrapped(buffer))) { + if ((buffer->ap_s._enabled && aplimit == (Addr)0) /* see .lwcheck */ + || (!buffer->ap_s._enabled && BufferIsTrapped(buffer))) { /* .check.use-trapped: This checking function uses BufferIsTrapped, */ /* So BufferIsTrapped can't do checking as that would cause an */ /* infinite loop. */ CHECKL(aplimit == (Addr)0); if (buffer->mode & BufferModeFLIPPED) { - CHECKL(buffer->apStruct.init == buffer->initAtFlip - || buffer->apStruct.init == buffer->apStruct.alloc); + CHECKL(buffer->ap_s.init == buffer->initAtFlip + || buffer->ap_s.init == buffer->ap_s.alloc); CHECKL(buffer->base <= buffer->initAtFlip); - CHECKL(buffer->initAtFlip <= buffer->apStruct.init); + CHECKL(buffer->initAtFlip <= (Addr)buffer->ap_s.init); } /* Nothing special to check in the logged mode. */ } else { @@ -174,9 +174,9 @@ Res BufferDescribe(Buffer buffer, mps_lib_FILE *stream) " alignment $W\n", (WriteFW)buffer->alignment, " base $A\n", buffer->base, " initAtFlip $A\n", buffer->initAtFlip, - " init $A\n", buffer->apStruct.init, - " alloc $A\n", buffer->apStruct.alloc, - " limit $A\n", buffer->apStruct.limit, + " init $A\n", buffer->ap_s.init, + " alloc $A\n", buffer->ap_s.alloc, + " limit $A\n", buffer->ap_s.limit, " poolLimit $A\n", buffer->poolLimit, NULL); if (res != ResOK) return res; @@ -223,12 +223,15 @@ static Res BufferInitV(Buffer buffer, BufferClass class, buffer->alignment = pool->alignment; /* .trans.mod */ buffer->base = (Addr)0; buffer->initAtFlip = (Addr)0; - buffer->apStruct.init = (Addr)0; - buffer->apStruct.alloc = (Addr)0; - buffer->apStruct.limit = (Addr)0; - buffer->apStruct.frameptr = NULL; - buffer->apStruct.enabled = FALSE; - buffer->apStruct.lwPopPending = FALSE; + /* In the next three assignements we really mean zero, not NULL, because + the bit pattern is compared. It's pretty unlikely we'll encounter + a platform where this makes a difference. */ + buffer->ap_s.init = (mps_addr_t)0; + buffer->ap_s.alloc = (mps_addr_t)0; + buffer->ap_s.limit = (mps_addr_t)0; + buffer->ap_s._frameptr = NULL; + buffer->ap_s._enabled = FALSE; + buffer->ap_s._lwpoppending = FALSE; buffer->poolLimit = (Addr)0; buffer->rampCount = 0; @@ -327,7 +330,7 @@ void BufferDetach(Buffer buffer, Pool pool) Size spare; buffer->mode |= BufferModeTRANSITION; - init = buffer->apStruct.init; + init = buffer->ap_s.init; limit = buffer->poolLimit; /* Ask the owning pool to do whatever it needs to before the */ /* buffer is detached (e.g. copy buffer state into pool state). */ @@ -353,9 +356,9 @@ void BufferDetach(Buffer buffer, Pool pool) /* Reset the buffer. */ buffer->base = (Addr)0; buffer->initAtFlip = (Addr)0; - buffer->apStruct.init = (Addr)0; - buffer->apStruct.alloc = (Addr)0; - buffer->apStruct.limit = (Addr)0; + buffer->ap_s.init = (mps_addr_t)0; + buffer->ap_s.alloc = (mps_addr_t)0; + buffer->ap_s.limit = (mps_addr_t)0; buffer->poolLimit = (Addr)0; buffer->mode &= ~(BufferModeATTACHED|BufferModeFLIPPED|BufferModeTRANSITION); @@ -445,7 +448,7 @@ Bool BufferIsReady(Buffer buffer) { AVERT(Buffer, buffer); - return buffer->apStruct.init == buffer->apStruct.alloc; + return buffer->ap_s.init == buffer->ap_s.alloc; } @@ -470,9 +473,9 @@ static void BufferSetUnflipped(Buffer buffer) AVERT(Buffer, buffer); AVER(buffer->mode & BufferModeFLIPPED); buffer->mode &= ~BufferModeFLIPPED; - /* restore apStruct.limit if appropriate */ + /* restore ap_s.limit if appropriate */ if (!BufferIsTrapped(buffer)) { - buffer->apStruct.limit = buffer->poolLimit; + buffer->ap_s.limit = buffer->poolLimit; } buffer->initAtFlip = (Addr)0; } @@ -486,16 +489,16 @@ static void BufferSetUnflipped(Buffer buffer) FrameState BufferFrameState(Buffer buffer) { AVERT(Buffer, buffer); - if (buffer->apStruct.enabled) { - if (buffer->apStruct.lwPopPending) { + if (buffer->ap_s._enabled) { + if (buffer->ap_s._lwpoppending) { return BufferFramePOP_PENDING; } else { - AVER(buffer->apStruct.frameptr == NULL); + AVER(buffer->ap_s._frameptr == NULL); return BufferFrameVALID; } } else { - AVER(buffer->apStruct.frameptr == NULL); - AVER(buffer->apStruct.lwPopPending == FALSE); + AVER(buffer->ap_s._frameptr == NULL); + AVER(buffer->ap_s._lwpoppending == FALSE); return BufferFrameDISABLED; } } @@ -510,9 +513,9 @@ void BufferFrameSetState(Buffer buffer, FrameState state) { AVERT(Buffer, buffer); AVER(state == BufferFrameVALID || state == BufferFrameDISABLED); - buffer->apStruct.frameptr = NULL; - buffer->apStruct.lwPopPending = FALSE; - buffer->apStruct.enabled = (state == BufferFrameVALID); + buffer->ap_s._frameptr = NULL; + buffer->ap_s._lwpoppending = FALSE; + buffer->ap_s._enabled = (state == BufferFrameVALID); } @@ -528,8 +531,8 @@ void BufferSetAllocAddr(Buffer buffer, Addr addr) AVER(buffer->base <= addr); AVER(buffer->poolLimit >= addr); - buffer->apStruct.init = addr; - buffer->apStruct.alloc = addr; + buffer->ap_s.init = addr; + buffer->ap_s.alloc = addr; } @@ -545,13 +548,13 @@ static void BufferFrameNotifyPopPending(Buffer buffer) Pool pool; AVER(BufferIsTrappedByMutator(buffer)); AVER(BufferFrameState(buffer) == BufferFramePOP_PENDING); - frame = (AllocFrame)buffer->apStruct.frameptr; + frame = (AllocFrame)buffer->ap_s._frameptr; /* Unset PopPending state & notify the pool */ BufferFrameSetState(buffer, BufferFrameVALID); /* If the frame is no longer trapped, undo the trap by resetting */ /* the AP limit pointer */ if (!BufferIsTrapped(buffer)) { - buffer->apStruct.limit = buffer->poolLimit; + buffer->ap_s.limit = buffer->poolLimit; } pool = BufferPool(buffer); (*pool->class->framePopPending)(pool, buffer, frame); @@ -571,7 +574,7 @@ Res BufferFramePush(AllocFrame *frameReturn, Buffer buffer) /* Process any flip or PopPending */ - if (!BufferIsReset(buffer) && buffer->apStruct.limit == (Addr)0) { + if (!BufferIsReset(buffer) && buffer->ap_s.limit == (Addr)0) { /* .fill.unflip: If the buffer is flipped then we unflip the buffer. */ if (buffer->mode & BufferModeFLIPPED) { BufferSetUnflipped(buffer); @@ -622,10 +625,11 @@ Res BufferReserve(Addr *pReturn, Buffer buffer, Size size, /* Is there enough room in the unallocated portion of the buffer to */ /* satisfy the request? If so, just increase the alloc marker and */ /* return a pointer to the area below it. */ - next = AddrAdd(buffer->apStruct.alloc, size); - if (next > buffer->apStruct.alloc && next <= buffer->apStruct.limit) { - buffer->apStruct.alloc = next; - *pReturn = buffer->apStruct.init; + next = AddrAdd(buffer->ap_s.alloc, size); + if (next > (Addr)buffer->ap_s.alloc && + next <= (Addr)buffer->ap_s.limit) { + buffer->ap_s.alloc = next; + *pReturn = buffer->ap_s.init; return ResOK; } @@ -653,13 +657,13 @@ void BufferAttach(Buffer buffer, Addr base, Addr limit, /* Set up the buffer to point at the supplied region */ buffer->mode |= BufferModeATTACHED; buffer->base = base; - buffer->apStruct.init = init; - buffer->apStruct.alloc = AddrAdd(init, size); + buffer->ap_s.init = init; + buffer->ap_s.alloc = AddrAdd(init, size); /* only set limit if not logged */ if ((buffer->mode & BufferModeLOGGED) == 0) { - buffer->apStruct.limit = limit; + buffer->ap_s.limit = limit; } else { - AVER(buffer->apStruct.limit == (Addr)0); + AVER(buffer->ap_s.limit == (Addr)0); } AVER(buffer->initAtFlip == (Addr)0); buffer->poolLimit = limit; @@ -710,7 +714,7 @@ Res BufferFill(Addr *pReturn, Buffer buffer, Size size, /* If we're here because the buffer was trapped, then we attempt */ /* the allocation here. */ - if (!BufferIsReset(buffer) && buffer->apStruct.limit == (Addr)0) { + if (!BufferIsReset(buffer) && buffer->ap_s.limit == (Addr)0) { /* .fill.unflip: If the buffer is flipped then we unflip the buffer. */ if (buffer->mode & BufferModeFLIPPED) { BufferSetUnflipped(buffer); @@ -722,21 +726,21 @@ Res BufferFill(Addr *pReturn, Buffer buffer, Size size, } /* .fill.logged: If the buffer is logged then we leave it logged. */ - next = AddrAdd(buffer->apStruct.alloc, size); - if (next > buffer->apStruct.alloc && - next <= buffer->poolLimit) { - buffer->apStruct.alloc = next; + next = AddrAdd(buffer->ap_s.alloc, size); + if (next > (Addr)buffer->ap_s.alloc && + next <= (Addr)buffer->poolLimit) { + buffer->ap_s.alloc = next; if (buffer->mode & BufferModeLOGGED) { - EVENT3(BufferReserve, buffer, buffer->apStruct.init, size); + EVENT3(BufferReserve, buffer, buffer->ap_s.init, size); } - *pReturn = buffer->apStruct.init; + *pReturn = buffer->ap_s.init; return ResOK; } } /* There really isn't enough room for the allocation now. */ - AVER(AddrAdd(buffer->apStruct.alloc, size) > buffer->poolLimit - || AddrAdd(buffer->apStruct.alloc, size) < buffer->apStruct.alloc); + AVER(AddrAdd(buffer->ap_s.alloc, size) > buffer->poolLimit || + AddrAdd(buffer->ap_s.alloc, size) < (Addr)buffer->ap_s.alloc); BufferDetach(buffer, pool); @@ -752,7 +756,7 @@ Res BufferFill(Addr *pReturn, Buffer buffer, Size size, BufferAttach(buffer, base, limit, base, size); if (buffer->mode & BufferModeLOGGED) { - EVENT3(BufferReserve, buffer, buffer->apStruct.init, size); + EVENT3(BufferReserve, buffer, buffer->ap_s.init, size); } *pReturn = base; @@ -776,13 +780,13 @@ Bool BufferCommit(Buffer buffer, Addr p, Size size) /* .commit.before: If a flip occurs before this point, when the */ /* pool reads "initAtFlip" it will point below the object, so it */ /* will be trashed and the commit must fail when trip is called. */ - AVER(p == buffer->apStruct.init); - AVER(AddrAdd(buffer->apStruct.init, size) == buffer->apStruct.alloc); + AVER(p == buffer->ap_s.init); + AVER(AddrAdd(buffer->ap_s.init, size) == buffer->ap_s.alloc); /* .commit.update: Atomically update the init pointer to declare */ /* that the object is initialized (though it may be invalid if a */ /* flip occurred). */ - buffer->apStruct.init = buffer->apStruct.alloc; + buffer->ap_s.init = buffer->ap_s.alloc; /* .improve.memory-barrier: Memory barrier here on the DEC Alpha */ /* (and other relaxed memory order architectures). */ @@ -791,7 +795,7 @@ Bool BufferCommit(Buffer buffer, Addr p, Size size) /* be collected. The commit must succeed when trip is called. */ /* The pointer "p" will have been fixed up. (@@@@ Will it?) */ /* .commit.trip: Trip the buffer if a flip has occurred. */ - if (buffer->apStruct.limit == 0) + if (buffer->ap_s.limit == 0) return BufferTrip(buffer, p, size); /* No flip occurred, so succeed. */ @@ -817,7 +821,7 @@ Bool BufferTrip(Buffer buffer, Addr p, Size size) /* The limit field should be zero, because that's how trip gets */ /* called. See .commit.trip. */ - AVER(buffer->apStruct.limit == 0); + AVER(buffer->ap_s.limit == 0); /* Of course we should be trapped. */ AVER(BufferIsTrapped(buffer)); /* But the mutator shouldn't have caused the trap */ @@ -825,7 +829,7 @@ Bool BufferTrip(Buffer buffer, Addr p, Size size) /* The init and alloc fields should be equal at this point, because */ /* the step .commit.update has happened. */ - AVER(buffer->apStruct.init == buffer->apStruct.alloc); + AVER(buffer->ap_s.init == buffer->ap_s.alloc); /* The p parameter points at the base address of the allocated */ /* block, the end of which should now coincide with the init and */ @@ -835,7 +839,7 @@ Bool BufferTrip(Buffer buffer, Addr p, Size size) /* it seems like the algorithms could be modified to cope with the */ /* case of the object having been copied between Commit updating i */ /* and testing limit) */ - AVER(AddrAdd(p, size) == buffer->apStruct.init); + AVER(AddrAdd(p, size) == buffer->ap_s.init); pool = BufferPool(buffer); @@ -847,13 +851,13 @@ Bool BufferTrip(Buffer buffer, Addr p, Size size) /* Otherwise (see .commit.after) the object is valid (will've been */ /* scanned) so commit can simply succeed. */ if ((buffer->mode & BufferModeFLIPPED) - && buffer->apStruct.init != buffer->initAtFlip) { + && buffer->ap_s.init != buffer->initAtFlip) { /* Reset just enough state for Reserve/Fill to work. */ /* The buffer is left trapped and we leave the untrapping */ /* for the next reserve (which goes out of line to Fill */ /* (.fill.unflip) because the buffer is still trapped) */ - buffer->apStruct.init = p; - buffer->apStruct.alloc = p; + buffer->ap_s.init = p; + buffer->ap_s.alloc = p; return FALSE; } @@ -901,9 +905,9 @@ void BufferFlip(Buffer buffer) && (buffer->mode & BufferModeFLIPPED) == 0 && !BufferIsReset(buffer)) { AVER(buffer->initAtFlip == (Addr)0); - buffer->initAtFlip = buffer->apStruct.init; + buffer->initAtFlip = buffer->ap_s.init; /* Memory Barrier here? @@@@ */ - buffer->apStruct.limit = (Addr)0; + buffer->ap_s.limit = (Addr)0; buffer->mode |= BufferModeFLIPPED; } } @@ -922,7 +926,7 @@ Addr BufferScanLimit(Buffer buffer) if (buffer->mode & BufferModeFLIPPED) { return buffer->initAtFlip; } else { - return buffer->apStruct.init; + return buffer->ap_s.init; } } @@ -984,9 +988,9 @@ Bool BufferIsTrapped(Buffer buffer) Bool BufferIsTrappedByMutator(Buffer buffer) { - AVER(!buffer->apStruct.lwPopPending || buffer->apStruct.enabled); + AVER(!buffer->ap_s._lwpoppending || buffer->ap_s._enabled); /* Can't check buffer, see .check.use-trapped */ - return buffer->apStruct.lwPopPending; + return buffer->ap_s._lwpoppending; } diff --git a/mps/code/exposet0.c b/mps/code/exposet0.c index c7000214d97..f5a0b1e9e49 100644 --- a/mps/code/exposet0.c +++ b/mps/code/exposet0.c @@ -151,8 +151,8 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool_g, arena, mps_class_amc(), format, chain), "pool_create(amc)"); - die(mps_ap_create(&ap, pool_g, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool_g, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool_g, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool_g, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) { exactRoots[i] = objNULL; @@ -162,12 +162,12 @@ static void *test(void *arg, size_t s) } die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); diff --git a/mps/code/expt825.c b/mps/code/expt825.c index 8e71df402c8..588716f49de 100644 --- a/mps/code/expt825.c +++ b/mps/code/expt825.c @@ -152,10 +152,10 @@ static void *test(void *arg, size_t s) die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc\n"); - die(mps_root_create_table(&mps_root, arena, MPS_RANK_EXACT, (mps_rm_t)0, + die(mps_root_create_table(&mps_root, arena, mps_rank_exact(), (mps_rm_t)0, root, (size_t)rootCOUNT), "root_create\n"); - die(mps_ap_create(&ap, amc, MPS_RANK_EXACT), "ap_create\n"); + die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create\n"); mps_message_type_enable(arena, mps_message_type_finalization()); diff --git a/mps/code/finalcv.c b/mps/code/finalcv.c index 355c841e1ae..79a38dbbfb3 100644 --- a/mps/code/finalcv.c +++ b/mps/code/finalcv.c @@ -117,13 +117,13 @@ static void *test(void *arg, size_t s) die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc\n"); - die(mps_root_create_table(&mps_root[0], arena, MPS_RANK_EXACT, (mps_rm_t)0, + die(mps_root_create_table(&mps_root[0], arena, mps_rank_exact(), (mps_rm_t)0, root, (size_t)rootCOUNT), "root_create\n"); - die(mps_root_create_table(&mps_root[1], arena, MPS_RANK_EXACT, (mps_rm_t)0, + die(mps_root_create_table(&mps_root[1], arena, mps_rank_exact(), (mps_rm_t)0, &p, (size_t)1), "root_create\n"); - die(mps_ap_create(&ap, amc, MPS_RANK_EXACT), "ap_create\n"); + die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create\n"); /* Make registered-for-finalization objects. */ /* */ diff --git a/mps/code/finaltest.c b/mps/code/finaltest.c index 79496801acb..9351688a9ce 100644 --- a/mps/code/finaltest.c +++ b/mps/code/finaltest.c @@ -142,10 +142,10 @@ static void *test(void *arg, size_t s) die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&amc, arena, mps_class_amc(), fmt, chain), "pool_create amc\n"); - die(mps_root_create_table(&mps_root, arena, MPS_RANK_EXACT, (mps_rm_t)0, + die(mps_root_create_table(&mps_root, arena, mps_rank_exact(), (mps_rm_t)0, root, (size_t)rootCOUNT), "root_create\n"); - die(mps_ap_create(&ap, amc, MPS_RANK_EXACT), "ap_create\n"); + die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create\n"); mps_message_type_enable(arena, mps_message_type_finalization()); diff --git a/mps/code/ld.c b/mps/code/ld.c index bca8b63c05a..766bfe5d823 100644 --- a/mps/code/ld.c +++ b/mps/code/ld.c @@ -57,7 +57,7 @@ SRCID(ld, "$Id$"); * because if the epoch advances after it is read the dependency * will simply include movement for more time than necessary. */ -void LDReset(LD ld, Arena arena) +void LDReset(mps_ld_t ld, Arena arena) { Bool b; Seg seg; @@ -68,8 +68,8 @@ void LDReset(LD ld, Arena arena) b = SegOfAddr(&seg, arena, (Addr)ld); if (b) ShieldExpose(arena, seg); /* .ld.access */ - ld->epoch = arena->epoch; - ld->rs = RefSetEMPTY; + ld->_epoch = arena->epoch; + ld->_rs = RefSetEMPTY; if (b) ShieldCover(arena, seg); } @@ -93,12 +93,12 @@ void LDReset(LD ld, Arena arena) * were used first only the new location of the reference would end up * in the set. */ -void LDAdd(LD ld, Arena arena, Addr addr) +void LDAdd(mps_ld_t ld, Arena arena, Addr addr) { - AVER(ld->epoch <= arena->epoch); + AVER(ld->_epoch <= arena->epoch); /* AVERT(Arena, arena) -- see .add.lock-free */ - ld->rs = RefSetAdd(arena, ld->rs, addr); + ld->_rs = RefSetAdd(arena, ld->_rs, addr); } @@ -115,36 +115,36 @@ void LDAdd(LD ld, Arena arena, Addr addr) * with everything which has moved since it was initialized. * * .stale.recent.conservative: The refset from the history table is - * loaded before we check whether ld->epoch is "recent" with respect to + * loaded before we check whether ld->_epoch is "recent" with respect to * the current epoch. This means that we may (conservatively) decide * to use the prehistory instead. * * .stale.old: Otherwise, if the dependency is older than the length * of the history, check it against all movement that has ever occured. */ -Bool LDIsStale(LD ld, Arena arena, Addr addr) +Bool LDIsStale(mps_ld_t ld, Arena arena, Addr addr) { RefSet rs; UNUSED(addr); - AVER(ld->epoch <= arena->epoch); + AVER(ld->_epoch <= arena->epoch); /* AVERT(Arena, arena) -- .stale.thread-safe */ - if (arena->epoch == ld->epoch) /* .stale.current */ + if (arena->epoch == ld->_epoch) /* .stale.current */ return FALSE; /* Load the history refset, _then_ check to see if it's recent. * This may in fact load an okay refset, which we decide to throw * away and use the pre-history instead. */ - rs = arena->history[ld->epoch % LDHistoryLENGTH]; + rs = arena->history[ld->_epoch % LDHistoryLENGTH]; /* .stale.recent */ /* .stale.recent.conservative */ - if (arena->epoch - ld->epoch > LDHistoryLENGTH) { + if (arena->epoch - ld->_epoch > LDHistoryLENGTH) { rs = arena->prehistory; /* .stale.old */ } - return RefSetInter(ld->rs, rs) != RefSetEMPTY; + return RefSetInter(ld->_rs, rs) != RefSetEMPTY; } @@ -191,22 +191,22 @@ void LDAge(Arena arena, RefSet rs) * (rest of the) MPS. It is unnecessary to claim locks before calling * this function. */ -void LDMerge(LD ld, Arena arena, LD from) +void LDMerge(mps_ld_t ld, Arena arena, mps_ld_t from) { /* AVERT(Arena, arena); -- .merge.lock-free */ AVER(ld != NULL); - AVER(ld->epoch <= arena->epoch); + AVER(ld->_epoch <= arena->epoch); AVER(from != NULL); - AVER(from->epoch <= arena->epoch); + AVER(from->_epoch <= arena->epoch); /* If a reference has been added since epoch e1 then I've */ /* certainly added since epoch e0 where e0 < e1. Therefore */ /* the epoch of the merged ld is the minimum. */ - if (from->epoch < ld->epoch) - ld->epoch = from->epoch; + if (from->_epoch < ld->_epoch) + ld->_epoch = from->_epoch; /* The set of references added is the union of the two. */ - ld->rs = RefSetUnion(ld->rs, from->rs); + ld->_rs = RefSetUnion(ld->_rs, from->_rs); } diff --git a/mps/code/locv.c b/mps/code/locv.c index 010983fd878..76260ed526b 100644 --- a/mps/code/locv.c +++ b/mps/code/locv.c @@ -52,7 +52,7 @@ int main(void) die(mps_arena_create(&arena, mps_arena_class_vm(), testArenaSIZE), "mps_arena_create"); - die(mps_root_create_table(&root, arena, MPS_RANK_EXACT, + die(mps_root_create_table(&root, arena, mps_rank_exact(), (mps_rm_t)0, roots, (sizeof(roots)/sizeof(*roots))), "RootCreate"); @@ -61,7 +61,7 @@ int main(void) die(mps_pool_create(&pool, arena, mps_class_lo(), format), "LOCreate"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "APCreate"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "APCreate"); die(mps_reserve(&p, ap, sizeof(void *)), "mps_reserve min"); *(mps_word_t *)p = sizeof(void *); diff --git a/mps/code/mpm.h b/mps/code/mpm.h index f8f2e9e7466..bdf4ba79d74 100644 --- a/mps/code/mpm.h +++ b/mps/code/mpm.h @@ -366,6 +366,14 @@ extern Bool ScanStateCheck(ScanState ss); extern void ScanStateSetSummary(ScanState ss, RefSet summary); extern RefSet ScanStateSummary(ScanState ss); +/* See impl.h.mpmst.ss */ +#define ScanStateZoneShift(ss) ((Shift)(ss)->ss_s._zs) +#define ScanStateWhite(ss) ((ZoneSet)(ss)->ss_s._w) +#define ScanStateUnfixedSummary(ss) ((RefSet)(ss)->ss_s._ufs) +#define ScanStateSetZoneShift(ss, shift) ((void)((ss)->ss_s._zs = (shift))) +#define ScanStateSetWhite(ss, zs) ((void)((ss)->ss_s._w = (zs))) +#define ScanStateSetUnfixedSummary(ss, rs) ((void)((ss)->ss_s._ufs = (rs))) + extern Bool TraceIdCheck(TraceId id); extern Bool TraceSetCheck(TraceSet ts); extern Bool TraceCheck(Trace trace); @@ -405,11 +413,11 @@ extern double TraceWorkFactor; #define TRACE_SCAN_BEGIN(ss) \ BEGIN \ /* Check range on zoneShift before casting to Shift. */ \ - AVER((ss)->zoneShift < MPS_WORD_WIDTH); \ + AVER(ScanStateZoneShift(ss) < MPS_WORD_WIDTH); \ { \ - Shift SCANzoneShift = (Shift)(ss)->zoneShift; \ - ZoneSet SCANwhite = (ss)->white; \ - RefSet SCANsummary = (ss)->unfixedSummary; \ + Shift SCANzoneShift = ScanStateZoneShift(ss); \ + ZoneSet SCANwhite = ScanStateWhite(ss); \ + RefSet SCANsummary = ScanStateUnfixedSummary(ss); \ Word SCANt; \ { @@ -422,7 +430,7 @@ extern double TraceWorkFactor; /* Equivalent to MPS_FIX2 */ -#define TRACE_FIX2(ss, refIO) mps_fix2((mps_ss_t)(ss), (mps_addr_t *)(refIO)) +#define TRACE_FIX2(ss, refIO) _mps_fix2((mps_ss_t)(ss), (mps_addr_t *)(refIO)) /* Equivalent to MPS_FIX */ @@ -433,7 +441,7 @@ extern double TraceWorkFactor; #define TRACE_SCAN_END(ss) \ } \ - (ss)->unfixedSummary = SCANsummary; \ + ScanStateSetUnfixedSummary(ss, SCANsummary); \ } \ END @@ -693,9 +701,11 @@ extern Res BufferDescribe(Buffer buffer, mps_lib_FILE *stream); extern Res BufferReserve(Addr *pReturn, Buffer buffer, Size size, Bool withReservoirPermit); /* macro equivalent for BufferReserve, keep in sync with */ +/* TODO: Perhaps this isn't really necessary now that we build the MPS with + more global optimisation and inlining. RB 2012-09-07 */ #define BUFFER_RESERVE(pReturn, buffer, size, withReservoirPermit) \ (AddrAdd(BufferAlloc(buffer), size) > BufferAlloc(buffer) && \ - AddrAdd(BufferAlloc(buffer), size) <= BufferAP(buffer)->limit ? \ + AddrAdd(BufferAlloc(buffer), size) <= (Addr)BufferAP(buffer)->limit ? \ (*(pReturn) = BufferAlloc(buffer), \ BufferAP(buffer)->alloc = AddrAdd(BufferAlloc(buffer), size), \ ResOK) : \ @@ -706,6 +716,8 @@ extern Res BufferFill(Addr *pReturn, Buffer buffer, Size size, extern Bool BufferCommit(Buffer buffer, Addr p, Size size); /* macro equivalent for BufferCommit, keep in sync with */ +/* TODO: Perhaps this isn't really necessary now that we build the MPS with + more global optimisation and inlining. RB 2012-09-07 */ #define BUFFER_COMMIT(buffer, p, size) \ (BufferAP(buffer)->init = BufferAlloc(buffer), \ BufferAP(buffer)->limit != 0 || BufferTrip(buffer, p, size)) @@ -721,10 +733,10 @@ extern void BufferAttach(Buffer buffer, extern void BufferDetach(Buffer buffer, Pool pool); extern void BufferFlip(Buffer buffer); -extern AP (BufferAP)(Buffer buffer); -#define BufferAP(buffer) (&(buffer)->apStruct) -extern Buffer BufferOfAP(AP ap); -#define BufferOfAP(ap) PARENT(BufferStruct, apStruct, ap) +extern mps_ap_t (BufferAP)(Buffer buffer); +#define BufferAP(buffer) (&(buffer)->ap_s) +extern Buffer BufferOfAP(mps_ap_t ap); +#define BufferOfAP(ap) PARENT(BufferStruct, ap_s, ap) #define BufferArena(buffer) ((buffer)->arena) #define BufferPool(buffer) ((buffer)->pool) @@ -736,8 +748,8 @@ extern void BufferSetRankSet(Buffer buffer, RankSet rankset); #define BufferBase(buffer) ((buffer)->base) #define BufferGetInit(buffer) /* see .trans.bufferinit */ \ - (BufferAP(buffer)->init) -#define BufferAlloc(buffer) (BufferAP(buffer)->alloc) + ((Addr)(BufferAP(buffer)->init)) +#define BufferAlloc(buffer) ((Addr)(BufferAP(buffer)->alloc)) #define BufferLimit(buffer) ((buffer)->poolLimit) extern Addr BufferScanLimit(Buffer buffer); @@ -890,11 +902,11 @@ extern Res MutatorFaultContextScan(ScanState ss, MutatorFaultContext mfc); /* Location Dependency -- see */ -extern void LDReset(LD ld, Arena arena); -extern void LDAdd(LD ld, Arena arena, Addr addr); -extern Bool LDIsStale(LD ld, Arena arena, Addr addr); +extern void LDReset(mps_ld_t ld, Arena arena); +extern void LDAdd(mps_ld_t ld, Arena arena, Addr addr); +extern Bool LDIsStale(mps_ld_t ld, Arena arena, Addr addr); extern void LDAge(Arena arena, RefSet moved); -extern void LDMerge(LD ld, Arena arena, LD from); +extern void LDMerge(mps_ld_t ld, Arena arena, mps_ld_t from); /* Root Interface -- see */ diff --git a/mps/code/mpmst.h b/mps/code/mpmst.h index 8807d086b66..9f1edbe6141 100644 --- a/mps/code/mpmst.h +++ b/mps/code/mpmst.h @@ -343,33 +343,15 @@ typedef struct BufferClassStruct { } BufferClassStruct; - - -/* APStruct -- allocation point structure - * - * AP are part of the design of buffers see . - * - * The allocation point is exported to the client code so that it can - * do in-line buffered allocation. - * - * .ap: This structure must match . See also - * . */ - -typedef struct APStruct { - Addr init; /* limit of initialized area */ - Addr alloc; /* limit of allocated area */ - Addr limit; /* limit of allocation buffer */ - Addr frameptr; /* lightweight frame pointer */ - Bool enabled; /* lightweight frame status */ - Bool lwPopPending; /* lightweight pop pending? */ -} APStruct; - - /* BufferStruct -- allocation buffer structure * * See , . * - * The buffer contains an AP which may be exported to the client. */ + * The buffer contains an AP which may be exported to the client. + * AP are part of the design of buffers see . + * The allocation point is exported to the client code so that it can + * do in-line buffered allocation. + */ #define BufferSig ((Sig)0x519B0FFE) /* SIGnature BUFFEr */ @@ -386,7 +368,7 @@ typedef struct BufferStruct { double emptySize; /* bytes emptied from this buffer */ Addr base; /* base address of allocation buffer */ Addr initAtFlip; /* limit of initialized data at flip */ - APStruct apStruct; /* the allocation point */ + mps_ap_s ap_s; /* the allocation point */ Addr poolLimit; /* the pool's idea of the limit */ Align alignment; /* allocation alignment */ unsigned rampCount; /* see */ @@ -435,40 +417,32 @@ typedef struct FormatStruct { } FormatStruct; -/* LDStruct -- location dependency structure - * - * See design.mps.ld, and . - * - * A version of this structure is exported to the client. .ld.struct: - * This must be kept in sync with . See also - * . */ - -typedef struct LDStruct { - Epoch epoch; /* epoch when ld was last reset / init'ed */ - RefSet rs; /* RefSet of Add'ed references */ -} LDStruct; - - /* ScanState * * .ss: See . * - * .ss: The first three fields of the trace structure must match the - * external scan state structure (mps_ss_s) thus: - * ss->zoneShift mps_ss->w0 - * ss->white mps_ss->w1 - * ss->unfixedSummary mps_ss->w2 - * See and . This is why the Sig - * field is in the middle of this structure. .ss.zone: The zoneShift - * field is therefore declared as Word rather than Shift. */ + * .ss: The mps_ss field of the scan state structure is exported + * through the MPS interface to optimise the critical path scan loop. + * + * .ss.zone: For binary compatibility, the zone shift is exported as + * a word rather than a shift, so that the external mps_ss_s is a uniform + * three-word structure. See and . + * + * zs Shift zoneShift copy of arena->zoneShift. See .ss.zone + * w ZoneSet white white set, for inline fix test + * ufs RefSet unfixedSummary accumulated summary of scanned references + * + * NOTE: The mps_ss structure used to be obfuscated to preserve Harlequin's + * trade secrets in the MPS technology. These days they just seek to + * emphasize the abstraction, and could maybe be given better names and + * types. RB 2012-09-07 + */ #define ScanStateSig ((Sig)0x5195CA45) /* SIGnature SCAN State */ typedef struct ScanStateStruct { - Word zoneShift; /* copy of arena->zoneShift. See .ss.zone */ - ZoneSet white; /* white set, for inline fix test */ - RefSet unfixedSummary; /* accumulated summary of scanned references */ Sig sig; /* */ + struct mps_ss_s ss_s; /* .ss */ Arena arena; /* owning arena */ PoolFixMethod fix; /* third stage fix function */ void *fixClosure; /* closure data for fix */ @@ -630,7 +604,7 @@ typedef struct GlobalsStruct { #define ArenaSig ((Sig)0x519A6E4A) /* SIGnature ARENA */ -typedef struct ArenaStruct { +typedef struct mps_arena_s { GlobalsStruct globals; /* must be first, see */ Serial serial; diff --git a/mps/code/mpmtypes.h b/mps/code/mpmtypes.h index 66d5b533546..a15098c53ee 100644 --- a/mps/code/mpmtypes.h +++ b/mps/code/mpmtypes.h @@ -67,9 +67,7 @@ typedef BufferClass SegBufClass; /* */ typedef BufferClass RankBufClass; /* */ typedef unsigned BufferMode; /* */ typedef unsigned FrameState; /* */ -typedef struct APStruct *AP; /* */ typedef struct FormatStruct *Format; /* design.mps.format */ -typedef struct LDStruct *LD; /* design.mps.ld */ typedef struct LockStruct *Lock; /* * */ typedef struct PoolStruct *Pool; /* */ typedef struct PoolClassStruct *PoolClass; /* */ @@ -94,7 +92,7 @@ typedef struct SegPrefStruct *SegPref; /* design.mps.pref, */ typedef int SegPrefKind; /* design.mps.pref, */ typedef struct ArenaClassStruct *ArenaClass; /* */ typedef ArenaClass AbstractArenaClass; /* */ -typedef struct ArenaStruct *Arena; /* */ +typedef struct mps_arena_s *Arena; /* */ typedef struct GlobalsStruct *Globals; /* */ typedef struct VMStruct *VM; /* * */ typedef struct RootStruct *Root; /* */ diff --git a/mps/code/mps.h b/mps/code/mps.h index 8971c3a4f2d..c0d7a20286d 100644 --- a/mps/code/mps.h +++ b/mps/code/mps.h @@ -1,11 +1,25 @@ /* mps.h: RAVENBROOK MEMORY POOL SYSTEM C INTERFACE * * $Id$ - * Copyright (c) 2001 Ravenbrook Limited. See end of file for license. + * Copyright (c) 2001-2012 Ravenbrook Limited. See end of file for license. * Portions copyright (c) 2002 Global Graphics Software. * - * .readership: customers, MPS developers. - * .sources: . + * THIS HEADER IS NOT DOCUMENTATION. + * Please refer to the [MPS Manual](../manual/). + * + * But if you are a human reading this, please note: + * + * .naming: The MPS interface only uses identifiers beginning `mps_`, + * `MPS_` or `_mps_` and may use any identifiers with these prefixes in + * future. + * + * .naming.internal: Any idenfitier beginning with underscore is for + * internal use within the interface and may change or be withdrawn without + * warning. + * + * .readership: compilers, MPS developers. + * + * .sources: [The design of the MPS Interface to C](../design/interface-c). */ #ifndef mps_h @@ -85,16 +99,16 @@ enum { * */ /* Not meant to be used by clients, they should use the macros below. */ enum { - MPS_MESSAGE_TYPE_FINALIZATION, - MPS_MESSAGE_TYPE_GC, - MPS_MESSAGE_TYPE_GC_START + _mps_MESSAGE_TYPE_FINALIZATION, + _mps_MESSAGE_TYPE_GC, + _mps_MESSAGE_TYPE_GC_START }; /* Message Types * This is what clients should use. */ -#define mps_message_type_finalization() MPS_MESSAGE_TYPE_FINALIZATION -#define mps_message_type_gc() MPS_MESSAGE_TYPE_GC -#define mps_message_type_gc_start() MPS_MESSAGE_TYPE_GC_START +#define mps_message_type_finalization() _mps_MESSAGE_TYPE_FINALIZATION +#define mps_message_type_gc() _mps_MESSAGE_TYPE_GC +#define mps_message_type_gc_start() _mps_MESSAGE_TYPE_GC_START /* Reference Ranks @@ -105,11 +119,6 @@ extern mps_rank_t mps_rank_ambig(void); extern mps_rank_t mps_rank_exact(void); extern mps_rank_t mps_rank_weak(void); -/* These upper case symbolic forms are obsolescent. */ -/* Provided for source compatibility only. */ -#define MPS_RANK_AMBIG mps_rank_ambig() -#define MPS_RANK_EXACT mps_rank_exact() -#define MPS_RANK_WEAK mps_rank_weak() /* Root Modes */ /* .rm: Keep in sync with */ @@ -125,9 +134,9 @@ typedef struct mps_ap_s { /* allocation point descriptor */ mps_addr_t init; /* limit of initialized memory */ mps_addr_t alloc; /* limit of allocated memory */ mps_addr_t limit; /* limit of available memory */ - mps_addr_t frameptr; /* lightweight frame pointer */ - mps_bool_t enabled; /* lightweight frame status */ - mps_bool_t lwpoppending; /* lightweight pop pending? */ + mps_addr_t _frameptr; /* lightweight frame pointer */ + mps_bool_t _enabled; /* lightweight frame status */ + mps_bool_t _lwpoppending; /* lightweight pop pending? */ } mps_ap_s; @@ -165,7 +174,7 @@ typedef struct mps_sac_class_s { /* .ld: Keep in sync with . */ typedef struct mps_ld_s { /* location dependency descriptor */ - mps_word_t w0, w1; + mps_word_t _epoch, _rs; } mps_ld_s; @@ -186,10 +195,10 @@ typedef mps_addr_t (*mps_fmt_class_t)(mps_addr_t); /* Scan State */ -/* .ss: See also and . */ +/* .ss: See also . */ typedef struct mps_ss_s { - mps_word_t w0, w1, w2; + mps_word_t _zs, _w, _ufs; } mps_ss_s; @@ -629,20 +638,20 @@ extern mps_res_t mps_fix(mps_ss_t, mps_addr_t *); #define MPS_SCAN_BEGIN(ss) \ MPS_BEGIN \ mps_ss_t _ss = (ss); \ - mps_word_t _mps_w0 = (_ss)->w0; \ - mps_word_t _mps_w1 = (_ss)->w1; \ - mps_word_t _mps_w2 = (_ss)->w2; \ + mps_word_t _mps_zs = (_ss)->_zs; \ + mps_word_t _mps_w = (_ss)->_w; \ + mps_word_t _mps_ufs = (_ss)->_ufs; \ mps_word_t _mps_wt; \ { #define MPS_FIX1(ss, ref) \ - (_mps_wt = (mps_word_t)1 << ((mps_word_t)(ref) >> _mps_w0 \ + (_mps_wt = (mps_word_t)1 << ((mps_word_t)(ref) >> _mps_zs \ & (sizeof(mps_word_t) * CHAR_BIT - 1)), \ - _mps_w2 |= _mps_wt, \ - (_mps_w1 & _mps_wt) != 0) + _mps_ufs |= _mps_wt, \ + (_mps_w & _mps_wt) != 0) -extern mps_res_t mps_fix2(mps_ss_t, mps_addr_t *); -#define MPS_FIX2(ss, ref_io) mps_fix2(ss, ref_io) +extern mps_res_t _mps_fix2(mps_ss_t, mps_addr_t *); +#define MPS_FIX2(ss, ref_io) _mps_fix2(ss, ref_io) #define MPS_FIX12(ss, ref_io) \ (MPS_FIX1(ss, *(ref_io)) ? \ @@ -653,12 +662,12 @@ extern mps_res_t mps_fix2(mps_ss_t, mps_addr_t *); #define MPS_FIX_CALL(ss, call) \ MPS_BEGIN \ - (call); _mps_w2 |= (ss)->w2; \ + (call); _mps_ufs |= (ss)->_ufs; \ MPS_END #define MPS_SCAN_END(ss) \ } \ - (ss)->w2 = _mps_w2; \ + (ss)->_ufs = _mps_ufs; \ MPS_END diff --git a/mps/code/mpsi.c b/mps/code/mpsi.c index 528ffebea3e..8b02e81e596 100644 --- a/mps/code/mpsi.c +++ b/mps/code/mpsi.c @@ -83,25 +83,17 @@ static Bool mpsi_check(void) CHECKL((int)MPS_RES_IO == (int)ResIO); CHECKL((int)MPS_RES_COMMIT_LIMIT == (int)ResCOMMIT_LIMIT); - /* Check that external and internal rank numbers match. */ - /* See and . */ - /* Also see .check.enum.cast. */ - 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); - /* Check that external and internal message types match. */ /* See and */ /* . */ /* Also see .check.enum.cast. */ CHECKL(COMPATTYPE(mps_message_type_t, MessageType)); CHECKL((int)MessageTypeFINALIZATION - == (int)MPS_MESSAGE_TYPE_FINALIZATION); + == (int)_mps_MESSAGE_TYPE_FINALIZATION); CHECKL((int)MessageTypeGC - == (int)MPS_MESSAGE_TYPE_GC); + == (int)_mps_MESSAGE_TYPE_GC); CHECKL((int)MessageTypeGCSTART - == (int)MPS_MESSAGE_TYPE_GC_START); + == (int)_mps_MESSAGE_TYPE_GC_START); /* The external idea of a word width and the internal one */ /* had better match. See . */ @@ -121,13 +113,6 @@ static Bool mpsi_check(void) /* out to external. */ CHECKL(COMPATTYPE(mps_clock_t, Clock)); - /* Check ap_s/APStruct compatibility by hand */ - /* .check.ap: See and . */ - CHECKL(sizeof(mps_ap_s) == sizeof(APStruct)); - 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 and . */ CHECKL(sizeof(mps_sac_s) == sizeof(ExternalSACStruct)); @@ -157,20 +142,6 @@ static Bool mpsi_check(void) CHECKL(COMPATFIELD(mps_sac_classes_s, mps_frequency, SACClassesStruct, frequency)); - /* Check ss_s/ScanStateStruct compatibility by hand */ - /* .check.ss: See and . */ - /* Note that the size of the mps_ss_s and ScanStateStruct */ - /* are not equal. See . */ - 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 and */ - CHECKL(sizeof(mps_ld_s) == sizeof(LDStruct)); - CHECKL(COMPATFIELD(mps_ld_s, w0, LDStruct, epoch)); - CHECKL(COMPATFIELD(mps_ld_s, w1, LDStruct, rs)); - return TRUE; } @@ -199,10 +170,9 @@ mps_rank_t mps_rank_weak(void) } -mps_res_t mps_arena_extend(mps_arena_t mps_arena, +mps_res_t mps_arena_extend(mps_arena_t arena, mps_addr_t base, size_t size) { - Arena arena = (Arena)mps_arena; Res res; ArenaEnter(arena); @@ -213,9 +183,8 @@ mps_res_t mps_arena_extend(mps_arena_t mps_arena, return (mps_res_t)res; } -size_t mps_arena_reserved(mps_arena_t mps_arena) +size_t mps_arena_reserved(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Size size; ArenaEnter(arena); @@ -231,9 +200,8 @@ size_t mps_space_reserved(mps_space_t mps_space) return mps_arena_reserved(mps_space); } -size_t mps_arena_committed(mps_arena_t mps_arena) +size_t mps_arena_committed(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Size size; ArenaEnter(arena); @@ -249,9 +217,8 @@ size_t mps_space_committed(mps_space_t mps_space) return mps_arena_committed(mps_space); } -size_t mps_arena_spare_committed(mps_arena_t mps_arena) +size_t mps_arena_spare_committed(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Size size; ArenaEnter(arena); @@ -261,9 +228,8 @@ size_t mps_arena_spare_committed(mps_arena_t mps_arena) return (size_t)size; } -size_t mps_arena_commit_limit(mps_arena_t mps_arena) +size_t mps_arena_commit_limit(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Size size; ArenaEnter(arena); @@ -273,10 +239,9 @@ size_t mps_arena_commit_limit(mps_arena_t mps_arena) return size; } -mps_res_t mps_arena_commit_limit_set(mps_arena_t mps_arena, size_t limit) +mps_res_t mps_arena_commit_limit_set(mps_arena_t arena, size_t limit) { Res res; - Arena arena = (Arena)mps_arena; ArenaEnter(arena); res = ArenaSetCommitLimit(arena, limit); @@ -285,10 +250,8 @@ mps_res_t mps_arena_commit_limit_set(mps_arena_t mps_arena, size_t limit) return res; } -void mps_arena_spare_commit_limit_set(mps_arena_t mps_arena, size_t limit) +void mps_arena_spare_commit_limit_set(mps_arena_t arena, size_t limit) { - Arena arena = (Arena)mps_arena; - ArenaEnter(arena); ArenaSetSpareCommitLimit(arena, limit); ArenaLeave(arena); @@ -296,9 +259,8 @@ void mps_arena_spare_commit_limit_set(mps_arena_t mps_arena, size_t limit) return; } -size_t mps_arena_spare_commit_limit(mps_arena_t mps_arena) +size_t mps_arena_spare_commit_limit(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; size_t limit; ArenaEnter(arena); @@ -308,9 +270,8 @@ size_t mps_arena_spare_commit_limit(mps_arena_t mps_arena) return limit; } -void mps_arena_clamp(mps_arena_t mps_arena) +void mps_arena_clamp(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; ArenaEnter(arena); ArenaClamp(ArenaGlobals(arena)); ArenaLeave(arena); @@ -323,9 +284,8 @@ void mps_space_clamp(mps_space_t mps_space) } -void mps_arena_release(mps_arena_t mps_arena) +void mps_arena_release(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; ArenaEnter(arena); ArenaRelease(ArenaGlobals(arena)); ArenaLeave(arena); @@ -352,26 +312,23 @@ void mps_space_park(mps_space_t mps_space) mps_arena_park(mps_space); } -void mps_arena_expose(mps_arena_t mps_arena) +void mps_arena_expose(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; ArenaEnter(arena); ArenaExposeRemember(ArenaGlobals(arena), 0); ArenaLeave(arena); } /* Null implementations of remember and restore */ -void mps_arena_unsafe_expose_remember_protection(mps_arena_t mps_arena) +void mps_arena_unsafe_expose_remember_protection(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; ArenaEnter(arena); ArenaExposeRemember(ArenaGlobals(arena), 1); ArenaLeave(arena); } -void mps_arena_unsafe_restore_protection(mps_arena_t mps_arena) +void mps_arena_unsafe_restore_protection(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; ArenaEnter(arena); ArenaRestoreProtection(ArenaGlobals(arena)); ArenaLeave(arena); @@ -398,12 +355,11 @@ mps_res_t mps_arena_collect(mps_space_t mps_space) return res; } -mps_bool_t mps_arena_step(mps_arena_t mps_arena, +mps_bool_t mps_arena_step(mps_arena_t arena, double interval, double multiplier) { Bool b; - Arena arena = (Arena)mps_arena; ArenaEnter(arena); b = ArenaStep(ArenaGlobals(arena), interval, multiplier); ArenaLeave(arena); @@ -457,10 +413,8 @@ mps_res_t mps_arena_create_v(mps_arena_t *mps_arena_o, /* mps_arena_destroy -- destroy an arena object */ -void mps_arena_destroy(mps_arena_t mps_arena) +void mps_arena_destroy(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; - ArenaEnter(arena); ArenaDestroy(arena); } @@ -468,10 +422,9 @@ void mps_arena_destroy(mps_arena_t mps_arena) /* mps_arena_has_addr -- is this address managed by this arena? */ -mps_bool_t mps_arena_has_addr(mps_arena_t mps_arena, mps_addr_t p) +mps_bool_t mps_arena_has_addr(mps_arena_t arena, mps_addr_t p) { Bool b; - Arena arena = (Arena)mps_arena; /* One of the few functions that can be called during the call to an MPS function. IE this function @@ -490,12 +443,11 @@ mps_bool_t mps_arena_has_addr(mps_arena_t mps_arena, mps_addr_t p) */ mps_bool_t mps_addr_pool(mps_pool_t *mps_pool_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_addr_t p) { Bool b; Pool pool; - Arena arena = (Arena)mps_arena; AVER(mps_pool_o != NULL); /* mps_arena -- will be checked by ArenaEnterRecursive */ @@ -528,13 +480,12 @@ mps_bool_t mps_addr_pool(mps_pool_t *mps_pool_o, * Note: may return an MPS-internal format. */ mps_bool_t mps_addr_fmt(mps_fmt_t *mps_fmt_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_addr_t p) { Bool b; Pool pool; Format format = 0; - Arena arena = (Arena)mps_arena; AVER(mps_fmt_o != NULL); /* mps_arena -- will be checked by ArenaEnterRecursive */ @@ -565,10 +516,9 @@ mps_bool_t mps_addr_fmt(mps_fmt_t *mps_fmt_o, * the format structure is declared as "mps_fmt_A". */ mps_res_t mps_fmt_create_A(mps_fmt_t *mps_fmt_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_fmt_A_s *mps_fmt_A) { - Arena arena = (Arena)mps_arena; Format format; Res res; @@ -600,10 +550,9 @@ mps_res_t mps_fmt_create_A(mps_fmt_t *mps_fmt_o, /* mps_fmt_create_B -- create an object format of variant B */ mps_res_t mps_fmt_create_B(mps_fmt_t *mps_fmt_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_fmt_B_s *mps_fmt_B) { - Arena arena = (Arena)mps_arena; Format format; Res res; @@ -635,10 +584,9 @@ mps_res_t mps_fmt_create_B(mps_fmt_t *mps_fmt_o, /* mps_fmt_create_auto_header -- create a format of variant auto_header */ mps_res_t mps_fmt_create_auto_header(mps_fmt_t *mps_fmt_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_fmt_auto_header_s *mps_fmt) { - Arena arena = (Arena)mps_arena; Format format; Res res; @@ -670,10 +618,9 @@ mps_res_t mps_fmt_create_auto_header(mps_fmt_t *mps_fmt_o, /* mps_fmt_create_fixed -- create an object format of variant fixed */ mps_res_t mps_fmt_create_fixed(mps_fmt_t *mps_fmt_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_fmt_fixed_s *mps_fmt_fixed) { - Arena arena = (Arena)mps_arena; Format format; Res res; @@ -720,21 +667,20 @@ void mps_fmt_destroy(mps_fmt_t mps_fmt) } -mps_res_t mps_pool_create(mps_pool_t *mps_pool_o, mps_arena_t mps_arena, +mps_res_t mps_pool_create(mps_pool_t *mps_pool_o, mps_arena_t arena, mps_class_t mps_class, ...) { mps_res_t res; va_list args; va_start(args, mps_class); - res = mps_pool_create_v(mps_pool_o, mps_arena, mps_class, args); + res = mps_pool_create_v(mps_pool_o, arena, mps_class, args); va_end(args); return res; } -mps_res_t mps_pool_create_v(mps_pool_t *mps_pool_o, mps_arena_t mps_arena, +mps_res_t mps_pool_create_v(mps_pool_t *mps_pool_o, mps_arena_t arena, mps_class_t mps_class, va_list args) { - Arena arena = (Arena)mps_arena; Pool pool; PoolClass class = (PoolClass)mps_class; Res res; @@ -863,7 +809,7 @@ mps_res_t mps_ap_create(mps_ap_t *mps_ap_o, mps_pool_t mps_pool, ...) if (res != ResOK) return res; - *mps_ap_o = (mps_ap_t)BufferAP(buf); + *mps_ap_o = BufferAP(buf); return MPS_RES_OK; } @@ -894,13 +840,13 @@ mps_res_t mps_ap_create_v(mps_ap_t *mps_ap_o, mps_pool_t mps_pool, if (res != ResOK) return res; - *mps_ap_o = (mps_ap_t)BufferAP(buf); + *mps_ap_o = BufferAP(buf); return MPS_RES_OK; } void mps_ap_destroy(mps_ap_t mps_ap) { - Buffer buf = BufferOfAP((AP)mps_ap); + Buffer buf = BufferOfAP(mps_ap); Arena arena; AVER(mps_ap != NULL); @@ -928,7 +874,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(TESTT(Buffer, BufferOfAP((AP)mps_ap))); + AVER(TESTT(Buffer, BufferOfAP(mps_ap))); AVER(mps_ap->init == mps_ap->alloc); AVER(size > 0); @@ -947,7 +893,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(TESTT(Buffer, BufferOfAP((AP)mps_ap))); + AVER(TESTT(Buffer, BufferOfAP(mps_ap))); AVER(mps_ap->init == mps_ap->alloc); MPS_RESERVE_WITH_RESERVOIR_PERMIT_BLOCK(res, *p_o, mps_ap, size); @@ -968,7 +914,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(TESTT(Buffer, BufferOfAP((AP)mps_ap))); + AVER(TESTT(Buffer, BufferOfAP(mps_ap))); AVER(p != NULL); AVER(size > 0); AVER(p == mps_ap->init); @@ -999,13 +945,13 @@ mps_res_t (mps_ap_frame_push)(mps_frame_t *frame_o, mps_ap_t mps_ap) return MPS_RES_FAIL; } - if (!mps_ap->lwpoppending) { + if (!mps_ap->_lwpoppending) { /* Valid state for a lightweight push */ *frame_o = (mps_frame_t)mps_ap->init; return MPS_RES_OK; } else { /* Need a heavyweight push */ - Buffer buf = BufferOfAP((AP)mps_ap); + Buffer buf = BufferOfAP(mps_ap); Arena arena; AllocFrame frame; Res res; @@ -1040,16 +986,16 @@ mps_res_t (mps_ap_frame_pop)(mps_ap_t mps_ap, mps_frame_t frame) return MPS_RES_FAIL; } - if (mps_ap->enabled) { + if (mps_ap->_enabled) { /* Valid state for a lightweight pop */ - mps_ap->frameptr = (mps_addr_t)frame; /* record pending pop */ - mps_ap->lwpoppending = TRUE; + mps_ap->_frameptr = (mps_addr_t)frame; /* record pending pop */ + mps_ap->_lwpoppending = TRUE; mps_ap->limit = (mps_addr_t)0; /* trap the buffer */ return MPS_RES_OK; } else { /* Need a heavyweight pop */ - Buffer buf = BufferOfAP((AP)mps_ap); + Buffer buf = BufferOfAP(mps_ap); Arena arena; Res res; @@ -1074,7 +1020,7 @@ mps_res_t (mps_ap_frame_pop)(mps_ap_t mps_ap, mps_frame_t frame) mps_res_t mps_ap_fill(mps_addr_t *p_o, mps_ap_t mps_ap, size_t size) { - Buffer buf = BufferOfAP((AP)mps_ap); + Buffer buf = BufferOfAP(mps_ap); Arena arena; Addr p; Res res; @@ -1105,7 +1051,7 @@ mps_res_t mps_ap_fill(mps_addr_t *p_o, mps_ap_t mps_ap, size_t size) mps_res_t mps_ap_fill_with_reservoir_permit(mps_addr_t *p_o, mps_ap_t mps_ap, size_t size) { - Buffer buf = BufferOfAP((AP)mps_ap); + Buffer buf = BufferOfAP(mps_ap); Arena arena; Addr p; Res res; @@ -1140,7 +1086,7 @@ mps_res_t mps_ap_fill_with_reservoir_permit(mps_addr_t *p_o, mps_ap_t mps_ap, mps_bool_t mps_ap_trip(mps_ap_t mps_ap, mps_addr_t p, size_t size) { - Buffer buf = BufferOfAP((AP)mps_ap); + Buffer buf = BufferOfAP(mps_ap); Arena arena; Bool b; @@ -1301,11 +1247,10 @@ void mps_sac_free(mps_sac_t mps_sac, mps_addr_t p, size_t size) /* Roots */ -mps_res_t mps_root_create(mps_root_t *mps_root_o, mps_arena_t mps_arena, +mps_res_t mps_root_create(mps_root_t *mps_root_o, mps_arena_t arena, mps_rank_t mps_rank, mps_rm_t mps_rm, mps_root_scan_t mps_root_scan, void *p, size_t s) { - Arena arena = (Arena)mps_arena; Rank rank = (Rank)mps_rank; Root root; Res res; @@ -1326,11 +1271,10 @@ mps_res_t mps_root_create(mps_root_t *mps_root_o, mps_arena_t mps_arena, return MPS_RES_OK; } -mps_res_t mps_root_create_table(mps_root_t *mps_root_o, mps_arena_t mps_arena, +mps_res_t mps_root_create_table(mps_root_t *mps_root_o, mps_arena_t arena, mps_rank_t mps_rank, mps_rm_t mps_rm, mps_addr_t *base, size_t size) { - Arena arena = (Arena)mps_arena; Rank rank = (Rank)mps_rank; Root root; RootMode mode = (RootMode)mps_rm; @@ -1357,12 +1301,11 @@ mps_res_t mps_root_create_table(mps_root_t *mps_root_o, mps_arena_t mps_arena, } mps_res_t mps_root_create_table_masked(mps_root_t *mps_root_o, - mps_arena_t mps_arena, + mps_arena_t arena, mps_rank_t mps_rank, mps_rm_t mps_rm, mps_addr_t *base, size_t size, mps_word_t mask) { - Arena arena = (Arena)mps_arena; Rank rank = (Rank)mps_rank; Root root; RootMode mode = (RootMode)mps_rm; @@ -1388,12 +1331,11 @@ mps_res_t mps_root_create_table_masked(mps_root_t *mps_root_o, return MPS_RES_OK; } -mps_res_t mps_root_create_fmt(mps_root_t *mps_root_o, mps_arena_t mps_arena, +mps_res_t mps_root_create_fmt(mps_root_t *mps_root_o, mps_arena_t arena, mps_rank_t mps_rank, mps_rm_t mps_rm, mps_fmt_scan_t mps_fmt_scan, mps_addr_t base, mps_addr_t limit) { - Arena arena = (Arena)mps_arena; Rank rank = (Rank)mps_rank; FormatScanMethod scan = (FormatScanMethod)mps_fmt_scan; Root root; @@ -1412,12 +1354,11 @@ mps_res_t mps_root_create_fmt(mps_root_t *mps_root_o, mps_arena_t mps_arena, return MPS_RES_OK; } -mps_res_t mps_root_create_reg(mps_root_t *mps_root_o, mps_arena_t mps_arena, +mps_res_t mps_root_create_reg(mps_root_t *mps_root_o, mps_arena_t arena, mps_rank_t mps_rank, mps_rm_t mps_rm, mps_thr_t mps_thr, mps_reg_scan_t mps_reg_scan, void *reg_scan_p, size_t mps_size) { - Arena arena = (Arena)mps_arena; Rank rank = (Rank)mps_rank; Thread thread = (Thread)mps_thr; Root root; @@ -1429,7 +1370,7 @@ mps_res_t mps_root_create_reg(mps_root_t *mps_root_o, mps_arena_t mps_arena, AVER(mps_reg_scan != NULL); AVER(mps_reg_scan == mps_stack_scan_ambig); /* .reg.scan */ AVER(reg_scan_p != NULL); /* stackBot */ - AVER(rank == MPS_RANK_AMBIG); + AVER(rank == mps_rank_ambig()); AVER(mps_rm == (mps_rm_t)0); /* See .root-mode. */ @@ -1452,9 +1393,8 @@ mps_res_t mps_root_create_reg(mps_root_t *mps_root_o, mps_arena_t mps_arena, mps_res_t mps_stack_scan_ambig(mps_ss_t mps_ss, mps_thr_t mps_thr, void *p, size_t s) { - ScanState ss = (ScanState)mps_ss; + ScanState ss = PARENT(ScanStateStruct, ss_s, mps_ss); Thread thread = (Thread)mps_thr; - UNUSED(s); return ThreadScan(ss, thread, p); } @@ -1487,9 +1427,8 @@ void (mps_tramp)(void **r_o, } -mps_res_t mps_thread_reg(mps_thr_t *mps_thr_o, mps_arena_t mps_arena) +mps_res_t mps_thread_reg(mps_thr_t *mps_thr_o, mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Thread thread; Res res; @@ -1522,15 +1461,10 @@ void mps_thread_dereg(mps_thr_t mps_thr) ArenaLeave(arena); } -void mps_ld_reset(mps_ld_t mps_ld, mps_arena_t mps_arena) +void mps_ld_reset(mps_ld_t ld, mps_arena_t arena) { - Arena arena = (Arena)mps_arena; - LD ld = (LD)mps_ld; - ArenaEnter(arena); - LDReset(ld, arena); - ArenaLeave(arena); } @@ -1539,11 +1473,8 @@ void mps_ld_reset(mps_ld_t mps_ld, mps_arena_t mps_arena) * * See . */ -void mps_ld_add(mps_ld_t mps_ld, mps_arena_t mps_arena, mps_addr_t addr) +void mps_ld_add(mps_ld_t ld, mps_arena_t arena, mps_addr_t addr) { - Arena arena = (Arena)mps_arena; - LD ld = (LD)mps_ld; - LDAdd(ld, arena, (Addr)addr); } @@ -1552,13 +1483,9 @@ void mps_ld_add(mps_ld_t mps_ld, mps_arena_t mps_arena, mps_addr_t addr) * * See . */ -void mps_ld_merge(mps_ld_t mps_ld, mps_arena_t mps_arena, - mps_ld_t mps_from) +void mps_ld_merge(mps_ld_t ld, mps_arena_t arena, + mps_ld_t from) { - Arena arena = (Arena)mps_arena; - LD ld = (LD)mps_ld; - LD from = (LD)mps_from; - LDMerge(ld, arena, from); } @@ -1567,11 +1494,9 @@ void mps_ld_merge(mps_ld_t mps_ld, mps_arena_t mps_arena, * * See . */ -mps_bool_t mps_ld_isstale(mps_ld_t mps_ld, mps_arena_t mps_arena, +mps_bool_t mps_ld_isstale(mps_ld_t ld, mps_arena_t arena, mps_addr_t addr) { - Arena arena = (Arena)mps_arena; - LD ld = (LD)mps_ld; Bool b; b = LDIsStale(ld, arena, (Addr)addr); @@ -1590,20 +1515,18 @@ mps_res_t mps_fix(mps_ss_t mps_ss, mps_addr_t *ref_io) return res; } -mps_word_t mps_collections(mps_arena_t mps_arena) +mps_word_t mps_collections(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; return ArenaEpoch(arena); /* thread safe: see */ } /* mps_finalize -- register for finalization */ -mps_res_t mps_finalize(mps_arena_t mps_arena, mps_addr_t *refref) +mps_res_t mps_finalize(mps_arena_t arena, mps_addr_t *refref) { Res res; Addr object; - Arena arena = (Arena)mps_arena; ArenaEnter(arena); @@ -1617,11 +1540,10 @@ mps_res_t mps_finalize(mps_arena_t mps_arena, mps_addr_t *refref) /* mps_definalize -- deregister for finalization */ -mps_res_t mps_definalize(mps_arena_t mps_arena, mps_addr_t *refref) +mps_res_t mps_definalize(mps_arena_t arena, mps_addr_t *refref) { Res res; Addr object; - Arena arena = (Arena)mps_arena; ArenaEnter(arena); @@ -1636,10 +1558,9 @@ mps_res_t mps_definalize(mps_arena_t mps_arena, mps_addr_t *refref) /* Messages */ -void mps_message_type_enable(mps_arena_t mps_arena, +void mps_message_type_enable(mps_arena_t arena, mps_message_type_t mps_type) { - Arena arena = (Arena)mps_arena; MessageType type = (MessageType)mps_type; ArenaEnter(arena); @@ -1649,10 +1570,9 @@ void mps_message_type_enable(mps_arena_t mps_arena, ArenaLeave(arena); } -void mps_message_type_disable(mps_arena_t mps_arena, +void mps_message_type_disable(mps_arena_t arena, mps_message_type_t mps_type) { - Arena arena = (Arena)mps_arena; MessageType type = (MessageType)mps_type; ArenaEnter(arena); @@ -1662,10 +1582,9 @@ void mps_message_type_disable(mps_arena_t mps_arena, ArenaLeave(arena); } -mps_bool_t mps_message_poll(mps_arena_t mps_arena) +mps_bool_t mps_message_poll(mps_arena_t arena) { Bool b; - Arena arena = (Arena)mps_arena; ArenaEnter(arena); @@ -1676,9 +1595,8 @@ mps_bool_t mps_message_poll(mps_arena_t mps_arena) } mps_bool_t mps_message_queue_type(mps_message_type_t *mps_message_type_return, - mps_arena_t mps_arena) + mps_arena_t arena) { - Arena arena = (Arena)mps_arena; MessageType type; Bool b; @@ -1694,11 +1612,10 @@ mps_bool_t mps_message_queue_type(mps_message_type_t *mps_message_type_return, } mps_bool_t mps_message_get(mps_message_t *mps_message_return, - mps_arena_t mps_arena, + mps_arena_t arena, mps_message_type_t mps_type) { Bool b; - Arena arena = (Arena)mps_arena; MessageType type = (MessageType)mps_type; Message message; @@ -1713,10 +1630,9 @@ mps_bool_t mps_message_get(mps_message_t *mps_message_return, return b; } -void mps_message_discard(mps_arena_t mps_arena, +void mps_message_discard(mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; ArenaEnter(arena); @@ -1731,10 +1647,9 @@ void mps_message_discard(mps_arena_t mps_arena, /* -- All Message Types */ -mps_message_type_t mps_message_type(mps_arena_t mps_arena, +mps_message_type_t mps_message_type(mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; MessageType type; @@ -1747,10 +1662,9 @@ mps_message_type_t mps_message_type(mps_arena_t mps_arena, return (mps_message_type_t)type; } -mps_clock_t mps_message_clock(mps_arena_t mps_arena, +mps_clock_t mps_message_clock(mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; Clock postedClock; @@ -1767,10 +1681,9 @@ mps_clock_t mps_message_clock(mps_arena_t mps_arena, /* -- mps_message_type_finalization */ void mps_message_finalization_ref(mps_addr_t *mps_addr_return, - mps_arena_t mps_arena, + mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; Ref ref; @@ -1787,10 +1700,9 @@ void mps_message_finalization_ref(mps_addr_t *mps_addr_return, /* -- mps_message_type_gc */ -size_t mps_message_gc_live_size(mps_arena_t mps_arena, +size_t mps_message_gc_live_size(mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; Size size; @@ -1803,10 +1715,9 @@ size_t mps_message_gc_live_size(mps_arena_t mps_arena, return (size_t)size; } -size_t mps_message_gc_condemned_size(mps_arena_t mps_arena, +size_t mps_message_gc_condemned_size(mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; Size size; @@ -1819,10 +1730,9 @@ size_t mps_message_gc_condemned_size(mps_arena_t mps_arena, return (size_t)size; } -size_t mps_message_gc_not_condemned_size(mps_arena_t mps_arena, +size_t mps_message_gc_not_condemned_size(mps_arena_t arena, mps_message_t mps_message) { - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; Size size; @@ -1837,11 +1747,10 @@ size_t mps_message_gc_not_condemned_size(mps_arena_t mps_arena, /* -- mps_message_type_gc_start */ -const char *mps_message_gc_start_why(mps_arena_t mps_arena, +const char *mps_message_gc_start_why(mps_arena_t arena, mps_message_t mps_message) { const char *s; - Arena arena = (Arena)mps_arena; Message message = (Message)mps_message; ArenaEnter(arena); @@ -1858,10 +1767,9 @@ const char *mps_message_gc_start_why(mps_arena_t mps_arena, /* Alert */ -mps_res_t mps_alert_collection_set(mps_arena_t mps_arena, +mps_res_t mps_alert_collection_set(mps_arena_t arena, mps_alert_collection_fn_t fn) { - Arena arena = (Arena)mps_arena; ArenaEnter(arena); arena->alertCollection = fn; ArenaLeave(arena); @@ -1922,7 +1830,7 @@ mps_res_t mps_ap_alloc_pattern_begin(mps_ap_t mps_ap, Arena arena; AVER(mps_ap != NULL); - buf = BufferOfAP((AP)mps_ap); + buf = BufferOfAP(mps_ap); AVER(TESTT(Buffer, buf)); arena = BufferArena(buf); @@ -1943,7 +1851,7 @@ mps_res_t mps_ap_alloc_pattern_end(mps_ap_t mps_ap, Res res; AVER(mps_ap != NULL); - buf = BufferOfAP((AP)mps_ap); + buf = BufferOfAP(mps_ap); AVER(TESTT(Buffer, buf)); UNUSED(alloc_pattern); /* .ramp.hack */ @@ -1964,7 +1872,7 @@ mps_res_t mps_ap_alloc_pattern_reset(mps_ap_t mps_ap) Arena arena; AVER(mps_ap != NULL); - buf = BufferOfAP((AP)mps_ap); + buf = BufferOfAP(mps_ap); AVER(TESTT(Buffer, buf)); arena = BufferArena(buf); @@ -1983,10 +1891,8 @@ mps_res_t mps_ap_alloc_pattern_reset(mps_ap_t mps_ap) /* mps_reservoir_limit_set -- set the reservoir size */ -void mps_reservoir_limit_set(mps_arena_t mps_arena, size_t size) +void mps_reservoir_limit_set(mps_arena_t arena, size_t size) { - Arena arena = (Arena)mps_arena; - ArenaEnter(arena); ReservoirSetLimit(ArenaReservoir(arena), size); ArenaLeave(arena); @@ -1995,9 +1901,8 @@ void mps_reservoir_limit_set(mps_arena_t mps_arena, size_t size) /* mps_reservoir_limit -- return the reservoir size */ -size_t mps_reservoir_limit(mps_arena_t mps_arena) +size_t mps_reservoir_limit(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Size size; ArenaEnter(arena); @@ -2011,9 +1916,8 @@ size_t mps_reservoir_limit(mps_arena_t mps_arena) /* mps_reservoir_available -- return memory available in the reservoir */ -size_t mps_reservoir_available(mps_arena_t mps_arena) +size_t mps_reservoir_available(mps_arena_t arena) { - Arena arena = (Arena)mps_arena; Size size; ArenaEnter(arena); @@ -2030,10 +1934,9 @@ size_t mps_reservoir_available(mps_arena_t mps_arena) /* mps_chain_create -- create a chain */ -mps_res_t mps_chain_create(mps_chain_t *chain_o, mps_arena_t mps_arena, +mps_res_t mps_chain_create(mps_chain_t *chain_o, mps_arena_t arena, size_t gen_count, mps_gen_param_s *params) { - Arena arena = (Arena)mps_arena; Chain chain; Res res; diff --git a/mps/code/mpsicv.c b/mps/code/mpsicv.c index 9dd9192097b..0c003442aff 100644 --- a/mps/code/mpsicv.c +++ b/mps/code/mpsicv.c @@ -431,19 +431,19 @@ static void *test(void *arg, size_t s) } die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, MPS_WORD_CONST(1)), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); obj = objNULL; die(mps_root_create(&singleRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &root_single, &obj, 0), "root_create(single)"); @@ -457,7 +457,7 @@ static void *test(void *arg, size_t s) addr_pool_test(arena, alloced_obj, mv, make(), amcpool, format); die(mps_root_create_fmt(&fmtRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, dylan_fmt_A()->scan, alloced_obj, (mps_addr_t)(((char*)alloced_obj)+asize)), @@ -587,7 +587,7 @@ int main(int argc, char **argv) die(mps_thread_reg(&thread, arena), "thread_reg"); die(mps_root_create_reg(®_root, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, thread, &mps_stack_scan_ambig, marker, (size_t)0), "root_create_reg"); diff --git a/mps/code/mv2test.c b/mps/code/mv2test.c index 02d1ed7a494..d8c80ba0d6a 100644 --- a/mps/code/mv2test.c +++ b/mps/code/mv2test.c @@ -220,7 +220,7 @@ static mps_res_t stress(mps_class_t class, mps_arena_t arena, va_end(arg); if(res != MPS_RES_OK) return res; - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); /* allocate a load of objects */ for(i=0; imode & BufferModeFLIPPED) != 0); Bool trapped = BufferIsTrapped(buffer); - Bool limitzeroed = (buffer->apStruct.limit == 0); + Bool limitzeroed = (buffer->ap_s.limit == 0); pbSketch[3] = 'X'; /* I don't know what's going on! */ @@ -1540,10 +1540,10 @@ static Res amcScanNailed(Bool *totalReturn, ScanState ss, Pool pool, DIAG_SINGLEF(( "amcScanNailed_loop", "scan completed, but had to loop $U times:\n", (WriteFU)loops, " SegSummary: $B\n", (WriteFB)SegSummary(seg), - " ss.white: $B\n", (WriteFB)ss->white, - " ss.unfixedSummary: $B", (WriteFB)ss->unfixedSummary, + " ss.white: $B\n", (WriteFB)ScanStateWhite(ss), + " ss.unfixedSummary: $B", (WriteFB)ScanStateUnfixedSummary(ss), "$S\n", (WriteFS)( - (RefSetSub(ss->unfixedSummary, SegSummary(seg))) + (RefSetSub(ScanStateUnfixedSummary(ss), SegSummary(seg))) ? "" : " <=== This would have failed .verify.segsummary!" ), diff --git a/mps/code/qs.c b/mps/code/qs.c index ae07aea9e60..3d8d730490b 100644 --- a/mps/code/qs.c +++ b/mps/code/qs.c @@ -338,11 +338,11 @@ static void *go(void *p, size_t s) die(mps_chain_create(&chain, arena, genCOUNT, testChain), "chain_create"); die(mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "AMCCreate"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "APCreate"); - die(mps_root_create_table(®root, arena, MPS_RANK_AMBIG, 0, + die(mps_ap_create(&ap, pool, mps_rank_exact()), "APCreate"); + die(mps_root_create_table(®root, arena, mps_rank_ambig(), 0, (mps_addr_t *)reg, NREGS), "RootCreateTable"); - die(mps_root_create_table(&actroot, arena, MPS_RANK_AMBIG, 0, + die(mps_root_create_table(&actroot, arena, mps_rank_ambig(), 0, (mps_addr_t *)&activationStack, sizeof(QSCell)/sizeof(mps_addr_t)), "RootCreateTable"); diff --git a/mps/code/segsmss.c b/mps/code/segsmss.c index 5a557be9c63..8f7c6095308 100644 --- a/mps/code/segsmss.c +++ b/mps/code/segsmss.c @@ -682,7 +682,7 @@ static void mps_amst_ap_stress(mps_ap_t ap) Buffer buffer; Seg seg; - buffer = BufferOfAP((AP)ap); + buffer = BufferOfAP(ap); AVERT(Buffer, buffer); seg = BufferSeg(buffer); AMSTStressBufferedSeg(seg, buffer); @@ -764,8 +764,8 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool, arena, mps_class_amst(), format), "pool_create(amst)"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); - die(mps_ap_create(&busy_ap, pool, MPS_RANK_EXACT), "BufferCreate 2"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); + die(mps_ap_create(&busy_ap, pool, mps_rank_exact()), "BufferCreate 2"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; @@ -773,12 +773,12 @@ static void *test(void *arg, size_t s) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); diff --git a/mps/code/steptest.c b/mps/code/steptest.c index 7236e9aaa9c..b4f957af79a 100644 --- a/mps/code/steptest.c +++ b/mps/code/steptest.c @@ -318,7 +318,7 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "pool_create(amc)"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "BufferCreate"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "BufferCreate"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; @@ -326,12 +326,12 @@ static void *test(void *arg, size_t s) ambigRoots[i] = rnd_addr(); die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); die(mps_root_create_table(&ambigRoot, arena, - MPS_RANK_AMBIG, (mps_rm_t)0, + mps_rank_ambig(), (mps_rm_t)0, &ambigRoots[0], ambigRootsCOUNT), "root_create_table(ambig)"); diff --git a/mps/code/testlib.h b/mps/code/testlib.h index d16f4fb6eef..2bcd50e7c18 100644 --- a/mps/code/testlib.h +++ b/mps/code/testlib.h @@ -118,7 +118,7 @@ typedef long longest_t; * argument on stderr and exits the program. Otherwise does nothing. * * Typical use: - * die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "APCreate"); + * die(mps_ap_create(&ap, pool, mps_rank_exact()), "APCreate"); */ extern void die(mps_res_t res, const char *s); diff --git a/mps/code/trace.c b/mps/code/trace.c index 9771797337d..eb497cd2314 100644 --- a/mps/code/trace.c +++ b/mps/code/trace.c @@ -40,12 +40,12 @@ Bool ScanStateCheck(ScanState ss) CHECKS(ScanState, ss); CHECKL(FUNCHECK(ss->fix)); /* Can't check ss->fixClosure. */ - CHECKL(ss->zoneShift == ss->arena->zoneShift); + CHECKL(ScanStateZoneShift(ss) == ss->arena->zoneShift); white = ZoneSetEMPTY; TRACE_SET_ITER(ti, trace, ss->traces, ss->arena) white = ZoneSetUnion(white, ss->arena->trace[ti].white); TRACE_SET_ITER_END(ti, trace, ss->traces, ss->arena); - CHECKL(ss->white == white); + CHECKL(ScanStateWhite(ss) == white); CHECKU(Arena, ss->arena); /* Summaries could be anything, and can't be checked. */ CHECKL(TraceSetCheck(ss->traces)); @@ -94,12 +94,12 @@ void ScanStateInit(ScanState ss, TraceSet ts, Arena arena, ss->rank = rank; ss->traces = ts; - ss->zoneShift = arena->zoneShift; - ss->unfixedSummary = RefSetEMPTY; + ScanStateSetZoneShift(ss, arena->zoneShift); + ScanStateSetUnfixedSummary(ss, RefSetEMPTY); ss->fixedSummary = RefSetEMPTY; ss->arena = arena; ss->wasMarked = TRUE; - ss->white = white; + ScanStateSetWhite(ss, white); STATISTIC(ss->fixRefCount = (Count)0); STATISTIC(ss->segRefCount = (Count)0); STATISTIC(ss->whiteSegRefCount = (Count)0); @@ -1108,7 +1108,7 @@ void ScanStateSetSummary(ScanState ss, RefSet summary) AVERT(ScanState, ss); /* Can't check summary, as it can be anything. */ - ss->unfixedSummary = RefSetEMPTY; + ScanStateSetUnfixedSummary(ss, RefSetEMPTY); ss->fixedSummary = summary; AVER(ScanStateSummary(ss) == summary); } @@ -1127,7 +1127,8 @@ RefSet ScanStateSummary(ScanState ss) AVERT(ScanState, ss); return RefSetUnion(ss->fixedSummary, - RefSetDiff(ss->unfixedSummary, ss->white)); + RefSetDiff(ScanStateUnfixedSummary(ss), + ScanStateWhite(ss))); } @@ -1156,16 +1157,17 @@ static Res traceScanSegRes(TraceSet ts, Rank rank, Arena arena, Seg seg) /* Setup result code to return later. */ res = ResOK; } else { /* scan it */ - ScanStateStruct ss; - ScanStateInit(&ss, ts, arena, rank, white); + ScanStateStruct ssStruct; + ScanState ss = &ssStruct; + ScanStateInit(ss, ts, arena, rank, white); /* Expose the segment to make sure we can scan it. */ ShieldExpose(arena, seg); - res = PoolScan(&wasTotal, &ss, SegPool(seg), seg); + res = PoolScan(&wasTotal, ss, SegPool(seg), seg); /* Cover, regardless of result */ ShieldCover(arena, seg); - traceSetUpdateCounts(ts, arena, &ss, traceAccountingPhaseSegScan); + traceSetUpdateCounts(ts, arena, ss, traceAccountingPhaseSegScan); /* Count segments scanned pointlessly */ STATISTIC_STAT ({ @@ -1186,19 +1188,19 @@ static Res traceScanSegRes(TraceSet ts, Rank rank, Arena arena, Seg seg) /* .verify.segsummary: were the seg contents, as found by this * scan, consistent with the recorded SegSummary? */ - AVER(RefSetSub(ss.unfixedSummary, SegSummary(seg))); + AVER(RefSetSub(ScanStateUnfixedSummary(ss), SegSummary(seg))); if(res != ResOK || !wasTotal) { /* scan was partial, so... */ /* scanned summary should be ORed into segment summary. */ - SegSetSummary(seg, RefSetUnion(SegSummary(seg), ScanStateSummary(&ss))); + SegSetSummary(seg, RefSetUnion(SegSummary(seg), ScanStateSummary(ss))); } else { /* all objects on segment have been scanned, so... */ /* scanned summary should replace the segment summary. */ - SegSetSummary(seg, ScanStateSummary(&ss)); + SegSetSummary(seg, ScanStateSummary(ss)); } - ScanStateFinish(&ss); + ScanStateFinish(ss); } if(res == ResOK) { @@ -1314,7 +1316,7 @@ static Res TraceFix2(ScanState ss, Ref *refIO) ref = *refIO; /* The zone test should already have been passed by MPS_FIX1 in mps.h. */ - AVER_CRITICAL(ZoneSetInter(ss->white, + AVER_CRITICAL(ZoneSetInter(ScanStateWhite(ss), ZoneSetAdd(ss->arena, ZoneSetEMPTY, ref)) != ZoneSetEMPTY); @@ -1388,7 +1390,7 @@ static Res TraceFix2(ScanState ss, Ref *refIO) * function is in trace.c and not mpsi.c. */ -mps_res_t mps_fix2(mps_ss_t mps_ss, mps_addr_t *mps_ref_io) +mps_res_t _mps_fix2(mps_ss_t mps_ss, mps_addr_t *mps_ref_io) { ScanState ss = (ScanState)mps_ss; Ref *refIO = (Ref *)mps_ref_io; diff --git a/mps/code/walkt0.c b/mps/code/walkt0.c index 4b2163d88ee..f4618fd420c 100644 --- a/mps/code/walkt0.c +++ b/mps/code/walkt0.c @@ -147,13 +147,13 @@ static void *test(void *arg, size_t s) die(mps_pool_create(&pool, arena, mps_class_amc(), format, chain), "pool_create(amc)"); - die(mps_ap_create(&ap, pool, MPS_RANK_EXACT), "ap_create"); + die(mps_ap_create(&ap, pool, mps_rank_exact()), "ap_create"); for(i = 0; i < exactRootsCOUNT; ++i) exactRoots[i] = objNULL; die(mps_root_create_table_masked(&exactRoot, arena, - MPS_RANK_EXACT, (mps_rm_t)0, + mps_rank_exact(), (mps_rm_t)0, &exactRoots[0], exactRootsCOUNT, (mps_word_t)1), "root_create_table(exact)"); diff --git a/mps/code/zcoll.c b/mps/code/zcoll.c index 494b443e6b7..be698733a73 100644 --- a/mps/code/zcoll.c +++ b/mps/code/zcoll.c @@ -754,18 +754,18 @@ static void *testscriptB(void *arg, size_t s) for(i = 0; i < myrootAmbigCOUNT; ++i) { myrootAmbig[i] = NULL; } - die(mps_root_create_table(&root_table_Ambig, arena, MPS_RANK_AMBIG, (mps_rm_t)0, + die(mps_root_create_table(&root_table_Ambig, arena, mps_rank_ambig(), (mps_rm_t)0, myrootAmbig, (size_t)myrootAmbigCOUNT), "root_create - ambig"); for(i = 0; i < myrootExactCOUNT; ++i) { myrootExact[i] = NULL; } - die(mps_root_create_table(&root_table_Exact, arena, MPS_RANK_EXACT, (mps_rm_t)0, + die(mps_root_create_table(&root_table_Exact, arena, mps_rank_exact(), (mps_rm_t)0, myrootExact, (size_t)myrootExactCOUNT), "root_create - exact"); - die(mps_ap_create(&ap, amc, MPS_RANK_EXACT), "ap_create"); + die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create"); /* root_stackreg: stack & registers are ambiguous roots = mutator's workspace */ stack_start = &stack_starts_here; diff --git a/mps/code/zmess.c b/mps/code/zmess.c index a1ec5f34466..88f84d2a1af 100644 --- a/mps/code/zmess.c +++ b/mps/code/zmess.c @@ -326,10 +326,10 @@ static void *testscriptB(void *arg, size_t s) for(i = 0; i < myrootCOUNT; ++i) { myroot[i] = NULL; } - die(mps_root_create_table(&root_table, arena, MPS_RANK_EXACT, (mps_rm_t)0, + die(mps_root_create_table(&root_table, arena, mps_rank_exact(), (mps_rm_t)0, myroot, (size_t)myrootCOUNT), "root_create"); - die(mps_ap_create(&ap, amc, MPS_RANK_EXACT), "ap_create"); + die(mps_ap_create(&ap, amc, mps_rank_exact()), "ap_create"); /* root_stackreg: stack & registers are ambiguous roots = mutator's workspace */ die(mps_root_create_reg(&root_stackreg, arena,