if (pid == 0)
if (__builtin_expect (pid, 0) == 0)
int __pthread_initialize_manager(void){  int manager_pipe[2];  int pid;  struct pthread_request request;  struct rlimit limit;  int max_stack;  /* Play with the stack size limit to make sure that no stack ever grows     beyond STACK_SIZE minus one page (to act as a guard page). */  getrlimit(RLIMIT_STACK, &limit);#ifdef NEED_SEPARATE_REGISTER_STACK  /* STACK_SIZE bytes hold both the main stack and register backing     store. The rlimit value applies to each individually.  */  max_stack = STACK_SIZE/2 - __getpagesize();#else  max_stack = STACK_SIZE - __getpagesize();#endif  if (limit.rlim_cur > max_stack) {    limit.rlim_cur = max_stack;    setrlimit(RLIMIT_STACK, &limit);  }  /* If basic initialization not done yet (e.g. we're called from a     constructor run before our constructor), do it now */  if (__pthread_initial_thread_bos == NULL) pthread_initialize();  /* Setup stack for thread manager */  __pthread_manager_thread_bos = malloc(THREAD_MANAGER_STACK_SIZE);  if (__pthread_manager_thread_bos == NULL) return -1;  __pthread_manager_thread_tos =    __pthread_manager_thread_bos + THREAD_MANAGER_STACK_SIZE;  /* Setup pipe to communicate with thread manager */  if (pipe(manager_pipe) == -1) {    free(__pthread_manager_thread_bos);    return -1;  }  /* Start the thread manager */  pid = 0;  if (__pthread_initial_thread.p_report_events)    {      /* It's a bit more complicated.  We have to report the creation of	 the manager thread.  */      int idx = __td_eventword (TD_CREATE);      uint32_t mask = __td_eventmask (TD_CREATE);      if ((mask & (__pthread_threads_events.event_bits[idx]		   | __pthread_initial_thread.p_eventbuf.eventmask.event_bits[idx]))	  != 0)	{	  __pthread_lock(__pthread_manager_thread.p_lock, NULL);#ifdef NEED_SEPARATE_REGISTER_STACK	  pid = __clone2(__pthread_manager_event,			 (void **) __pthread_manager_thread_bos,			 THREAD_MANAGER_STACK_SIZE,			 CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,			 (void *)(long)manager_pipe[0]);#else	  pid = __clone(__pthread_manager_event,			(void **) __pthread_manager_thread_tos,			CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,			(void *)(long)manager_pipe[0]);#endif	  if (pid != -1)	    {	      /* Now fill in the information about the new thread in	         the newly created thread's data structure.  We cannot let	         the new thread do this since we don't know whether it was	         already scheduled when we send the event.  */	      __pthread_manager_thread.p_eventbuf.eventdata =		&__pthread_manager_thread;	      __pthread_manager_thread.p_eventbuf.eventnum = TD_CREATE;	      __pthread_last_event = &__pthread_manager_thread;	      __pthread_manager_thread.p_tid = 2* PTHREAD_THREADS_MAX + 1;	      __pthread_manager_thread.p_pid = pid;	      /* Now call the function which signals the event.  */	      __linuxthreads_create_event ();	    }	  /* Now restart the thread.  */	  __pthread_unlock(__pthread_manager_thread.p_lock);	}    }  if (pid == 0)    {#ifdef NEED_SEPARATE_REGISTER_STACK      pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos,		     THREAD_MANAGER_STACK_SIZE,		     CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,		     (void *)(long)manager_pipe[0]);#else      pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos,		    CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND,		    (void *)(long)manager_pipe[0]);#endif    }  if (pid == -1) {    free(__pthread_manager_thread_bos);    __libc_close(manager_pipe[0]);    __libc_close(manager_pipe[1]);    return -1;  }  __pthread_manager_request = manager_pipe[1]; /* writing end */  __pthread_manager_reader = manager_pipe[0]; /* reading end */  __pthread_manager_thread.p_tid = 2* PTHREAD_THREADS_MAX + 1;  __pthread_manager_thread.p_pid = pid;  /* Make gdb aware of new thread manager */  if (__pthread_threads_debug && __pthread_sig_debug > 0)    {      raise(__pthread_sig_debug);      /* We suspend ourself and gdb will wake us up when it is	 ready to handle us. */      __pthread_wait_for_restart_signal(thread_self());    }  /* Synchronize debugging of the thread manager */  request.req_kind = REQ_DEBUG;  __libc_write(__pthread_manager_request, (char *) &request, sizeof(request));  return 0;}