let lo = getRegisterReg platform (CmmLocal dst_lo)

                   hi = getRegisterReg platform (CmmLocal dst_hi)

                   nd = getRegisterReg platform (CmmLocal dst_needed)

               return $

                   code_x `appOL`

                   code_y `snocOL`

                   SMULH (OpReg W64 hi) (OpReg W64 reg_a) (OpReg W64 reg_b) `snocOL`

                   -- Are all high bits equal to the sign bit of the low word?

                   -- nd = (hi == ASR(lo,width-1)) ? 1 : 0

                   CMP   (OpReg W64 hi) (OpRegShift W64 lo SASR (widthInBits w - 1)) `snocOL`

 moreCapabilities (uint32_t from USED_IF_THREADS, uint32_t to USED_IF_THREADS)

 {

 #if defined(THREADED_RTS)

     if (to == 1) {

         // THREADED_RTS must work on builds that don't have a mutable

         // BaseReg (eg. unregisterised), so in this case

     }

     debugTrace(DEBUG_sched, "allocated %d more capabilities", to - from);

 #endif

 }

 #include "win32/AsyncWinIO.h"

 #endif

 #include "Trace.h"

 #include "RaiseAsync.h"

 #include "Threads.h"

 #include "Timer.h"

     ACQUIRE_LOCK(&all_tasks_mutex);

 #endif

 #if defined(TRACING)

 #endif

     pid = fork();

     if (pid) { // parent

         RELEASE_LOCK(&sched_mutex);

         RELEASE_LOCK(&sm_mutex);

         RELEASE_LOCK(&stable_ptr_mutex);

         RELEASE_LOCK(&stable_name_mutex);

         RELEASE_LOCK(&task->lock);

 #if defined(THREADED_RTS)

         /* N.B. releaseCapability_ below may need to take all_tasks_mutex */

         RELEASE_LOCK(&all_tasks_mutex);

     cap = rts_lock();

     task = cap->running_task;

     stopAllCapabilities(&cap, task);

     if (new_n_capabilities < enabled_capabilities)

             tracingAddCapabilities(n_capabilities, new_n_capabilities);

 #endif

             moreCapabilities(n_capabilities, new_n_capabilities);

             // Resize and update storage manager data structures

     // Notify IO manager that the number of capabilities has changed.

     notifyIOManagerCapabilitiesChanged(&cap);

     rts_unlock(cap);

 #endif // THREADED_RTS

 #include "RtsSignals.h"

 #include "rts/EventLogWriter.h"

 // This global counter is used to allow multiple threads to stop the

 // timer temporarily with a stopTimer()/startTimer() pair.  If

 //      timer_enabled  == 0          timer is enabled

 static EventsBuf *capEventBuf; // one EventsBuf for each Capability

 static EventsBuf eventBuf; // an EventsBuf not associated with any Capability

 #endif

 // Event type

     moreCapEventBufs(0, get_n_capabilities());

     initEventsBuf(&eventBuf, EVENT_LOG_SIZE, (EventCapNo)(-1));

     initMutex(&eventBufMutex);

     initMutex(&state_change_mutex);

 #endif

 }

 {

     initEventLogWriter();

     postHeaderEvents();

     /*

      */

     printAndClearEventBuf(&eventBuf);

     return true;

 }

     flushEventLog_(NULL);

     // Mark end of events (data).

     postEventTypeNum(&eventBuf, EVENT_DATA_END);

     // Flush the end of data marker.

     printAndClearEventBuf(&eventBuf);

     stopEventLogWriter();

     event_log_writer = NULL;

 postCapEvent (EventTypeNum  tag,

               EventCapNo    capno)

 {

     ensureRoomForEvent(&eventBuf, tag);

     postEventHeader(&eventBuf, tag);

         barf("postCapEvent: unknown event tag %d", tag);

     }

 }

 void postCapsetEvent (EventTypeNum tag,

                       EventCapsetID capset,

                       StgWord info)

 {

     ensureRoomForEvent(&eventBuf, tag);

     postEventHeader(&eventBuf, tag);

         barf("postCapsetEvent: unknown event tag %d", tag);

     }

 }

 void postCapsetStrEvent (EventTypeNum tag,

         return;

     }

     if (!hasRoomForVariableEvent(&eventBuf, size)){

         printAndClearEventBuf(&eventBuf);

         if (!hasRoomForVariableEvent(&eventBuf, size)){

             errorBelch("Event size exceeds buffer size, bail out");

             return;

         }

     }

     postBuf(&eventBuf, (StgWord8*) msg, strsize);

 }

 void postCapsetVecEvent (EventTypeNum tag,

         }

     }

     if (!hasRoomForVariableEvent(&eventBuf, size)){

         printAndClearEventBuf(&eventBuf);

         if(!hasRoomForVariableEvent(&eventBuf, size)){

             errorBelch("Event size exceeds buffer size, bail out");

             return;

         }

     }

         postBuf(&eventBuf, (StgWord8*) argv[i], 1 + strlen(argv[i]));

     }

 }

 void postWallClockTime (EventCapsetID capset)

     StgWord64 sec;

     StgWord32 nsec;

     /* The EVENT_WALL_CLOCK_TIME event is intended to allow programs

        reading the eventlog to match up the event timestamps with wall

     postWord64(&eventBuf, sec);

     postWord32(&eventBuf, nsec);

 }

 /*

                         W_          mblockSize,

                         W_          blockSize)

 {

     ensureRoomForEvent(&eventBuf, EVENT_HEAP_INFO_GHC);

     postEventHeader(&eventBuf, EVENT_HEAP_INFO_GHC);

     postWord64(&eventBuf, mblockSize);

     postWord64(&eventBuf, blockSize);

 }

 void postEventGcStats  (Capability    *cap,

                           EventCapNo capno,

                           EventKernelThreadId tid)

 {

     ensureRoomForEvent(&eventBuf, EVENT_TASK_CREATE);

     postEventHeader(&eventBuf, EVENT_TASK_CREATE);

     postCapNo(&eventBuf, capno);

     postKernelThreadId(&eventBuf, tid);

 }

 void postTaskMigrateEvent (EventTaskId taskId,

                            EventCapNo capno,

                            EventCapNo new_capno)

 {

     ensureRoomForEvent(&eventBuf, EVENT_TASK_MIGRATE);

     postEventHeader(&eventBuf, EVENT_TASK_MIGRATE);

     postCapNo(&eventBuf, capno);

     postCapNo(&eventBuf, new_capno);

 }

 void postTaskDeleteEvent (EventTaskId taskId)

 {

     ensureRoomForEvent(&eventBuf, EVENT_TASK_DELETE);

     postEventHeader(&eventBuf, EVENT_TASK_DELETE);

     /* EVENT_TASK_DELETE (taskID) */

     postTaskId(&eventBuf, taskId);

 }

 void

 postEventNoCap (EventTypeNum tag)

 {

     ensureRoomForEvent(&eventBuf, tag);

     postEventHeader(&eventBuf, tag);

 }

 void

 void postMsg(char *msg, va_list ap)

 {

     postLogMsg(&eventBuf, EVENT_LOG_MSG, msg, ap);

 }

 void postCapMsg(Capability *cap, char *msg, va_list ap)

 void postConcMarkEnd(StgWord32 marked_obj_count)

 {

     ensureRoomForEvent(&eventBuf, EVENT_CONC_MARK_END);

     postEventHeader(&eventBuf, EVENT_CONC_MARK_END);

     postWord32(&eventBuf, marked_obj_count);

 }

 void postNonmovingHeapCensus(uint16_t blk_size,

                              const struct NonmovingAllocCensus *census)

 {

     postEventHeader(&eventBuf, EVENT_NONMOVING_HEAP_CENSUS);

     postWord16(&eventBuf, blk_size);

     postWord32(&eventBuf, census->n_active_segs);

     postWord32(&eventBuf, census->n_filled_segs);

     postWord32(&eventBuf, census->n_live_blocks);

 }

 void postNonmovingPrunedSegments(uint32_t pruned_segments, uint32_t free_segments)

 {

     postEventHeader(&eventBuf, EVENT_NONMOVING_PRUNED_SEGMENTS);

     postWord32(&eventBuf, pruned_segments);

     postWord32(&eventBuf, free_segments);

 }

 void closeBlockMarker (EventsBuf *ebuf)

 void postHeapProfBegin(void)

 {

     PROFILING_FLAGS *flags = &RtsFlags.ProfFlags;

     StgWord modSelector_len   =

         flags->modSelector ? strlen(flags->modSelector) : 0;

     postStringLen(&eventBuf, flags->ccsSelector, ccsSelector_len);

     postStringLen(&eventBuf, flags->retainerSelector, retainerSelector_len);

     postStringLen(&eventBuf, flags->bioSelector, bioSelector_len);

 }

 void postHeapProfSampleBegin(StgInt era)

 {

     ensureRoomForEvent(&eventBuf, EVENT_HEAP_PROF_SAMPLE_BEGIN);

     postEventHeader(&eventBuf, EVENT_HEAP_PROF_SAMPLE_BEGIN);

     postWord64(&eventBuf, era);

 }

 void postHeapBioProfSampleBegin(StgInt era, StgWord64 time)

 {

     ensureRoomForEvent(&eventBuf, EVENT_HEAP_BIO_PROF_SAMPLE_BEGIN);

     postEventHeader(&eventBuf, EVENT_HEAP_BIO_PROF_SAMPLE_BEGIN);

     postWord64(&eventBuf, era);

     postWord64(&eventBuf, time);

 }

 void postHeapProfSampleEnd(StgInt era)

 {

     ensureRoomForEvent(&eventBuf, EVENT_HEAP_PROF_SAMPLE_END);

     postEventHeader(&eventBuf, EVENT_HEAP_PROF_SAMPLE_END);

     postWord64(&eventBuf, era);

 }

 void postHeapProfSampleString(const char *label,

                               StgWord64 residency)

 {

     StgWord label_len = strlen(label);

     StgWord len = 1+8+label_len+1;

     CHECK(!ensureRoomForVariableEvent(&eventBuf, len));

     postWord8(&eventBuf, 0);

     postWord64(&eventBuf, residency);

     postStringLen(&eventBuf, label, label_len);

 }

 #if defined(PROFILING)

                             const char *srcloc,

                             StgBool is_caf)

 {

     StgWord label_len = strlen(label);

     StgWord module_len = strlen(module);

     StgWord srcloc_len = strlen(srcloc);

     postStringLen(&eventBuf, module, module_len);

     postStringLen(&eventBuf, srcloc, srcloc_len);

     postWord8(&eventBuf, is_caf);

 }

 void postHeapProfSampleCostCentre(CostCentreStack *stack,

                                   StgWord64 residency)

 {

     StgWord depth = 0;

     CostCentreStack *ccs;

     for (ccs = stack; ccs != NULL && ccs != CCS_MAIN; ccs = ccs->prevStack)

          depth>0 && ccs != NULL && ccs != CCS_MAIN;

          ccs = ccs->prevStack, depth--)

         postWord32(&eventBuf, ccs->cc->ccID);

 }

                               CostCentreStack *stack,

                               StgWord64 tick)

 {

     StgWord depth = 0;

     CostCentreStack *ccs;

     for (ccs = stack; ccs != NULL && ccs != CCS_MAIN; ccs = ccs->prevStack)

          depth>0 && ccs != NULL && ccs != CCS_MAIN;

          ccs = ccs->prevStack, depth--)

         postWord32(&eventBuf, ccs->cc->ccID);

 }

 // This event is output at the start of profiling so the tick interval can

 // can be calculated from how many samples there are.

 void postProfBegin(void)

 {

     postEventHeader(&eventBuf, EVENT_PROF_BEGIN);

     // The interval that each tick was sampled, in nanoseconds

     postWord64(&eventBuf, TimeToNS(RtsFlags.MiscFlags.tickInterval));

 }

 #endif /* PROFILING */

 void postTickyCounterDefs(StgEntCounter *counters)

 {

     for (StgEntCounter *p = counters; p != NULL; p = p->link) {

         postTickyCounterDef(&eventBuf, p);

     }

 }

 static void postTickyCounterSample(EventsBuf *eb, StgEntCounter *p)

 void postTickyCounterSamples(StgEntCounter *counters)

 {

     ensureRoomForEvent(&eventBuf, EVENT_TICKY_COUNTER_SAMPLE);

     postEventHeader(&eventBuf, EVENT_TICKY_COUNTER_BEGIN_SAMPLE);

     for (StgEntCounter *p = counters; p != NULL; p = p->link) {

         postTickyCounterSample(&eventBuf, p);

     }

 }

 #endif /* TICKY_TICKY */

 void postIPE(const InfoProvEnt *ipe)

     // See Note [Maximum event length].

     const StgWord MAX_IPE_STRING_LEN = 65535;

     StgWord table_name_len = MIN(strlen(ipe->prov.table_name), MAX_IPE_STRING_LEN);

     StgWord closure_desc_len = MIN(strlen(closure_desc_buf), MAX_IPE_STRING_LEN);

     StgWord ty_desc_len = MIN(strlen(ipe->prov.ty_desc), MAX_IPE_STRING_LEN);

     postBuf(&eventBuf, &colon, 1);

     postStringLen(&eventBuf, ipe->prov.src_span, src_span_len);

 }

 void printAndClearEventBuf (EventsBuf *ebuf)

 // Flush all capabilities' event buffers when we already hold all capabilities.

 // Used during forkProcess.

 void flushAllCapsEventsBufs(void)

 {

     if (!event_log_writer) {

         return;

     }

     printAndClearEventBuf(&eventBuf);

     for (unsigned int i=0; i < getNumCapabilities(); i++) {

         flushLocalEventsBuf(getCapability(i));

       return;

     }

     printAndClearEventBuf(&eventBuf);

 #if defined(THREADED_RTS)

     Task *task = newBoundTask();

 #if defined(TRACING)

 extern bool eventlog_enabled;

 void initEventLogging(void);

 void restartEventLogging(void);

 void moreCapEventBufs (uint32_t from, uint32_t to);

 void flushLocalEventsBuf(Capability *cap);

 void flushAllCapsEventsBufs(void);

 void flushAllEventsBufs(Capability *cap);

 typedef void (*EventlogInitPost)(void);

 #pragma once

 #if defined(HAVE_PTHREAD_H) && !defined(mingw32_HOST_OS)

 #if defined(CMINUSMINUS)

 //

 // Mutexes

 //

 extern void initMutex             ( Mutex* pMut );

 extern void closeMutex            ( Mutex* pMut );

 // Processors and affinity

 void setThreadAffinity (uint32_t n, uint32_t m);

 void setThreadNode (uint32_t node);

 #else

 #define ACQUIRE_LOCK(l)

 #define TRY_ACQUIRE_LOCK(l) 0

 #define RELEASE_LOCK(l)

 test('T26061', normal, compile_and_run, [''])

 test('T26537', normal, compile_and_run, ['-O2 -fregs-graph'])

 test('T24016', normal, compile_and_run, ['-O1 -fPIC'])

 # Check that GHC-generated finalizers run on Darwin. The Apple linker doesn't

 # support --wrap, so we can't intercept hs_spt_remove directly.  Instead we

 main :: IO ()

 main = do

   setNumCapabilities 2