Fix building RTS with gcc 2.*; declare all variables at the top of a block

Patch from Audrey Tang.

diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c
index d892e95..b71e126 100644 (file)
--- a/rts/RaiseAsync.c
+++ b/rts/RaiseAsync.c
@@ -942,10 +942,12 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
        }
 
        case STOP_FRAME:
        }
 
        case STOP_FRAME:

+       {

            // We've stripped the entire stack, the thread is now dead.
            tso->what_next = ThreadKilled;
            tso->sp = frame + sizeofW(StgStopFrame);
            return;
            // We've stripped the entire stack, the thread is now dead.
            tso->what_next = ThreadKilled;
            tso->sp = frame + sizeofW(StgStopFrame);
            return;

+       }

 
        case CATCH_FRAME:
            // If we find a CATCH_FRAME, and we've got an exception to raise,
 
        case CATCH_FRAME:
            // If we find a CATCH_FRAME, and we've got an exception to raise,

@@ -1017,15 +1019,17 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
            // whether the transaction is valid or not because its
            // possible validity cannot have caused the exception
            // and will not be visible after the abort.
            // whether the transaction is valid or not because its
            // possible validity cannot have caused the exception
            // and will not be visible after the abort.

-           debugTrace(DEBUG_stm, 
-                      "found atomically block delivering async exception");

 
 

+               {

             StgTRecHeader *trec = tso -> trec;
             StgTRecHeader *outer = stmGetEnclosingTRec(trec);
             StgTRecHeader *trec = tso -> trec;
             StgTRecHeader *outer = stmGetEnclosingTRec(trec);

+           debugTrace(DEBUG_stm, 
+                      "found atomically block delivering async exception");

             stmAbortTransaction(cap, trec);
            stmFreeAbortedTRec(cap, trec);
             tso -> trec = outer;
            break;
             stmAbortTransaction(cap, trec);
            stmFreeAbortedTRec(cap, trec);
             tso -> trec = outer;
            break;

+           };

            
        default:
            break;
            
        default:
            break;

diff --git a/rts/RetainerProfile.c b/rts/RetainerProfile.c
index f752506..036eacf 100644 (file)
--- a/rts/RetainerProfile.c
+++ b/rts/RetainerProfile.c
@@ -864,6 +864,7 @@ pop( StgClosure **c, StgClosure **cp, retainer *r )
            // we divide the step counter: the 2 low bits indicate
            // which field, and the rest of the bits indicate the
            // entry number (starting from zero).
            // we divide the step counter: the 2 low bits indicate
            // which field, and the rest of the bits indicate the
            // entry number (starting from zero).

+           TRecEntry *entry;

            nat entry_no = se->info.next.step >> 2;
            nat field_no = se->info.next.step & 3;
            if (entry_no == ((StgTRecChunk *)se->c)->next_entry_idx) {
            nat entry_no = se->info.next.step >> 2;
            nat field_no = se->info.next.step & 3;
            if (entry_no == ((StgTRecChunk *)se->c)->next_entry_idx) {

@@ -871,7 +872,7 @@ pop( StgClosure **c, StgClosure **cp, retainer *r )
                popOff();
                return;
            }
                popOff();
                return;
            }

-           TRecEntry *entry = &((StgTRecChunk *)se->c)->entries[entry_no];
+           entry = &((StgTRecChunk *)se->c)->entries[entry_no];

            if (field_no == 0) {
                *c = (StgClosure *)entry->tvar;
            } else if (field_no == 1) {
            if (field_no == 0) {
                *c = (StgClosure *)entry->tvar;
            } else if (field_no == 1) {

diff --git a/rts/STM.c b/rts/STM.c
index f9c814f..c43e7ca 100644 (file)
--- a/rts/STM.c
+++ b/rts/STM.c
@@ -596,8 +596,9 @@ static void remove_watch_queue_entries_for_trec(Capability *cap,
     StgTVarWatchQueue *pq;
     StgTVarWatchQueue *nq;
     StgTVarWatchQueue *q;
     StgTVarWatchQueue *pq;
     StgTVarWatchQueue *nq;
     StgTVarWatchQueue *q;

+    StgClosure *saw;

     s = e -> tvar;
     s = e -> tvar;

-    StgClosure *saw = lock_tvar(trec, s);
+    saw = lock_tvar(trec, s);

     q = (StgTVarWatchQueue *) (e -> new_value);
     TRACE("%p : removing tso=%p from watch queue for tvar=%p", 
          trec, 
     q = (StgTVarWatchQueue *) (e -> new_value);
     TRACE("%p : removing tso=%p from watch queue for tvar=%p", 
          trec, 

@@ -943,6 +944,7 @@ StgTRecHeader *stmStartTransaction(Capability *cap,
 
 void stmAbortTransaction(Capability *cap,
                          StgTRecHeader *trec) {
 
 void stmAbortTransaction(Capability *cap,
                          StgTRecHeader *trec) {

+  StgTRecHeader *et;

   TRACE("%p : stmAbortTransaction", trec);
   ASSERT (trec != NO_TREC);
   ASSERT ((trec -> state == TREC_ACTIVE) || 
   TRACE("%p : stmAbortTransaction", trec);
   ASSERT (trec != NO_TREC);
   ASSERT ((trec -> state == TREC_ACTIVE) || 

@@ -951,7 +953,7 @@ void stmAbortTransaction(Capability *cap,
 
   lock_stm(trec);
 
 
   lock_stm(trec);
 

-  StgTRecHeader *et = trec -> enclosing_trec;
+  et = trec -> enclosing_trec;

   if (et == NO_TREC) {
     // We're a top-level transaction: remove any watch queue entries that
     // we may have.
   if (et == NO_TREC) {
     // We're a top-level transaction: remove any watch queue entries that
     // we may have.

@@ -1165,13 +1167,13 @@ static void connect_invariant_to_trec(Capability *cap,
 void stmAddInvariantToCheck(Capability *cap, 
                            StgTRecHeader *trec,
                            StgClosure *code) {
 void stmAddInvariantToCheck(Capability *cap, 
                            StgTRecHeader *trec,
                            StgClosure *code) {

+  StgAtomicInvariant *invariant;
+  StgInvariantCheckQueue *q;

   TRACE("%p : stmAddInvariantToCheck closure=%p", trec, code);
   ASSERT(trec != NO_TREC);
   ASSERT(trec -> state == TREC_ACTIVE ||
         trec -> state == TREC_CONDEMNED);
 
   TRACE("%p : stmAddInvariantToCheck closure=%p", trec, code);
   ASSERT(trec != NO_TREC);
   ASSERT(trec -> state == TREC_ACTIVE ||
         trec -> state == TREC_CONDEMNED);
 

-  StgAtomicInvariant *invariant;
-  StgInvariantCheckQueue *q;

 
   // 1. Allocate an StgAtomicInvariant, set last_execution to NO_TREC
   //    to signal that this is a new invariant in the current atomic block
 
   // 1. Allocate an StgAtomicInvariant, set last_execution to NO_TREC
   //    to signal that this is a new invariant in the current atomic block

@@ -1200,6 +1202,7 @@ void stmAddInvariantToCheck(Capability *cap,
  */
 
 StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, StgTRecHeader *trec) {
  */
 
 StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, StgTRecHeader *trec) {

+  StgTRecChunk *c;

   TRACE("%p : stmGetInvariantsToCheck, head was %p", 
        trec,
        trec -> invariants_to_check);
   TRACE("%p : stmGetInvariantsToCheck, head was %p", 
        trec,
        trec -> invariants_to_check);

@@ -1211,7 +1214,7 @@ StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, StgTRecHeader *
   ASSERT(trec -> enclosing_trec == NO_TREC);
 
   lock_stm(trec);
   ASSERT(trec -> enclosing_trec == NO_TREC);
 
   lock_stm(trec);

-  StgTRecChunk *c = trec -> current_chunk;
+  c = trec -> current_chunk;

   while (c != END_STM_CHUNK_LIST) {
     unsigned int i;
     for (i = 0; i < c -> next_entry_idx; i ++) {
   while (c != END_STM_CHUNK_LIST) {
     unsigned int i;
     for (i = 0; i < c -> next_entry_idx; i ++) {

@@ -1223,15 +1226,15 @@ StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, StgTRecHeader *
        // Pick up any invariants on the TVar being updated
        // by entry "e"
 
        // Pick up any invariants on the TVar being updated
        // by entry "e"
 

-       TRACE("%p : checking for invariants on %p", trec, s);

        StgTVarWatchQueue *q;
        StgTVarWatchQueue *q;

+       TRACE("%p : checking for invariants on %p", trec, s);

        for (q = s -> first_watch_queue_entry;
             q != END_STM_WATCH_QUEUE;
             q = q -> next_queue_entry) {
          if (watcher_is_invariant(q)) {
        for (q = s -> first_watch_queue_entry;
             q != END_STM_WATCH_QUEUE;
             q = q -> next_queue_entry) {
          if (watcher_is_invariant(q)) {

-           TRACE("%p : Touching invariant %p", trec, q -> closure);

            StgBool found = FALSE;
            StgInvariantCheckQueue *q2;
            StgBool found = FALSE;
            StgInvariantCheckQueue *q2;

+           TRACE("%p : Touching invariant %p", trec, q -> closure);

            for (q2 = trec -> invariants_to_check;
                 q2 != END_INVARIANT_CHECK_QUEUE;
                 q2 = q2 -> next_queue_entry) {
            for (q2 = trec -> invariants_to_check;
                 q2 != END_INVARIANT_CHECK_QUEUE;
                 q2 = q2 -> next_queue_entry) {

@@ -1243,8 +1246,8 @@ StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, StgTRecHeader *
            }
            
            if (!found) {
            }
            
            if (!found) {

-             TRACE("%p : Not already found %p", trec, q -> closure);

              StgInvariantCheckQueue *q3;
              StgInvariantCheckQueue *q3;

+             TRACE("%p : Not already found %p", trec, q -> closure);

              q3 = alloc_stg_invariant_check_queue(cap,
                                                   (StgAtomicInvariant*) q -> closure);
              q3 -> next_queue_entry = trec -> invariants_to_check;
              q3 = alloc_stg_invariant_check_queue(cap,
                                                   (StgAtomicInvariant*) q -> closure);
              q3 -> next_queue_entry = trec -> invariants_to_check;

@@ -1273,6 +1276,8 @@ StgInvariantCheckQueue *stmGetInvariantsToCheck(Capability *cap, StgTRecHeader *
 StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec) {
   int result;
   StgInt64 max_commits_at_start = max_commits;
 StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec) {
   int result;
   StgInt64 max_commits_at_start = max_commits;

+  StgBool touched_invariants;
+  StgBool use_read_phase;

 
   TRACE("%p : stmCommitTransaction()", trec);
   ASSERT (trec != NO_TREC);
 
   TRACE("%p : stmCommitTransaction()", trec);
   ASSERT (trec != NO_TREC);

@@ -1286,7 +1291,7 @@ StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec) {
   // touched_invariants is true if we've written to a TVar with invariants 
   // attached to it, or if we're trying to add a new invariant to the system.
 
   // touched_invariants is true if we've written to a TVar with invariants 
   // attached to it, or if we're trying to add a new invariant to the system.
 

-  StgBool touched_invariants = (trec -> invariants_to_check != END_INVARIANT_CHECK_QUEUE);
+  touched_invariants = (trec -> invariants_to_check != END_INVARIANT_CHECK_QUEUE);

 
   // If we have touched invariants then (i) lock the invariant, and (ii) add
   // the invariant's read set to our own.  Step (i) is needed to serialize
 
   // If we have touched invariants then (i) lock the invariant, and (ii) add
   // the invariant's read set to our own.  Step (i) is needed to serialize

@@ -1298,18 +1303,20 @@ StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec) {
   // invariant from both tvars).
 
   if (touched_invariants) {
   // invariant from both tvars).
 
   if (touched_invariants) {

-    TRACE("%p : locking invariants", trec);

     StgInvariantCheckQueue *q = trec -> invariants_to_check;
     StgInvariantCheckQueue *q = trec -> invariants_to_check;

+    TRACE("%p : locking invariants", trec);

     while (q != END_INVARIANT_CHECK_QUEUE) {
     while (q != END_INVARIANT_CHECK_QUEUE) {

+      StgTRecHeader *inv_old_trec;
+      StgAtomicInvariant *inv;

       TRACE("%p : locking invariant %p", trec, q -> invariant);
       TRACE("%p : locking invariant %p", trec, q -> invariant);

-      StgAtomicInvariant *inv = q -> invariant;
+      inv = q -> invariant;

       if (!lock_inv(inv)) {
         TRACE("%p : failed to lock %p", trec, inv);
         trec -> state = TREC_CONDEMNED;
         break;
       }
 
       if (!lock_inv(inv)) {
         TRACE("%p : failed to lock %p", trec, inv);
         trec -> state = TREC_CONDEMNED;
         break;
       }
 

-      StgTRecHeader *inv_old_trec = inv -> last_execution;
+      inv_old_trec = inv -> last_execution;

       if (inv_old_trec != NO_TREC) {
        StgTRecChunk *c = inv_old_trec -> current_chunk;
        while (c != END_STM_CHUNK_LIST) {
       if (inv_old_trec != NO_TREC) {
        StgTRecChunk *c = inv_old_trec -> current_chunk;
        while (c != END_STM_CHUNK_LIST) {

@@ -1336,7 +1343,7 @@ StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec) {
   // invariants and TVars are managed by the TVar watch queues which are
   // protected by the TVar's locks.
 
   // invariants and TVars are managed by the TVar watch queues which are
   // protected by the TVar's locks.
 

-  StgBool use_read_phase = ((config_use_read_phase) && (!touched_invariants));
+  use_read_phase = ((config_use_read_phase) && (!touched_invariants));

 
   result = validate_and_acquire_ownership(trec, (!use_read_phase), TRUE);
   if (result) {
 
   result = validate_and_acquire_ownership(trec, (!use_read_phase), TRUE);
   if (result) {

@@ -1344,12 +1351,13 @@ StgBool stmCommitTransaction(Capability *cap, StgTRecHeader *trec) {
     ASSERT (trec -> state == TREC_ACTIVE);
 
     if (use_read_phase) {
     ASSERT (trec -> state == TREC_ACTIVE);
 
     if (use_read_phase) {

+      StgInt64 max_commits_at_end;
+      StgInt64 max_concurrent_commits;

       TRACE("%p : doing read check", trec);
       result = check_read_only(trec);
       TRACE("%p : read-check %s", trec, result ? "succeeded" : "failed");
 
       TRACE("%p : doing read check", trec);
       result = check_read_only(trec);
       TRACE("%p : read-check %s", trec, result ? "succeeded" : "failed");
 

-      StgInt64 max_commits_at_end = max_commits;
-      StgInt64 max_concurrent_commits;
+      max_commits_at_end = max_commits;

       max_concurrent_commits = ((max_commits_at_end - max_commits_at_start) +
                                 (n_capabilities * TOKEN_BATCH_SIZE));
       if (((max_concurrent_commits >> 32) > 0) || shake()) {
       max_concurrent_commits = ((max_commits_at_end - max_commits_at_start) +
                                 (n_capabilities * TOKEN_BATCH_SIZE));
       if (((max_concurrent_commits >> 32) > 0) || shake()) {

diff --git a/rts/Schedule.c b/rts/Schedule.c
index b68e1ac..5ebb685 100644 (file)
--- a/rts/Schedule.c
+++ b/rts/Schedule.c
@@ -3109,10 +3109,10 @@ findRetryFrameHelper (StgTSO *tso)
        return CATCH_RETRY_FRAME;
       
     case CATCH_STM_FRAME: {
        return CATCH_RETRY_FRAME;
       
     case CATCH_STM_FRAME: {

-        debugTrace(DEBUG_stm,
-                  "found CATCH_STM_FRAME at %p during retry", p);

         StgTRecHeader *trec = tso -> trec;
        StgTRecHeader *outer = stmGetEnclosingTRec(trec);
         StgTRecHeader *trec = tso -> trec;
        StgTRecHeader *outer = stmGetEnclosingTRec(trec);

+        debugTrace(DEBUG_stm,
+                  "found CATCH_STM_FRAME at %p during retry", p);

         debugTrace(DEBUG_stm, "trec=%p outer=%p", trec, outer);
        stmAbortTransaction(tso -> cap, trec);
        stmFreeAbortedTRec(tso -> cap, trec);
         debugTrace(DEBUG_stm, "trec=%p outer=%p", trec, outer);
        stmAbortTransaction(tso -> cap, trec);
        stmFreeAbortedTRec(tso -> cap, trec);

diff --git a/rts/sm/GC.c b/rts/sm/GC.c
index 216d3cb..e4b5098 100644 (file)
--- a/rts/sm/GC.c
+++ b/rts/sm/GC.c
@@ -199,12 +199,12 @@ GarbageCollect ( rtsBool force_major_gc )
   lnat oldgen_saved_blocks = 0;
   nat g, s, i;
 
   lnat oldgen_saved_blocks = 0;
   nat g, s, i;
 

-  ACQUIRE_SM_LOCK;
-

 #ifdef PROFILING
   CostCentreStack *prev_CCS;
 #endif
 
 #ifdef PROFILING
   CostCentreStack *prev_CCS;
 #endif
 

+  ACQUIRE_SM_LOCK;
+

   debugTrace(DEBUG_gc, "starting GC");
 
 #if defined(RTS_USER_SIGNALS)
   debugTrace(DEBUG_gc, "starting GC");
 
 #if defined(RTS_USER_SIGNALS)