#endif
{
BitWord *bit_array_ptr, *bit_array_end;
- P_ scan_w_start, info; I_ size;
+ P_ scan_w_start, info;
+ I_ size;
LinkLim = lim; /* Only checked for generational collection */
info = next;
}
INFO_PTR(Scan) = (W_) info;
-/*
-if (SM_trace & 8) {
- fprintf(stderr, " Marked: word %ld, val 0x%lx, cur 0x%lx, Scan_w 0x%lx, Scan 0x%lx, Info 0x%lx, Code 0x%lx\n",
- (bit_array_ptr-1) - bit_array, *(bit_array_ptr-1), w, scan_w_start, Scan, info,
- SCAN_LINK_CODE(info)); };
-*/
size = (*SCAN_LINK_CODE(info))();
w >>= 1;
} else { /* Bit Set -- Enter ScanMove for closure*/
-/*HACK if (SM_trace&8) {fprintf(stderr,"Scan=%x\n",Scan);} */
info = (P_) INFO_PTR(Scan);
-/*HACK if (SM_trace&8) {fprintf(stderr,"info=%x\n",info);} */
while (MARKED_LOCATION(info)) {
P_ next;
info = UNMARK_LOCATION(info);
next = (P_) *info;
-/*HACK if (SM_trace&8) {fprintf(stderr,"next=%x\n",next);} */
DEBUG_UNLINK_LOCATION(info, Scan, New);
-/*HACK if (SM_trace&8) {fprintf(stderr,"New=%x\n",New);} */
*info = (W_) New;
info = next;
-/*HACK if (SM_trace&8) {fprintf(stderr,"*info=%x,info=%x\n",*info,info);} */
}
-/*HACK if (SM_trace&8) {fprintf(stderr,"preNew info=%x\n",info);} */
INFO_PTR(New) = (W_) info;
-/*
-if (SM_trace & 8) {
- fprintf(stderr, " Marked: word %ld, cur 0x%lx, Scan_w 0x%lx, Scan 0x%lx, Info 0x%lx, Code 0x%lx\n",
- (bit_array_ptr-1) - bit_array, w, scan_w_start, Scan, info, SCAN_MOVE_CODE(info)); };
-*/
-
size = (*SCAN_MOVE_CODE(info))();
New += size; /* set New address of next closure */
Scan += size; /* skip size bits */
#endif
-#if defined(_GC_DEBUG)
+#if defined(DEBUG)
#define DEBUG_SCAN_LINK(type, sizevar, ptrvar) \
- if (SM_trace & 2) \
+ if (RTSflags.GcFlags.trace & DEBUG_TRACE_MINOR_GC) \
fprintf(stderr, "Scan Link (%s): 0x%lx -> 0x%lx, info 0x%lx, size %ld, ptrs %ld\n", \
type, Scan, New, INFO_PTR(Scan), sizevar, ptrvar)
#define DEBUG_SCAN_MOVE(type, sizevar) \
- if (SM_trace & 2) \
+ if (RTSflags.GcFlags.trace & DEBUG_TRACE_MINOR_GC) \
fprintf(stderr, "Scan Move (%s): 0x%lx -> 0x%lx, info 0x%lx, size %ld\n", \
type, Scan, New, INFO_PTR(New), sizevar)
/*** LINKING CLOSURES ***/
+#ifdef TICKY_TICKY
I_
-_ScanLink_1_0(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 1, 0);
- return(FIXED_HS + 1); /* SPEC_VHS is defined to be 0, so "size" really is 1 */
+_ScanLink_0_0(STG_NO_ARGS) {
+ I_ size = 0; /* NB: SPEC_VHS is *defined* to be zero */
+ DEBUG_SCAN_LINK("SPEC", size, 0);
+ return(FIXED_HS + size);
}
+#endif
+
I_
-_ScanLink_2_0(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 2, 0);
- return(FIXED_HS + 2);
+_ScanLink_1_0(STG_NO_ARGS) {
+ I_ size = 1; /* NB: SPEC_VHS is *defined* to be zero */
+ DEBUG_SCAN_LINK("SPEC", size, 0);
+ return(FIXED_HS + size);
}
I_
-_ScanLink_3_0(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 3, 0);
- return(FIXED_HS + 3);
+_ScanLink_1_1(STG_NO_ARGS) {
+ I_ size = 1;
+ DEBUG_SCAN_LINK("SPEC", size, 1);
+ SPEC_LINK_LOCATION(1);
+ return(FIXED_HS + size);
}
I_
-_ScanLink_4_0(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 4, 0);
- return(FIXED_HS + 4);
+_ScanLink_2_0(STG_NO_ARGS) {
+ I_ size = 2;
+ DEBUG_SCAN_LINK("SPEC", size, 0);
+ return(FIXED_HS + size);
}
I_
-_ScanLink_5_0(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 5, 0);
- return(FIXED_HS + 5);
-}
-
-I_
_ScanLink_2_1(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 2, 1);
+ I_ size = 2;
+ DEBUG_SCAN_LINK("SPEC", size, 1);
SPEC_LINK_LOCATION(1);
- return(FIXED_HS + 2);
+ return(FIXED_HS + size);
}
I_
-_ScanLink_3_1(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 3, 1);
+_ScanLink_2_2(STG_NO_ARGS) {
+ I_ size = 2;
+ DEBUG_SCAN_LINK("SPEC", size, 2);
SPEC_LINK_LOCATION(1);
- return(FIXED_HS + 3);
+ SPEC_LINK_LOCATION(2);
+ return(FIXED_HS + size);
}
I_
-_ScanLink_3_2(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 3, 2);
- SPEC_LINK_LOCATION(1);
- SPEC_LINK_LOCATION(2);
- return(FIXED_HS + 3);
+_ScanLink_3_0(STG_NO_ARGS) {
+ I_ size = 3;
+ DEBUG_SCAN_LINK("SPEC", size, 0);
+ return(FIXED_HS + size);
}
-
I_
-_ScanLink_1_1(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 1, 1);
+_ScanLink_3_1(STG_NO_ARGS) {
+ I_ size = 3;
+ DEBUG_SCAN_LINK("SPEC", size, 1);
SPEC_LINK_LOCATION(1);
- return(FIXED_HS + 1);
+ return(FIXED_HS + size);
}
I_
-_ScanLink_2_2(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 2, 2);
+_ScanLink_3_2(STG_NO_ARGS) {
+ I_ size = 3;
+ DEBUG_SCAN_LINK("SPEC", size, 2);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
- return(FIXED_HS + 2);
+ return(FIXED_HS + size);
}
I_
_ScanLink_3_3(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 3, 3);
+ I_ size = 3;
+ DEBUG_SCAN_LINK("SPEC", size, 3);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
- return(FIXED_HS + 3);
+ return(FIXED_HS + size);
+}
+I_
+_ScanLink_4_0(STG_NO_ARGS) {
+ I_ size = 4;
+ DEBUG_SCAN_LINK("SPEC", size, 0);
+ return(FIXED_HS + size);
}
I_
_ScanLink_4_4(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 4, 4);
+ I_ size = 4;
+ DEBUG_SCAN_LINK("SPEC", size, 4);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(4);
- return(FIXED_HS + 4);
+ return(FIXED_HS + size);
+}
+I_
+_ScanLink_5_0(STG_NO_ARGS) {
+ I_ size = 5;
+ DEBUG_SCAN_LINK("SPEC", size, 0);
+ return(FIXED_HS + size);
}
I_
_ScanLink_5_5(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 5, 5);
+ I_ size = 5;
+ DEBUG_SCAN_LINK("SPEC", size, 5);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(4);
SPEC_LINK_LOCATION(5);
- return(FIXED_HS + 5);
+ return(FIXED_HS + size);
}
I_
_ScanLink_6_6(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 6, 6);
+ I_ size = 6;
+ DEBUG_SCAN_LINK("SPEC", size, 6);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(4);
SPEC_LINK_LOCATION(5);
SPEC_LINK_LOCATION(6);
- return(FIXED_HS + 6);
+ return(FIXED_HS + size);
}
I_
_ScanLink_7_7(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 7, 7);
+ I_ size = 7;
+ DEBUG_SCAN_LINK("SPEC", size, 7);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(5);
SPEC_LINK_LOCATION(6);
SPEC_LINK_LOCATION(7);
- return(FIXED_HS + 7);
+ return(FIXED_HS + size);
}
I_
_ScanLink_8_8(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 8, 8);
+ I_ size = 8;
+ DEBUG_SCAN_LINK("SPEC", size, 8);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(6);
SPEC_LINK_LOCATION(7);
SPEC_LINK_LOCATION(8);
- return(FIXED_HS + 8);
+ return(FIXED_HS + size);
}
I_
_ScanLink_9_9(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 9, 9);
+ I_ size = 9;
+ DEBUG_SCAN_LINK("SPEC", size, 9);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(7);
SPEC_LINK_LOCATION(8);
SPEC_LINK_LOCATION(9);
- return(FIXED_HS + 9);
+ return(FIXED_HS + size);
}
I_
_ScanLink_10_10(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 10, 10);
+ I_ size = 10;
+ DEBUG_SCAN_LINK("SPEC", size, 10);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(8);
SPEC_LINK_LOCATION(9);
SPEC_LINK_LOCATION(10);
- return(FIXED_HS + 10);
+ return(FIXED_HS + size);
}
I_
_ScanLink_11_11(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 11, 11);
+ I_ size = 11;
+ DEBUG_SCAN_LINK("SPEC", size, 11);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(9);
SPEC_LINK_LOCATION(10);
SPEC_LINK_LOCATION(11);
- return(FIXED_HS + 11);
+ return(FIXED_HS + size);
}
I_
_ScanLink_12_12(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("SPEC", 12, 12);
+ I_ size = 12;
+ DEBUG_SCAN_LINK("SPEC", size, 12);
SPEC_LINK_LOCATION(1);
SPEC_LINK_LOCATION(2);
SPEC_LINK_LOCATION(3);
SPEC_LINK_LOCATION(10);
SPEC_LINK_LOCATION(11);
SPEC_LINK_LOCATION(12);
- return(FIXED_HS + 12);
+ return(FIXED_HS + size);
}
\end{code}
I_
_ScanLink_RBH_2_1(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 2, 1);
+ I_ size = 2 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
- return(FIXED_HS + 2); /* ???? but SPEC_RBH_VHS is *not* zero! */
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_3_1(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 3, 1);
+ I_ size = 3 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
- return(FIXED_HS + 3);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_3_3(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 3, 3);
+ I_ size = 3 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 3);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
- return(FIXED_HS + 3);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_4_1(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 4, 1);
+ I_ size = 4 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
- return(FIXED_HS + 4);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_4_4(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 4, 4);
+ I_ size = 4 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 4);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
- return(FIXED_HS + 4);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_5_1(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 5, 1);
+ I_ size = 5 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
- return(FIXED_HS + 5);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_5_5(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 5, 5);
+ I_ size = 5 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 5);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 3);
- return(FIXED_HS + 5);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_6_6(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 6, 6);
+ I_ size = 6 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 6);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 3);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 4);
- return(FIXED_HS + 6);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_7_7(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 7, 7);
+ I_ size = 7 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 7);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 3);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 4);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 5);
- return(FIXED_HS + 7);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_8_8(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 8, 8);
+ I_ size = 8 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 8);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 4);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 5);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 6);
- return(FIXED_HS + 8);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_9_9(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 9, 9);
+ I_ size = 9 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 9);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 5);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 6);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 7);
- return(FIXED_HS + 9);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_10_10(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 10, 10);
+ I_ size = 10 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 10);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 6);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 7);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 8);
- return(FIXED_HS + 10);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_11_11(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 11, 11);
+ I_ size = 11 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 11);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 7);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 8);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 9);
- return(FIXED_HS + 11);
+ return(FIXED_HS + size);
}
-
I_
_ScanLink_RBH_12_12(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("SRBH", 12, 12);
+ I_ size = 12 + SPEC_RBH_VHS;
+ DEBUG_SCAN_LINK("SRBH", size, 12);
LINK_LOCATION(SPEC_RBH_BQ_LOCN);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 1);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 2);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 8);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 9);
LINK_LOCATION(SPEC_RBH_BQ_LOCN + 10);
- return(FIXED_HS + 12);
+ return(FIXED_HS + size);
}
#endif
-
\end{code}
Scan-linking a MallocPtr is straightforward: exactly the same as
\begin{code}
#ifndef PAR
-StgInt
+I_
_ScanLink_MallocPtr(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("MallocPtr", MallocPtr_SIZE, 0);
- return(FIXED_HS + MallocPtr_SIZE);
+ I_ size = MallocPtr_SIZE;
+ DEBUG_SCAN_LINK("MallocPtr", size, 0);
+ return(FIXED_HS + size);
}
#endif /* !PAR */
\end{code}
/*** MOVING CLOSURES ***/
+#ifdef TICKY_TICKY
+I_
+_ScanMove_0(STG_NO_ARGS) {
+ I_ size = 0; /* NB: SPEC_VHS defined to be zero, so 0 really is the "size" */
+ DEBUG_SCAN_MOVE("CONST", size);
+ SLIDE_FIXED_HDR;
+ return(FIXED_HS + size);
+}
+#endif
I_
_ScanMove_1(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 1);
+ I_ size = 1; /* NB: SPEC_VHS defined to be zero, so 1 really is the "size" */
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
- return(FIXED_HS + 1); /* NB: SPEC_VHS defined to be zero, so 1 really is the "size" */
+ return(FIXED_HS + size);
}
I_
_ScanMove_2(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 2);
+ I_ size = 2;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
- return(FIXED_HS + 2);
+ return(FIXED_HS + size);
}
I_
_ScanMove_3(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 3);
+ I_ size = 3;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(3);
- return(FIXED_HS + 3);
+ return(FIXED_HS + size);
}
I_
_ScanMove_4(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 4);
+ I_ size = 4;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(3);
SPEC_SLIDE_WORD(4);
- return(FIXED_HS + 4);
+ return(FIXED_HS + size);
}
I_
_ScanMove_5(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 5);
+ I_ size = 5;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(3);
SPEC_SLIDE_WORD(4);
SPEC_SLIDE_WORD(5);
- return(FIXED_HS + 5);
+ return(FIXED_HS + size);
}
I_
_ScanMove_6(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 6);
+ I_ size = 6;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(4);
SPEC_SLIDE_WORD(5);
SPEC_SLIDE_WORD(6);
- return(FIXED_HS + 6);
+ return(FIXED_HS + size);
}
I_
_ScanMove_7(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 7);
+ I_ size = 7;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(5);
SPEC_SLIDE_WORD(6);
SPEC_SLIDE_WORD(7);
- return(FIXED_HS + 7);
+ return(FIXED_HS + size);
}
I_
_ScanMove_8(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 8);
+ I_ size = 8;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(6);
SPEC_SLIDE_WORD(7);
SPEC_SLIDE_WORD(8);
- return(FIXED_HS + 8);
+ return(FIXED_HS + size);
}
I_
_ScanMove_9(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 9);
+ I_ size = 9;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(7);
SPEC_SLIDE_WORD(8);
SPEC_SLIDE_WORD(9);
- return(FIXED_HS + 9);
+ return(FIXED_HS + size);
}
I_
_ScanMove_10(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 10);
+ I_ size = 10;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(8);
SPEC_SLIDE_WORD(9);
SPEC_SLIDE_WORD(10);
- return(FIXED_HS + 10);
+ return(FIXED_HS + size);
}
I_
_ScanMove_11(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 11);
+ I_ size = 11;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(9);
SPEC_SLIDE_WORD(10);
SPEC_SLIDE_WORD(11);
- return(FIXED_HS + 11);
+ return(FIXED_HS + size);
}
I_
_ScanMove_12(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SPEC", 12);
+ I_ size = 12;
+ DEBUG_SCAN_MOVE("SPEC", size);
SLIDE_FIXED_HDR;
SPEC_SLIDE_WORD(1);
SPEC_SLIDE_WORD(2);
SPEC_SLIDE_WORD(10);
SPEC_SLIDE_WORD(11);
SPEC_SLIDE_WORD(12);
- return(FIXED_HS + 12);
+ return(FIXED_HS + size);
}
#if defined(PAR) && defined(GC_MUT_REQUIRED)
I_
_ScanMove_RBH_2(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 2);
+ I_ size = 2 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 2); /* ???? SPEC_RBH_VHS is *not* zero! */
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_3(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 3);
+ I_ size = 3 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 3);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_4(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 4);
+ I_ size = 4 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 4);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_5(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 5);
+ I_ size = 5 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 5);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_6(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 6);
+ I_ size = 6 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 6);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_7(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 7);
+ I_ size = 7 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 7);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_8(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 8);
+ I_ size = 8 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 8);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_9(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 9);
+ I_ size = 9 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 9);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_10(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 10);
+ I_ size = 10 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 10);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_11(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 11);
+ I_ size = 11 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 11);
+ return(FIXED_HS + size);
}
I_
_ScanMove_RBH_12(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("SRBH", 12);
+ I_ size = 12 + SPEC_RBH_VHS;
+ DEBUG_SCAN_MOVE("SRBH", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(SPEC_RBH_HS + 0);
SLIDE_WORD(SPEC_RBH_HS + 1);
MUT_LINK(New) = (W_) StorageMgrInfo.OldMutables;
StorageMgrInfo.OldMutables = (P_) New;
- return(FIXED_HS + 12);
+ return(FIXED_HS + size);
}
#endif
\end{code}
\begin{code}
#ifndef PAR
-StgInt
+I_
_ScanMove_MallocPtr(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("MallocPtr", MallocPtr_SIZE);
+ I_ size = MallocPtr_SIZE;
+ DEBUG_SCAN_MOVE("MallocPtr", size);
-#if defined(_GC_DEBUG)
- if (SM_trace & 16) {
+#if defined(DEBUG)
+ if (RTSflags.GcFlags.trace & DEBUG_TRACE_MALLOCPTRS) {
printf("Moving MallocPtr(%x)=<%x,%x,%x>", Scan, Scan[0], Scan[1], Scan[2]);
printf(" Data = %x, Next = %x\n",
MallocPtr_CLOSURE_DATA(Scan), MallocPtr_CLOSURE_LINK(Scan) );
MallocPtr_SLIDE_DATA;
MallocPtr_RELINK;
-#if defined(_GC_DEBUG)
- if (SM_trace & 16) {
+#if defined(DEBUG)
+ if (RTSflags.GcFlags.trace & DEBUG_TRACE_MALLOCPTRS) {
printf("Moved MallocPtr(%x)=<%x,_,%x,%x,%x>", New, New[0], New[1], New[2], New[3]);
printf(" Data = %x, Next = %x",
MallocPtr_CLOSURE_DATA(New), MallocPtr_CLOSURE_LINK(New) );
}
#endif
- return(FIXED_HS + MallocPtr_SIZE);
+ return(FIXED_HS + size);
}
#endif /* !PAR */
\end{code}
I_
_ScanLink_BH_U(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("BH ", MIN_UPD_SIZE, 0);
- return(FIXED_HS + BH_U_SIZE); /* size includes _VHS */
- /* NB: pretty intimate knowledge about BH closure layout */
+ I_ size = BH_U_SIZE;
+ DEBUG_SCAN_LINK("BH ", size, 0);
+ return(FIXED_HS + size);
}
I_
_ScanMove_BH_U(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("BH ", MIN_UPD_SIZE);
+ I_ size = BH_U_SIZE;
+ DEBUG_SCAN_MOVE("BH ", size);
SLIDE_FIXED_HDR;
- return(FIXED_HS + BH_U_SIZE);
- /* ditto */
+ return(FIXED_HS + size);
}
I_
_ScanLink_BH_N(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("BH N", MIN_NONUPD_SIZE, 0);
- return(FIXED_HS + BH_N_SIZE); /* size includes _VHS */
- /* NB: pretty intimate knowledge about BH closure layout */
+ I_ size = BH_N_SIZE;
+ DEBUG_SCAN_LINK("BH N", size, 0);
+ return(FIXED_HS + size);
}
I_
_ScanMove_BH_N(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("BH N",MIN_NONUPD_SIZE);
+ I_ size = BH_N_SIZE;
+ DEBUG_SCAN_MOVE("BH N", size);
SLIDE_FIXED_HDR;
- return(FIXED_HS + BH_N_SIZE);
- /* ditto */
+ return(FIXED_HS + size);
}
-#ifdef USE_COST_CENTRES
+#if defined(PROFILING) || defined(TICKY_TICKY)
I_
_ScanLink_PI(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("PI ", IND_CLOSURE_SIZE(dummy), 1);
+ I_ size = IND_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_LINK("PI ", size, 1);
LINK_LOCATION(IND_HS);
- return(FIXED_HS + IND_CLOSURE_SIZE(dummy) /*MIN_UPD_SIZE*/);
+ return(FIXED_HS + size);
}
I_
_ScanMove_PI(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("PI ", IND_CLOSURE_SIZE(dummy));
+ I_ size = IND_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_MOVE("PI ", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(IND_HS);
- return(FIXED_HS + IND_CLOSURE_SIZE(dummy) /*MIN_UPD_SIZE*/);
+ return(FIXED_HS + size);
}
#endif
I_
_ScanLink_FetchMe(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("FME ", MIN_UPD_SIZE, 0);
- return(FIXED_HS + FETCHME_CLOSURE_SIZE(dummy) /*MIN_UPD_SIZE*/);
+ I_ size = FETCHME_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_LINK("FME ", size, 0);
+ return(FIXED_HS + size);
}
I_
_ScanMove_FetchMe(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("FME ",MIN_UPD_SIZE);
+ I_ size = FETCHME_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_MOVE("FME ", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(FETCHME_GA_LOCN);
ASSERT(GALAlookup(FETCHME_GA(New)) != NULL);
StorageMgrInfo.OldMutables = (P_) New;
#endif
- return(FIXED_HS + FETCHME_CLOSURE_SIZE(dummy) /*MIN_UPD_SIZE*/);
+ return(FIXED_HS + size);
}
I_
_ScanLink_BF(STG_NO_ARGS)
{
- DEBUG_SCAN_LINK("BF", BF_HS, 2 /*possibly wrong (WDP 95/07)*/);
+ I_ size = BF_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_LINK("BF", size, 2);
LINK_LOCATION(BF_LINK_LOCN);
LINK_LOCATION(BF_NODE_LOCN);
- return(FIXED_HS + BF_CLOSURE_SIZE(dummy));
+ return(FIXED_HS + size);
}
I_
_ScanMove_BF(STG_NO_ARGS)
{
I_ count;
+ I_ size = BF_CLOSURE_SIZE(dummy);
SLIDE_FIXED_HDR;
for (count = FIXED_HS; count < FIXED_HS + BF_VHS; count++) {
StorageMgrInfo.OldMutables = (P_) New;
#endif
- return(FIXED_HS + BF_CLOSURE_SIZE(dummy));
+ return(FIXED_HS + size);
}
#endif /* PAR */
I_
_ScanLink_BQ(STG_NO_ARGS) {
- DEBUG_SCAN_LINK("BQ ", BQ_CLOSURE_SIZE(dummy), BQ_CLOSURE_NoPTRS(Scan));
+ I_ size = BQ_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_LINK("BQ ", size, BQ_CLOSURE_NoPTRS(Scan));
LINK_LOCATION(BQ_HS);
- return(FIXED_HS + BQ_CLOSURE_SIZE(dummy));
+ return(FIXED_HS + size);
}
I_
_ScanMove_BQ(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("BQ ", BQ_CLOSURE_SIZE(dummy));
+ I_ size = BQ_CLOSURE_SIZE(dummy);
+ DEBUG_SCAN_MOVE("BQ ", size);
SLIDE_FIXED_HDR;
SLIDE_WORD(BQ_HS);
StorageMgrInfo.OldMutables = (P_) New;
#endif
- return(FIXED_HS + BQ_CLOSURE_SIZE(dummy));
+ return(FIXED_HS + size);
}
I_
STGRegisterTable *r = TSO_INTERNAL_PTR(Scan);
W_ liveness = r->rLiveness;
I_ i;
+ I_ size = TSO_VHS + TSO_CTS_SIZE;
- DEBUG_SCAN_LINK("TSO", TSO_HS + TSO_CTS_SIZE, 0/*wrong*/);
+ DEBUG_SCAN_LINK("TSO", size, 0/*wrong*/);
LINK_LOCATION(TSO_LINK_LOCN);
LINK_LOCATION(((P_) &r->rStkO) - Scan);
LINK_LOCATION(((P_) &r->rR[i].p) - Scan)
}
}
- return(TSO_HS + TSO_CTS_SIZE);
+ return(FIXED_HS + size);
}
I_
_ScanMove_TSO(STG_NO_ARGS)
{
I_ count;
+ I_ size = TSO_VHS + TSO_CTS_SIZE;
SLIDE_FIXED_HDR;
for (count = FIXED_HS; count < FIXED_HS + TSO_VHS; count++) {
StorageMgrInfo.OldMutables = (P_) New;
#endif
- return(TSO_HS + TSO_CTS_SIZE);
+ return(FIXED_HS + size);
}
I_
LINK_LOCATION(STKO_LINK_LOCN);
/* Link the locations in the A stack */
- DEBUG_SCAN_LINK("STKO", size, cts_size - STKO_SpA_OFFSET(SCAN) + 1);
+ DEBUG_SCAN_LINK("STKO", size, cts_size - STKO_SpA_OFFSET(Scan) + 1);
for (count = STKO_SpA_OFFSET(Scan); count <= cts_size; count++) {
STKO_LINK_LOCATION(count);
}
sub = STKO_CLOSURE_OFFSET(Scan, subptr);
}
- /*
- I assume what's wanted is the size of the object
- rather the number of pointers in the object. KH
- */
+ ASSERT(sanityChk_StkO(Scan));
+
return(FIXED_HS + size);
}
DEBUG_SCAN_MOVE("STKO", size);
SLIDE_FIXED_HDR;
-#ifdef DO_REDN_COUNTING
+#ifdef TICKY_TICKY
SLIDE_WORD(STKO_ADEP_LOCN);
SLIDE_WORD(STKO_BDEP_LOCN);
#endif
StorageMgrInfo.OldMutables = (P_) New;
#endif
+ /* ToDo: ASSERT(sanityChk_StkO(Scan or New)); ??? */
+
return(FIXED_HS + size);
}
\end{code}
\begin{code}
-#if defined(GCgn)
-I_
-_ScanMove_OldRoot(STG_NO_ARGS) {
- DEBUG_SCAN_MOVE("OLDR", 2);
- SLIDE_FIXED_HDR;
- IND_CLOSURE_PTR(New) = IND_CLOSURE_PTR(Scan);
- IND_CLOSURE_LINK(New) = (W_) genInfo.OldInNew;
- genInfo.OldInNew = New;
- genInfo.OldInNewno++;
- return(IND_HS + MIN_UPD_SIZE); /* this looks wrong (WDP 95/07) */
-}
-#endif /* GCgn */
-
/*** Dummy Entries -- Should not be entered ***/
/* Should not be in a .lc file either... --JSM */
}
#endif /* _INFO_COMPACTING */
-
\end{code}
projects / ghc-hetmet.git / blobdiff