if (atomic_decrement_and_test (&__nptl_nthreads))
if (__builtin_expect (atomic_decrement_and_test (&__nptl_nthreads), 0))
start_thread (void *arg){  /* One more thread.  */  atomic_increment (&__nptl_nthreads);  struct pthread *pd = (struct pthread *) arg;#if HP_TIMING_AVAIL  /* Remember the time when the thread was started.  */  hp_timing_t now;  HP_TIMING_NOW (now);  THREAD_SETMEM (pd, cpuclock_offset, now);#endif  /* This is where the try/finally block should be created.  For     compilers without that support we do use setjmp.  */  if (setjmp (pd->cancelbuf) == 0)    {      /* Run the code the user provided.  */      pd->result = pd->start_routine (pd->arg);    }  /* If this is the last thread we terminate the process now.  We     do not notify the debugger, it might just irritate it if there     is no thread left.  */  if (atomic_decrement_and_test (&__nptl_nthreads))    /* This was the last thread.  */    exit (0);  /* Report the death of the thread if this is wanted.  */  if (__builtin_expect (pd->report_events, 0))    {      /* See whether TD_DEATH is in any of the mask.  */      const int idx = __td_eventword (TD_DEATH);      const uint32_t mask = __td_eventmask (TD_DEATH);      if ((mask & (__nptl_threads_events.event_bits[idx]		   | pd->eventbuf.eventmask.event_bits[idx])) != 0)	{	  /* Yep, we have to signal the death.  Add the descriptor to	     the list but only if it is not already on it.  */	  if (pd->nextevent == NULL)	    {	      pd->eventbuf.eventnum = TD_DEATH;	      pd->eventbuf.eventdata = pd;	      do		pd->nextevent = __nptl_last_event;	      while (atomic_compare_and_exchange_acq (&__nptl_last_event, pd,						      pd->nextevent) != 0);	    }	  /* Now call the function to signal the event.  */	  __nptl_death_event ();	}    }  /* The thread is exiting now.  */  atomic_bit_set (&pd->cancelhandling, EXITING_BIT);  /* If the thread is detached free the TCB.  */  if (IS_DETACHED (pd))    /* Free the TCB.  */    __free_tcb (pd);  /* We cannot call '_exit' here.  '_exit' will terminate the process.     The 'exit' implementation in the kernel will signal when the     process is really dead since 'clone' got passed the CLONE_CLEARTID     flag.  The 'tid' field in the TCB will be set to zero.     The exit code is zero since in case all threads exit by calling     'pthread_exit' the exit status must be 0 (zero).  */  __exit_thread_inline (0);  /* NOTREACHED */  return 0;}