Scan at correct rank according to the band in arenaread.

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

2 files changed, 19 insertions, 6 deletions

diff --git a/mps/code/global.c b/mps/code/global.c
index 3ca9745388f..5368cb6a04b 100644
--- a/mps/code/global.c
+++ b/mps/code/global.c
@@ -915,12 +915,16 @@ void ArenaPokeSeg(Arena arena, Seg seg, Ref *p, Ref ref)
 /* ArenaRead -- read a single reference, possibly through a barrier
  *
  * This forms part of a software barrier.  It provides fine-grain access
- * to single references in segments.  */
+ * to single references in segments.
+ * 
+ * See also PoolSingleAccess and PoolSegAccess. */
 
 Ref ArenaRead(Arena arena, Ref *p)
 {
   Bool b;
   Seg seg = NULL;       /* suppress "may be used uninitialized" */
+  Rank rank;
+  Ref ref;
 
   AVERT(Arena, arena);
 
@@ -935,10 +939,13 @@ Ref ArenaRead(Arena arena, Ref *p)
   /* it somewhere after having read it) references that are white. */
   AVER(TraceSetSub(SegWhite(seg), arena->flippedTraces));
 
-  /* .read.conservative: @@@@ Should scan at rank phase-of-trace, */
-  /* not RankEXACT which is conservative.  See also */
-  /* <code/trace.c#scan.conservative> for a similar nasty. */
-  TraceScanSingleRef(arena->flippedTraces, RankEXACT, arena, seg, p);
+  /* .read.conservative: Scan according to rank phase-of-trace, */
+  /* See <code/trace.c#scan.conservative> */
+  rank = TraceRankForAccess(arena, seg);
+  TraceScanSingleRef(arena->flippedTraces, rank, arena, seg, p);
+  /* We don't need to update the Seg Summary as in PoolSingleAccess
+   * because we are not changing it after it has been scanned. */
+  
   /* get the possibly fixed reference */
   return ArenaPeekSeg(arena, seg, p);
 }
diff --git a/mps/code/poolabs.c b/mps/code/poolabs.c
index 9834feb711d..e3e45b7480c 100644
--- a/mps/code/poolabs.c
+++ b/mps/code/poolabs.c
@@ -348,6 +348,8 @@ Res PoolNoAccess(Pool pool, Seg seg, Addr addr,
 
 /* SegAccess
  *
+ * See also PoolSingleAccess
+ *
  * Should be used (for the access method) by Pool Classes which intend
  * to handle page faults by scanning the entire segment and lowering
  * the barrier.
@@ -372,6 +374,8 @@ Res PoolSegAccess(Pool pool, Seg seg, Addr addr,
 
 /* SingleAccess
  *
+ * See also ArenaRead, and PoolSegAccess.
+ *
  * Handles page faults by attempting emulation.  If the faulting
  * instruction cannot be emulated then this function returns ResFAIL.
  *
@@ -410,7 +414,7 @@ Res PoolSingleAccess(Pool pool, Seg seg, Addr addr,
       /* .single-access.assume.ref */
       /* .single-access.improve.format */
       ref = *(Ref *)addr;
-      /* Check that the reference is aligned to a word boundary */
+      /* .tagging: Check that the reference is aligned to a word boundary */
       /* (we assume it is not a reference otherwise). */
       if(WordIsAligned((Word)ref, sizeof(Word))) {
         Rank rank;
@@ -427,6 +431,8 @@ Res PoolSingleAccess(Pool pool, Seg seg, Addr addr,
 
     /* Update SegSummary according to the possibly changed reference. */
     ref = *(Ref *)addr;
+    /* .tagging: ought to check the reference for a tag.  But
+     * this is conservative. */
     SegSetSummary(seg, RefSetAdd(arena, SegSummary(seg), ref));
 
     ShieldCover(arena, seg);