fi

 fi

 if [ -n "${IGNORE_PERF_FAILURES:-}" ]; then

 fi

 if [[ -z ${BIGNUM_BACKEND:-} ]]; then BIGNUM_BACKEND=gmp; fi

     /* The invariant is

      *   created = converted + remaining + gcd + fizzled

      */

                             "(created == converted + remaining + gcd + fizzled)",

                             sparks.created, sparks.converted, remaining,

                             sparks.gcd, sparks.fizzled);

 /* CMM primop. Result is true on success, or false on allocation failure. */

 bool syncDelay(CapIOManager *iomgr, StgTSO *tso, HsInt us_delay)

 {

     ASSERT(tso->why_blocked == NotBlocked);

     switch (iomgr_type) {

 #if defined(IOMGR_ENABLED_SELECT)

     if (i == &stg_MSG_TRY_WAKEUP_info)

     {

         StgTSO *tso = ((MessageWakeup *)m)->tso;

         tryWakeupThread(cap, tso);

     }

     else if (i == &stg_MSG_THROWTO_info)

             goto loop;

         }

         r = throwToMsg(cap, t);

     uint32_t i;

     for(i = 0; i < size; i++, bitmap >>= 1 ) {

         if ((bitmap & 1) == 0) {

             printPtr((P_)payload[i]);

             debugBelch(" -- ");

         StgWord bitmap = large_bitmap->bitmap[bmp];

         j = 0;

         for(; i < size && j < BITS_IN(W_); j++, i++, bitmap >>= 1 ) {

             if ((bitmap & 1) == 0) {

                 printPtr((P_)payload[i]);

                 debugBelch(" -- ");

   StgTRecHeader *__t = (_t);                                                    \

   StgTRecChunk *__c = __t -> current_chunk;                                     \

   StgWord __limit = __c -> next_entry_idx;                                      \

   while (__c != END_STM_CHUNK_LIST) {                                           \

     StgWord __i;                                                                \

     for (__i = 0; __i < __limit; __i ++) {                                      \

             result = false;

             BREAK_FOR_EACH;

           } else {

           }

         });

       }

       StgTVar *s;

       s = e -> tvar;

       if (entry_is_read_only(e)) {

         // We must first load current_value then num_updates; this is inverse of

         // the order of the stores in stmCommitTransaction.

 StgBool stmValidateNestOfTransactions(Capability *cap, StgTRecHeader *trec, StgBool optimistically) {

   StgTRecHeader *t;

   ASSERT(trec != NO_TREC);

   ASSERT((trec -> state == TREC_ACTIVE) ||

          (trec -> state == TREC_WAITING) ||

 #if defined(DEBUG)

         debugTrace(DEBUG_sched,

 #endif

         // don't do this if the nursery is (nearly) full, we'll GC first.

     pool->top     &= pool->moduloSize;

     debugTrace(DEBUG_sparks,

                sparkPoolSize(pool), pool->bottom, pool->top);

     ASSERT_WSDEQUE_INVARIANTS(pool);

     debugTrace(DEBUG_sparks, "pruned %d sparks", pruned_sparks);

     debugTrace(DEBUG_sparks,

                sparkPoolSize(pool), pool->bottom, pool->top);

     ASSERT_WSDEQUE_INVARIANTS(pool);

     }

     debugTrace(DEBUG_sparks,

                sparkPoolSize(pool), pool->bottom, pool->top);

 }

   if (sn != 0) {

     ASSERT(stable_name_table[sn].addr == p);

     stableNameUnlock();

     return sn;

   }

                 p->sn_obj = isAlive(p->sn_obj);

                 if (p->sn_obj == NULL) {

                     // StableName object died

                     freeSnEntry(p);

                 } else if (p->addr != NULL) {

                     // sn_obj is alive, update pointee

                 || (bh_info == &stg_WHITEHOLE_info))

             {

                 debugTrace(DEBUG_squeeze,

                 // If this closure is already an indirection, then

                 // suspend the computation up to this point.

         debugTrace(DEBUG_gc,

                    "threadStackOverflow of TSO %" FMT_StgThreadID " (%p): stack"

                    (long)tso->stackobj->stack_size, RtsFlags.GcFlags.maxStkSize);

         IF_DEBUG(gc,

                  /* If we're debugging, just print out the top of the stack */

     }

     debugTraceCap(DEBUG_sched, cap,

                   chunk_size * sizeof(W_));

     // Charge the current thread for allocating stack.  Stack usage is

   switch (UntagWhyBlocked(ACQUIRE_LOAD(&tso->why_blocked))) {

 #if defined(mingw32_HOST_OS)

     case BlockedOnDoProc:

     break;

 #endif

 #if !defined(THREADED_RTS)

 // -----------------------------------------------------------------------------

 #if defined(DEBUG)

 void traceEnd (void);

 #endif

         traceCap_(cap, msg, ##__VA_ARGS__);     \

     }

 /*

  * Emit a trace message

         trace_(msg, ##__VA_ARGS__);             \

     }

 /*

  * A message or event emitted by the program

         int res = ppoll(poll_table, nfds, &tv, NULL);

         debugTrace(DEBUG_iomanager,

 #else

         int res = poll(poll_table, nfds, 0);

         debugTrace(DEBUG_iomanager,

 #endif

         if (res == 0) {

             /* There is no I/O ready. We'll return to the scheduler. */

         int res = ppoll(poll_table, nfds, timeout_ns, NULL);

         debugTrace(DEBUG_iomanager,

                    res);

 #else

         int res = poll(poll_table, nfds, timeout_ms);

         debugTrace(DEBUG_iomanager,

                    nfds, timeout_ms, res);

 #endif

     insertTimeoutQueue(&iomgr->timeout_queue, timeout, target);

     debugTrace(DEBUG_iomanager,

                us_delay, target);

     return true;

 }

         if (now < waketime) {

             break;

         }

         StgTimeout *timeout;

         deleteMinTimeoutQueue(&iomgr->timeout_queue, &timeout);

         notifyTimeoutCompletion(iomgr, timeout);

     // 2. update forward ptrs

     for (W_ g = 0; g < RtsFlags.GcFlags.generations; g++) {

         generation *gen = &generations[g];

         update_fwd(gen->blocks);

         for (W_ n = 0; n < getNumCapabilities(); n++) {

         update_fwd_large(gen->scavenged_large_objects);

         update_fwd_cnf(gen->live_compact_objects);

         if (g == RtsFlags.GcFlags.generations-1 && gen->old_blocks != NULL) {

             update_fwd_compact(gen->old_blocks);

         }

     }

     if (gen->old_blocks != NULL) {

         W_ blocks = update_bkwd_compact(gen);

         debugTrace(DEBUG_gc,

                    gen->no, gen->n_old_blocks, blocks);

         gen->n_old_blocks = blocks;

     }

               if(idle_cap[i]) { continue; }

               thread = gc_threads[i];

               debugTrace(DEBUG_gc,"thread %d:", i);

                          RELAXED_LOAD(&thread->copied) * sizeof(W_));

                          RELAXED_LOAD(&thread->scanned) * sizeof(W_));

                          RELAXED_LOAD(&thread->any_work));

                          RELAXED_LOAD(&thread->scav_find_work));

               any_work += RELAXED_LOAD(&thread->any_work);

 #if defined(DEBUG)

         debugTrace(DEBUG_gc,

                    (unsigned long)(mut_list_size * sizeof(W_)),

                    mutlist_scav_stats.n_MUTVAR,

                    mutlist_scav_stats.n_MUTARR,

   // Free the mark stack.

   if (mark_stack_top_bd != NULL) {

                  countBlocks(mark_stack_top_bd));

       freeChain(mark_stack_top_bd);

   }

       need_copied_live = BLOCK_ROUND_UP(need_copied_live) / BLOCK_SIZE_W;

       need_uncopied_live = BLOCK_ROUND_UP(need_uncopied_live) / BLOCK_SIZE_W;

       // minOldGenSize states that the size of the oldest generation must be at least

       if (RtsFlags.GcFlags.minOldGenSize >= need_copied_live + need_uncopied_live){

         extra_needed = RtsFlags.GcFlags.minOldGenSize - (need_copied_live + need_uncopied_live);

       }

       // If oldest gen is uncopying in some manner (compact or non-moving) then

       // add the extra requested by minOldGenSize to uncopying portion of memory.

       ASSERT(need_uncopied_live + need_copied_live >= RtsFlags.GcFlags.minOldGenSize );

       need_prealloc = 0;

       for (i = 0; i < n_nurseries; i++) {

       need = BLOCKS_TO_MBLOCKS(need);

       got = mblocks_allocated;

       uint32_t returned = 0;

       if (got > need) {

             gen->bitmap = bitmap_bdescr;

             bitmap = bitmap_bdescr->start;

                        bitmap_size, bitmap);

             // don't forget to fill it with zeros!

             adjusted_blocks = (RtsFlags.GcFlags.maxHeapSize - 2 * blocks);

                        RtsFlags.GcFlags.maxHeapSize, blocks, adjusted_blocks);

             pc_free = adjusted_blocks * 100 / RtsFlags.GcFlags.maxHeapSize;

 void

 push_todo_block(bdescr *bd, gen_workspace *ws)

 {

     ASSERT(bd->link == NULL);

     // Do nothing if USE_LARGE_ADDRESS_SPACE, we never want

     // to release address space

 }

 #else // !USE_LARGE_ADDRESS_SPACE

   oldest_gen->n_words  -= pruned_segments * NONMOVING_SEGMENT_SIZE;

   nonmovingHeap.saved_free = NULL;

   debugTrace(DEBUG_nonmoving_gc,

             pruned_segments, new_length);

   traceNonmovingPrunedSegments(pruned_segments, new_length);

   trace(TRACE_nonmoving_gc, "Finished pruning free segment list.");

 bool nonmovingWaitForFlush(void)

 {

     ACQUIRE_LOCK(&upd_rem_set_lock);

     bool finished = upd_rem_set_flush_count == getNumCapabilities();

     if (!finished) {

         waitCondition(&upd_rem_set_flushed_cond, &upd_rem_set_lock);

                 RELEASE_SM_LOCK;

             } else {

                 // Nothing more to do

                 traceConcMarkEnd(count);

                 return;

             }

         node = capNoToNumaNode(i);

         if (nursery_blocks < blocks) {

                        nursery_blocks, blocks);

             nursery->blocks = allocNursery(node, nursery->blocks,

                                            blocks-nursery_blocks);

         {

             bdescr *next_bd;

                        nursery_blocks, blocks);

             bd = nursery->blocks;

             // might have gone just under, by freeing a large block, so make

             // up the difference.

             if (nursery_blocks < blocks) {

                              nursery_blocks, blocks);

                 nursery->blocks = allocNursery(node, nursery->blocks,

                                                blocks-nursery_blocks);

     gen->live_estimate = live;

           gen->n_old_blocks + freed,

           gen->n_old_blocks - blocks + freed,

           freed,

 test('CCallConv', [req_c], compile_and_run, ['CCallConv_c.c'])

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

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

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

 test('T27046',

      [ req_cmm

 cua CanUpdateAnchorOnly _ = return []

 cua NoCanUpdateAnchor _ = return []

 -- | "Enter" an annotation, by using the associated 'anchor' field as

 -- the new reference point for calculating all DeltaPos positions.

 -- This is the heart of the exact printing process.

 -- This is combination of the ghc=exactprint Delta.withAST and

 -- Print.exactPC functions and effectively does the delta processing

 -- immediately followed by the print processing.  JIT ghc-exactprint.

   p <- getPosP

   debugM $ "enterAnn:starting:NO ANN:(p,a) =" ++ show (p, astId a)

   debugM $ "enterAnn:done:NO ANN:p =" ++ show (p, astId a)

   return r

   acceptSpan <- getAcceptSpan

   setAcceptSpan False

   case anchor' of

   advance edp

   debugM $ "enterAnn:exact a starting:" ++ show (showAst anchor')

   debugM $ "enterAnn:exact a done:" ++ show (showAst anchor')

   -- Core recursive exactprint done, start end of Entry processing

           EpaSpan s -> EpaDelta s         edp []

           _         -> EpaDelta noSrcSpan edp []

   let r = case canUpdateAnchor of

             NoCanUpdateAnchor -> a'

   return r

     epTokensToComments "(" ops

     epTokensToComments ")" cps

     outer_bndrs' <- case outer_bndrs of

       L _ (HsOuterImplicit _) -> return outer_bndrs

       _ -> markAnnotated outer_bndrs

     return (ConDeclGADT { con_g_ext = AnnConDeclGADT [] [] dcol'

                         , con_names = cons'

                         , con_modifiers = mods'

                         , con_res_ty = res_ty', con_doc = doc })

   where