[skip ci] rts: Detabify RaiseAsync.c

Signed-off-by: Austin Seipp <austin@well-typed.com>

1 files changed, 227 insertions, 229 deletions

diff --git a/rts/RaiseAsync.c b/rts/RaiseAsync.c
index a5440e40ad..10585c89fa 100644
--- a/rts/RaiseAsync.c
+++ b/rts/RaiseAsync.c
@@ -34,7 +34,7 @@ static void removeFromQueues(Capability *cap, StgTSO *tso);
 static void removeFromMVarBlockedQueue (StgTSO *tso);
 
 static void throwToSendMsg (Capability *cap USED_IF_THREADS,
-                            Capability *target_cap USED_IF_THREADS, 
+                            Capability *target_cap USED_IF_THREADS,
                             MessageThrowTo *msg USED_IF_THREADS);
 
 /* -----------------------------------------------------------------------------
@@ -42,7 +42,7 @@ static void throwToSendMsg (Capability *cap USED_IF_THREADS,
 
    This version of throwTo is safe to use if and only if one of the
    following holds:
-   
+
      - !THREADED_RTS
 
      - all the other threads in the system are stopped (eg. during GC).
@@ -55,7 +55,7 @@ static void throwToSendMsg (Capability *cap USED_IF_THREADS,
    -------------------------------------------------------------------------- */
 
 static void
-throwToSingleThreaded__ (Capability *cap, StgTSO *tso, StgClosure *exception, 
+throwToSingleThreaded__ (Capability *cap, StgTSO *tso, StgClosure *exception,
                          rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
 {
     // Thread already dead?
@@ -128,13 +128,13 @@ suspendComputation (Capability *cap, StgTSO *tso, StgUpdateFrame *stop_here)
    its parent container (e.g. the MVar) and then raise the exception.
    We might change these cases to be more message-passing-like in the
    future.
-  
-   Returns: 
+
+   Returns:
 
    NULL               exception was raised, ok to continue
 
    MessageThrowTo *   exception was not raised; the source TSO
-                      should now put itself in the state 
+                      should now put itself in the state
                       BlockedOnMsgThrowTo, and when it is ready
                       it should unlock the mssage using
                       unlockClosure(msg, &stg_MSG_THROWTO_info);
@@ -145,10 +145,10 @@ suspendComputation (Capability *cap, StgTSO *tso, StgUpdateFrame *stop_here)
    -------------------------------------------------------------------------- */
 
 MessageThrowTo *
-throwTo (Capability *cap,	// the Capability we hold 
-	 StgTSO *source,	// the TSO sending the exception (or NULL)
-	 StgTSO *target,        // the TSO receiving the exception
-	 StgClosure *exception) // the exception closure
+throwTo (Capability *cap,       // the Capability we hold
+         StgTSO *source,        // the TSO sending the exception (or NULL)
+         StgTSO *target,        // the TSO receiving the exception
+         StgClosure *exception) // the exception closure
 {
     MessageThrowTo *msg;
 
@@ -175,7 +175,7 @@ throwTo (Capability *cap,	// the Capability we hold
         return msg;
     }
 }
-    
+
 
 nat
 throwToMsg (Capability *cap, MessageThrowTo *msg)
@@ -194,14 +194,14 @@ check_target:
     ASSERT(target != END_TSO_QUEUE);
 
     // Thread already dead?
-    if (target->what_next == ThreadComplete 
-	|| target->what_next == ThreadKilled) {
-	return THROWTO_SUCCESS;
+    if (target->what_next == ThreadComplete
+        || target->what_next == ThreadKilled) {
+        return THROWTO_SUCCESS;
     }
 
     debugTraceCap(DEBUG_sched, cap,
                   "throwTo: from thread %lu to thread %lu",
-                  (unsigned long)msg->source->id, 
+                  (unsigned long)msg->source->id,
                   (unsigned long)msg->target->id);
 
 #ifdef DEBUG
@@ -215,7 +215,7 @@ check_target:
     }
 
     status = target->why_blocked;
-    
+
     switch (status) {
     case NotBlocked:
     {
@@ -276,8 +276,8 @@ check_target:
             goto retry;
         }
 
-	if ((target->flags & TSO_BLOCKEX) &&
-	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+        if ((target->flags & TSO_BLOCKEX) &&
+            ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
             unlockClosure((StgClosure*)m, i);
             blockedThrowTo(cap,target,msg);
             return THROWTO_BLOCKED;
@@ -293,17 +293,17 @@ check_target:
     case BlockedOnMVar:
     case BlockedOnMVarRead:
     {
-	/*
-	  To establish ownership of this TSO, we need to acquire a
-	  lock on the MVar that it is blocked on.
-	*/
-	StgMVar *mvar;
-	StgInfoTable *info USED_IF_THREADS;
-	
-	mvar = (StgMVar *)target->block_info.closure;
-
-	// ASSUMPTION: tso->block_info must always point to a
-	// closure.  In the threaded RTS it does.
+        /*
+          To establish ownership of this TSO, we need to acquire a
+          lock on the MVar that it is blocked on.
+        */
+        StgMVar *mvar;
+        StgInfoTable *info USED_IF_THREADS;
+
+        mvar = (StgMVar *)target->block_info.closure;
+
+        // ASSUMPTION: tso->block_info must always point to a
+        // closure.  In the threaded RTS it does.
         switch (get_itbl((StgClosure *)mvar)->type) {
         case MVAR_CLEAN:
         case MVAR_DIRTY:
@@ -312,47 +312,47 @@ check_target:
             goto retry;
         }
 
-	info = lockClosure((StgClosure *)mvar);
+        info = lockClosure((StgClosure *)mvar);
 
         // we have the MVar, let's check whether the thread
-	// is still blocked on the same MVar.
-	if ((target->why_blocked != BlockedOnMVar && target->why_blocked != BlockedOnMVarRead)
-	    || (StgMVar *)target->block_info.closure != mvar) {
-	    unlockClosure((StgClosure *)mvar, info);
-	    goto retry;
-	}
+        // is still blocked on the same MVar.
+        if ((target->why_blocked != BlockedOnMVar && target->why_blocked != BlockedOnMVarRead)
+            || (StgMVar *)target->block_info.closure != mvar) {
+            unlockClosure((StgClosure *)mvar, info);
+            goto retry;
+        }
 
         if (target->_link == END_TSO_QUEUE) {
             // the MVar operation has already completed.  There is a
             // MSG_TRY_WAKEUP on the way, but we can just wake up the
             // thread now anyway and ignore the message when it
             // arrives.
-	    unlockClosure((StgClosure *)mvar, info);
+            unlockClosure((StgClosure *)mvar, info);
             tryWakeupThread(cap, target);
             goto retry;
         }
 
-	if ((target->flags & TSO_BLOCKEX) &&
-	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+        if ((target->flags & TSO_BLOCKEX) &&
+            ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
             blockedThrowTo(cap,target,msg);
-	    unlockClosure((StgClosure *)mvar, info);
-	    return THROWTO_BLOCKED;
-	} else {
+            unlockClosure((StgClosure *)mvar, info);
+            return THROWTO_BLOCKED;
+        } else {
             // revoke the MVar operation
             removeFromMVarBlockedQueue(target);
-	    raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
-	    unlockClosure((StgClosure *)mvar, info);
-	    return THROWTO_SUCCESS;
-	}
+            raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
+            unlockClosure((StgClosure *)mvar, info);
+            return THROWTO_SUCCESS;
+        }
     }
 
     case BlockedOnBlackHole:
     {
-	if (target->flags & TSO_BLOCKEX) {
+        if (target->flags & TSO_BLOCKEX) {
             // BlockedOnBlackHole is not interruptible.
             blockedThrowTo(cap,target,msg);
-	    return THROWTO_BLOCKED;
-	} else {
+            return THROWTO_BLOCKED;
+        } else {
             // Revoke the message by replacing it with IND. We're not
             // locking anything here, so we might still get a TRY_WAKEUP
             // message from the owner of the blackhole some time in the
@@ -365,23 +365,23 @@ check_target:
     }
 
     case BlockedOnSTM:
-	lockTSO(target);
-	// Unblocking BlockedOnSTM threads requires the TSO to be
-	// locked; see STM.c:unpark_tso().
-	if (target->why_blocked != BlockedOnSTM) {
-	    unlockTSO(target);
-	    goto retry;
-	}
-	if ((target->flags & TSO_BLOCKEX) &&
-	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+        lockTSO(target);
+        // Unblocking BlockedOnSTM threads requires the TSO to be
+        // locked; see STM.c:unpark_tso().
+        if (target->why_blocked != BlockedOnSTM) {
+            unlockTSO(target);
+            goto retry;
+        }
+        if ((target->flags & TSO_BLOCKEX) &&
+            ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
             blockedThrowTo(cap,target,msg);
-	    unlockTSO(target);
-	    return THROWTO_BLOCKED;
-	} else {
-	    raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
-	    unlockTSO(target);
-	    return THROWTO_SUCCESS;
-	}
+            unlockTSO(target);
+            return THROWTO_BLOCKED;
+        } else {
+            raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
+            unlockTSO(target);
+            return THROWTO_SUCCESS;
+        }
 
     case BlockedOnCCall_Interruptible:
 #ifdef THREADED_RTS
@@ -409,8 +409,8 @@ check_target:
     }
 #endif
     case BlockedOnCCall:
-	blockedThrowTo(cap,target,msg);
-	return THROWTO_BLOCKED;
+        blockedThrowTo(cap,target,msg);
+        return THROWTO_BLOCKED;
 
 #ifndef THREADEDED_RTS
     case BlockedOnRead:
@@ -419,15 +419,15 @@ check_target:
 #if defined(mingw32_HOST_OS)
     case BlockedOnDoProc:
 #endif
-	if ((target->flags & TSO_BLOCKEX) &&
-	    ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
-	    blockedThrowTo(cap,target,msg);
-	    return THROWTO_BLOCKED;
-	} else {
-	    removeFromQueues(cap,target);
-	    raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
-	    return THROWTO_SUCCESS;
-	}
+        if ((target->flags & TSO_BLOCKEX) &&
+            ((target->flags & TSO_INTERRUPTIBLE) == 0)) {
+            blockedThrowTo(cap,target,msg);
+            return THROWTO_BLOCKED;
+        } else {
+            removeFromQueues(cap,target);
+            raiseAsync(cap, target, msg->exception, rtsFalse, NULL);
+            return THROWTO_SUCCESS;
+        }
 #endif
 
     case ThreadMigrating:
@@ -450,9 +450,9 @@ check_target:
 
 static void
 throwToSendMsg (Capability *cap STG_UNUSED,
-                Capability *target_cap USED_IF_THREADS, 
+                Capability *target_cap USED_IF_THREADS,
                 MessageThrowTo *msg USED_IF_THREADS)
-            
+
 {
 #ifdef THREADED_RTS
     debugTraceCap(DEBUG_sched, cap, "throwTo: sending a throwto message to cap %lu", (unsigned long)target_cap->no);
@@ -510,17 +510,17 @@ maybePerformBlockedException (Capability *cap, StgTSO *tso)
         }
     }
 
-    if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE && 
+    if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE &&
         (tso->flags & TSO_BLOCKEX) != 0) {
         debugTraceCap(DEBUG_sched, cap, "throwTo: thread %lu has blocked exceptions but is inside block", (unsigned long)tso->id);
     }
 
     if (tso->blocked_exceptions != END_BLOCKED_EXCEPTIONS_QUEUE
-	&& ((tso->flags & TSO_BLOCKEX) == 0
-	    || ((tso->flags & TSO_INTERRUPTIBLE) && interruptible(tso)))) {
+        && ((tso->flags & TSO_BLOCKEX) == 0
+            || ((tso->flags & TSO_INTERRUPTIBLE) && interruptible(tso)))) {
 
-	// We unblock just the first thread on the queue, and perform
-	// its throw immediately.
+        // We unblock just the first thread on the queue, and perform
+        // its throw immediately.
     loop:
         msg = tso->blocked_exceptions;
         if (msg == END_BLOCKED_EXCEPTIONS_QUEUE) return 0;
@@ -562,7 +562,7 @@ awakenBlockedExceptionQueue (Capability *cap, StgTSO *tso)
         }
     }
     tso->blocked_exceptions = END_BLOCKED_EXCEPTIONS_QUEUE;
-}    
+}
 
 /* -----------------------------------------------------------------------------
    Remove a thread from blocking queues.
@@ -673,7 +673,7 @@ removeFromQueues(Capability *cap, StgTSO *tso)
 
   case BlockedOnDelay:
         removeThreadFromQueue(cap, &sleeping_queue, tso);
-	goto done;
+        goto done;
 #endif
 
   default:
@@ -696,11 +696,11 @@ removeFromQueues(Capability *cap, StgTSO *tso)
  * TSO blocked_exception queues.
  *
  * We strip the stack down to the innermost CATCH_FRAME, building
- * thunks in the heap for all the active computations, so they can 
+ * thunks in the heap for all the active computations, so they can
  * be restarted if necessary.  When we reach a CATCH_FRAME, we build
  * an application of the handler to the exception, and push it on
  * the top of the stack.
- * 
+ *
  * How exactly do we save all the active computations?  We create an
  * AP_STACK for every UpdateFrame on the stack.  Entering one of these
  * AP_STACKs pushes everything from the corresponding update frame
@@ -711,7 +711,7 @@ removeFromQueues(Capability *cap, StgTSO *tso)
  * exactly as it did when we killed the TSO and we can continue
  * execution by entering the closure on top of the stack.
  *
- * We can also kill a thread entirely - this happens if either (a) the 
+ * We can also kill a thread entirely - this happens if either (a) the
  * exception passed to raiseAsync is NULL, or (b) there's no
  * CATCH_FRAME on the stack.  In either case, we strip the entire
  * stack and replace the thread with a zombie.
@@ -724,8 +724,8 @@ removeFromQueues(Capability *cap, StgTSO *tso)
  * -------------------------------------------------------------------------- */
 
 static StgTSO *
-raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception, 
-	   rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
+raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
+           rtsBool stop_at_atomically, StgUpdateFrame *stop_here)
 {
     StgRetInfoTable *info;
     StgPtr sp, frame;
@@ -735,12 +735,12 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
 
     debugTraceCap(DEBUG_sched, cap,
                   "raising exception in thread %ld.", (long)tso->id);
-    
+
 #if defined(PROFILING)
-    /* 
+    /*
      * Debugging tool: on raising an  exception, show where we are.
      * See also Exception.cmm:stg_raisezh.
-     * This wasn't done for asynchronous exceptions originally; see #1450 
+     * This wasn't done for asynchronous exceptions originally; see #1450
      */
     if (RtsFlags.ProfFlags.showCCSOnException && exception != NULL)
     {
@@ -749,10 +749,10 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
 #endif
     // ASSUMES: the thread is not already complete or dead
     // Upper layers should deal with that.
-    ASSERT(tso->what_next != ThreadComplete && 
+    ASSERT(tso->what_next != ThreadComplete &&
            tso->what_next != ThreadKilled);
 
-    // only if we own this TSO (except that deleteThread() calls this 
+    // only if we own this TSO (except that deleteThread() calls this
     ASSERT(tso->cap == cap);
 
     stack = tso->stackobj;
@@ -762,7 +762,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
     dirty_STACK(cap, stack);
 
     sp = stack->sp;
-    
+
     if (stop_here != NULL) {
         updatee = stop_here->updatee;
     } else {
@@ -773,69 +773,69 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
     // the top of the stack, so we have to arrange that this is the case...
     //
     if (sp[0] == (W_)&stg_enter_info) {
-	sp++;
+        sp++;
     } else {
-	sp--;
-	sp[0] = (W_)&stg_dummy_ret_closure;
+        sp--;
+        sp[0] = (W_)&stg_dummy_ret_closure;
     }
 
     frame = sp + 1;
     while (stop_here == NULL || frame < (StgPtr)stop_here) {
 
-	// 1. Let the top of the stack be the "current closure"
-	//
-	// 2. Walk up the stack until we find either an UPDATE_FRAME or a
-	// CATCH_FRAME.
-	//
-	// 3. If it's an UPDATE_FRAME, then make an AP_STACK containing the
-	// current closure applied to the chunk of stack up to (but not
-	// including) the update frame.  This closure becomes the "current
-	// closure".  Go back to step 2.
-	//
-	// 4. If it's a CATCH_FRAME, then leave the exception handler on
-	// top of the stack applied to the exception.
-	// 
-	// 5. If it's a STOP_FRAME, then kill the thread.
-        // 
+        // 1. Let the top of the stack be the "current closure"
+        //
+        // 2. Walk up the stack until we find either an UPDATE_FRAME or a
+        // CATCH_FRAME.
+        //
+        // 3. If it's an UPDATE_FRAME, then make an AP_STACK containing the
+        // current closure applied to the chunk of stack up to (but not
+        // including) the update frame.  This closure becomes the "current
+        // closure".  Go back to step 2.
+        //
+        // 4. If it's a CATCH_FRAME, then leave the exception handler on
+        // top of the stack applied to the exception.
+        //
+        // 5. If it's a STOP_FRAME, then kill the thread.
+        //
         // 6. If it's an UNDERFLOW_FRAME, then continue with the next
         //    stack chunk.
         //
         // NB: if we pass an ATOMICALLY_FRAME then abort the associated
         // transaction
-       
+
         info = get_ret_itbl((StgClosure *)frame);
 
-	switch (info->i.type) {
-
-	case UPDATE_FRAME:
-	{
-	    StgAP_STACK * ap;
-	    nat words;
-	    
-	    // First build an AP_STACK consisting of the stack chunk above the
-	    // current update frame, with the top word on the stack as the
-	    // fun field.
-	    //
-	    words = frame - sp - 1;
-	    ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
-	    
-	    ap->size = words;
-	    ap->fun  = (StgClosure *)sp[0];
-	    sp++;
-	    for(i=0; i < (nat)words; ++i) {
-		ap->payload[i] = (StgClosure *)*sp++;
-	    }
-	    
-	    SET_HDR(ap,&stg_AP_STACK_info,
-		    ((StgClosure *)frame)->header.prof.ccs /* ToDo */); 
-	    TICK_ALLOC_UP_THK(WDS(words+1),0);
-	    
-	    //IF_DEBUG(scheduler,
-	    //	     debugBelch("sched: Updating ");
-	    //	     printPtr((P_)((StgUpdateFrame *)frame)->updatee); 
-	    //	     debugBelch(" with ");
-	    //	     printObj((StgClosure *)ap);
-	    //	);
+        switch (info->i.type) {
+
+        case UPDATE_FRAME:
+        {
+            StgAP_STACK * ap;
+            nat words;
+
+            // First build an AP_STACK consisting of the stack chunk above the
+            // current update frame, with the top word on the stack as the
+            // fun field.
+            //
+            words = frame - sp - 1;
+            ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
+
+            ap->size = words;
+            ap->fun  = (StgClosure *)sp[0];
+            sp++;
+            for(i=0; i < (nat)words; ++i) {
+                ap->payload[i] = (StgClosure *)*sp++;
+            }
+
+            SET_HDR(ap,&stg_AP_STACK_info,
+                    ((StgClosure *)frame)->header.prof.ccs /* ToDo */);
+            TICK_ALLOC_UP_THK(WDS(words+1),0);
+
+            //IF_DEBUG(scheduler,
+            //       debugBelch("sched: Updating ");
+            //       printPtr((P_)((StgUpdateFrame *)frame)->updatee);
+            //       debugBelch(" with ");
+            //       printObj((StgClosure *)ap);
+            //  );
 
             if (((StgUpdateFrame *)frame)->updatee == updatee) {
                 // If this update frame points to the same closure as
@@ -848,37 +848,37 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
                 // Perform the update
                 // TODO: this may waste some work, if the thunk has
                 // already been updated by another thread.
-                updateThunk(cap, tso, 
+                updateThunk(cap, tso,
                             ((StgUpdateFrame *)frame)->updatee, (StgClosure *)ap);
             }
 
-	    sp += sizeofW(StgUpdateFrame) - 1;
-	    sp[0] = (W_)ap; // push onto stack
-	    frame = sp + 1;
-	    continue; //no need to bump frame
-	}
+            sp += sizeofW(StgUpdateFrame) - 1;
+            sp[0] = (W_)ap; // push onto stack
+            frame = sp + 1;
+            continue; //no need to bump frame
+        }
 
         case UNDERFLOW_FRAME:
         {
-	    StgAP_STACK * ap;
-	    nat words;
-	    
-	    // First build an AP_STACK consisting of the stack chunk above the
-	    // current update frame, with the top word on the stack as the
-	    // fun field.
-	    //
-	    words = frame - sp - 1;
-	    ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
-	    
-	    ap->size = words;
-	    ap->fun  = (StgClosure *)sp[0];
-	    sp++;
-	    for(i=0; i < (nat)words; ++i) {
-		ap->payload[i] = (StgClosure *)*sp++;
-	    }
-	    
+            StgAP_STACK * ap;
+            nat words;
+
+            // First build an AP_STACK consisting of the stack chunk above the
+            // current update frame, with the top word on the stack as the
+            // fun field.
+            //
+            words = frame - sp - 1;
+            ap = (StgAP_STACK *)allocate(cap,AP_STACK_sizeW(words));
+
+            ap->size = words;
+            ap->fun  = (StgClosure *)sp[0];
+            sp++;
+            for(i=0; i < (nat)words; ++i) {
+                ap->payload[i] = (StgClosure *)*sp++;
+            }
+
             SET_HDR(ap,&stg_AP_STACK_NOUPD_info,
-		    ((StgClosure *)frame)->header.prof.ccs /* ToDo */); 
+                    ((StgClosure *)frame)->header.prof.ccs /* ToDo */);
             TICK_ALLOC_SE_THK(WDS(words+1),0);
 
             stack->sp = sp;
@@ -893,40 +893,40 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
         }
 
         case STOP_FRAME:
-	{
-	    // We've stripped the entire stack, the thread is now dead.
-	    tso->what_next = ThreadKilled;
+        {
+            // We've stripped the entire stack, the thread is now dead.
+            tso->what_next = ThreadKilled;
             stack->sp = frame + sizeofW(StgStopFrame);
             goto done;
-	}
-
-	case CATCH_FRAME:
-	    // If we find a CATCH_FRAME, and we've got an exception to raise,
-	    // then build the THUNK raise(exception), and leave it on
-	    // top of the CATCH_FRAME ready to enter.
-	    //
-	{
-	    StgCatchFrame *cf = (StgCatchFrame *)frame;
-	    StgThunk *raise;
-	    
-	    if (exception == NULL) break;
-
-	    // we've got an exception to raise, so let's pass it to the
-	    // handler in this frame.
-	    //
-	    raise = (StgThunk *)allocate(cap,sizeofW(StgThunk)+1);
-	    TICK_ALLOC_SE_THK(WDS(1),0);
-	    SET_HDR(raise,&stg_raise_info,cf->header.prof.ccs);
-	    raise->payload[0] = exception;
-	    
-	    // throw away the stack from Sp up to the CATCH_FRAME.
-	    //
-	    sp = frame - 1;
-	    
-	    /* Ensure that async exceptions are blocked now, so we don't get
-	     * a surprise exception before we get around to executing the
-	     * handler.
-	     */
+        }
+
+        case CATCH_FRAME:
+            // If we find a CATCH_FRAME, and we've got an exception to raise,
+            // then build the THUNK raise(exception), and leave it on
+            // top of the CATCH_FRAME ready to enter.
+            //
+        {
+            StgCatchFrame *cf = (StgCatchFrame *)frame;
+            StgThunk *raise;
+
+            if (exception == NULL) break;
+
+            // we've got an exception to raise, so let's pass it to the
+            // handler in this frame.
+            //
+            raise = (StgThunk *)allocate(cap,sizeofW(StgThunk)+1);
+            TICK_ALLOC_SE_THK(WDS(1),0);
+            SET_HDR(raise,&stg_raise_info,cf->header.prof.ccs);
+            raise->payload[0] = exception;
+
+            // throw away the stack from Sp up to the CATCH_FRAME.
+            //
+            sp = frame - 1;
+
+            /* Ensure that async exceptions are blocked now, so we don't get
+             * a surprise exception before we get around to executing the
+             * handler.
+             */
             tso->flags |= TSO_BLOCKEX;
             if ((cf->exceptions_blocked & TSO_INTERRUPTIBLE) == 0) {
                 tso->flags &= ~TSO_INTERRUPTIBLE;
@@ -934,20 +934,20 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
                 tso->flags |= TSO_INTERRUPTIBLE;
             }
 
-	    /* Put the newly-built THUNK on top of the stack, ready to execute
-	     * when the thread restarts.
-	     */
-	    sp[0] = (W_)raise;
-	    sp[-1] = (W_)&stg_enter_info;
+            /* Put the newly-built THUNK on top of the stack, ready to execute
+             * when the thread restarts.
+             */
+            sp[0] = (W_)raise;
+            sp[-1] = (W_)&stg_enter_info;
             stack->sp = sp-1;
-	    tso->what_next = ThreadRunGHC;
+            tso->what_next = ThreadRunGHC;
             goto done;
-	}
-	    
-	case ATOMICALLY_FRAME:
-	    if (stop_at_atomically) {
-		ASSERT(tso->trec->enclosing_trec == NO_TREC);
-		stmCondemnTransaction(cap, tso -> trec);
+        }
+
+        case ATOMICALLY_FRAME:
+            if (stop_at_atomically) {
+                ASSERT(tso->trec->enclosing_trec == NO_TREC);
+                stmCondemnTransaction(cap, tso -> trec);
                 stack->sp = frame - 2;
                 // The ATOMICALLY_FRAME expects to be returned a
                 // result from the transaction, which it stores in the
@@ -961,7 +961,7 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
                 stack->sp[0] = (W_)&stg_ret_p_info;
                 tso->what_next = ThreadRunGHC;
                 goto done;
-	    }
+            }
             else
             {
                 // Freezing an STM transaction.  Just aborting the
@@ -1009,33 +1009,33 @@ raiseAsync(Capability *cap, StgTSO *tso, StgClosure *exception,
             }
 
         case CATCH_STM_FRAME:
-	case CATCH_RETRY_FRAME:
+        case CATCH_RETRY_FRAME:
             // CATCH frames within an atomically block: abort the
             // inner transaction and continue.  Eventually we will
             // hit the outer transaction that will get frozen (see
             // above).
             //
             // In this case (unlike ordinary exceptions) we do not care
-	    // 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.
         {
             StgTRecHeader *trec = tso -> trec;
             StgTRecHeader *outer = trec -> enclosing_trec;
-	    debugTraceCap(DEBUG_stm, cap,
+            debugTraceCap(DEBUG_stm, cap,
                           "found atomically block delivering async exception");
             stmAbortTransaction(cap, trec);
-	    stmFreeAbortedTRec(cap, trec);
+            stmFreeAbortedTRec(cap, trec);
             tso -> trec = outer;
             break;
         };
 
-	default:
-	    break;
-	}
+        default:
+            break;
+        }
 
-	// move on to the next stack frame
-	frame += stack_frame_sizeW((StgClosure *)frame);
+        // move on to the next stack frame
+        frame += stack_frame_sizeW((StgClosure *)frame);
     }
 
 done:
@@ -1045,9 +1045,7 @@ done:
     if (tso->why_blocked != NotBlocked) {
         tso->why_blocked = NotBlocked;
         appendToRunQueue(cap,tso);
-    }        
+    }
 
     return tso;
 }
-
-