sgen_resume_thread (struct SgenThreadInfo * info)
{
  gboolean D.17594;
  int restart_signal_num.0;
  int D.17596;
  _Bool D.17597;

  restart_signal_num.0 = 24;
  D.17596 = mono_threads_pthread_kill (info, restart_signal_num.0);
  D.17597 = D.17596 == 0;
  D.17594 = (gboolean) D.17597;
  return D.17594;
}


sgen_suspend_thread (struct SgenThreadInfo * info)
{
  gboolean D.17599;
  int suspend_signal_num.1;
  int D.17601;
  _Bool D.17602;

  suspend_signal_num.1 = 30;
  D.17601 = mono_threads_pthread_kill (info, suspend_signal_num.1);
  D.17602 = D.17601 == 0;
  D.17599 = (gboolean) D.17602;
  return D.17599;
}


sgen_wait_for_suspend_ack (int count)
{
  int * D.17604;
  int D.17605;
  char * D.17608;
  union MonoSemType * suspend_ack_semaphore_ptr.2;
  int i;
  int result;

  i = 0;
  goto <D.17567>;
  <D.17566>:
  goto <D.17564>;
  <D.17563>:
  D.17604 = __errno_location ();
  D.17605 = *D.17604;
  if (D.17605 != 4) goto <D.17606>; else goto <D.17607>;
  <D.17606>:
  D.17604 = __errno_location ();
  D.17605 = *D.17604;
  D.17608 = strerror (D.17605);
  D.17604 = __errno_location ();
  D.17605 = *D.17604;
  monoeg_g_log (0B, 4, "MONO_SEM_WAIT FAILED with %d errno %d (%s)", result, D.17605, D.17608);
  <D.17562>:
  goto <D.17562>;
  <D.17607>:
  <D.17564>:
  suspend_ack_semaphore_ptr.2 = suspend_ack_semaphore_ptr;
  result = mono_sem_wait (suspend_ack_semaphore_ptr.2, 0);
  if (result != 0) goto <D.17563>; else goto <D.17565>;
  <D.17565>:
  i = i + 1;
  <D.17567>:
  if (i < count) goto <D.17566>; else goto <D.17568>;
  <D.17568>:
}


sgen_thread_handshake (BOOL suspend)
{
  const int iftmp.3;
  struct MonoLinkedListSet * D.17614;
  struct MonoLinkedListSetNode * * D.17615;
  void * D.17616;
  struct MonoLinkedListSetNode * * D.17617;
  long unsigned int D.17618;
  long unsigned int D.17621;
  int D.17622;
  int D.17625;
  const char * iftmp.4;
  struct FILE * gc_debug_file.5;
  int D.17642;
  int count;
  int result;
  struct SgenThreadInfo * info;
  int signum;
  MonoNativeThreadId me;

  if (suspend != 0) goto <D.17611>; else goto <D.17612>;
  <D.17611>:
  iftmp.3 = 30;
  goto <D.17613>;
  <D.17612>:
  iftmp.3 = 24;
  <D.17613>:
  signum = iftmp.3;
  me = mono_native_thread_id_get ();
  count = 0;
  {
    struct MonoThreadHazardPointers * __hp;
    struct MonoLinkedListSetNode * __cur;
    struct MonoLinkedListSetNode * __next;

    __hp = mono_hazard_pointer_get ();
    D.17614 = mono_thread_info_list_head ();
    D.17615 = &D.17614->head;
    D.17616 = get_hazardous_pointer (D.17615, __hp, 1);
    __cur = mono_lls_pointer_unmask (D.17616);
    goto <D.17582>;
    <D.17581>:
    D.17617 = &__cur->next;
    __next = get_hazardous_pointer_with_mask (D.17617, __hp, 0);
    D.17618 = mono_lls_pointer_get_mark (__next);
    if (D.17618 == 0) goto <D.17619>; else goto <D.17620>;
    <D.17619>:
    info = __cur;
    D.17621 = MEM[(struct MonoThreadInfo *)info].node.key;
    D.17622 = mono_native_thread_id_equals (D.17621, me);
    if (D.17622 != 0) goto <D.17623>; else goto <D.17624>;
    <D.17623>:
    // predicted unlikely by continue predictor.
    goto <D.17580>;
    <D.17624>:
    D.17625 = info->gc_disabled;
    if (D.17625 != 0) goto <D.17626>; else goto <D.17627>;
    <D.17626>:
    // predicted unlikely by continue predictor.
    goto <D.17580>;
    <D.17627>:
    result = mono_threads_pthread_kill (info, signum);
    if (result == 0) goto <D.17628>; else goto <D.17629>;
    <D.17628>:
    count = count + 1;
    goto <D.17630>;
    <D.17629>:
    info->skip = 1;
    <D.17630>:
    <D.17620>:
    <D.17580>:
    __cur = mono_lls_info_step (__next, __hp);
    <D.17582>:
    if (__cur != 0B) goto <D.17581>; else goto <D.17583>;
    <D.17583>:
    if (0 != 0) goto <D.17631>; else goto <D.17632>;
    <D.17631>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.17632>:
    __hp->hazard_pointers[0] = 0B;
    if (0 != 0) goto <D.17633>; else goto <D.17634>;
    <D.17633>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.17634>:
    __hp->hazard_pointers[1] = 0B;
  }
  sgen_wait_for_suspend_ack (count);
  if (0 != 0) goto <D.17635>; else goto <D.17636>;
  <D.17635>:
  if (suspend != 0) goto <D.17638>; else goto <D.17639>;
  <D.17638>:
  iftmp.4 = "suspend";
  goto <D.17640>;
  <D.17639>:
  iftmp.4 = "resume";
  <D.17640>:
  gc_debug_file.5 = gc_debug_file;
  fprintf (gc_debug_file.5, "%s handshake for %d threads\n\n", iftmp.4, count);
  gc_debug_file.5 = gc_debug_file;
  fflush (gc_debug_file.5);
  <D.17636>:
  D.17642 = count;
  return D.17642;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.17644;
  long unsigned int p.6;
  long unsigned int D.17646;

  p.6 = (long unsigned int) p;
  D.17646 = p.6 & 18446744073709551612;
  D.17644 = (void *) D.17646;
  return D.17644;
}


mono_lls_pointer_get_mark (void * n)
{
  uintptr_t D.17648;
  long unsigned int n.7;

  n.7 = (long unsigned int) n;
  D.17648 = n.7 & 1;
  return D.17648;
}


mono_lls_info_step (struct MonoLinkedListSetNode * val, struct MonoThreadHazardPointers * hp)
{
  struct MonoLinkedListSetNode * D.17653;

  val = mono_lls_pointer_unmask (val);
  if (0 != 0) goto <D.17651>; else goto <D.17652>;
  <D.17651>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "../../mono/utils/mono-linked-list-set.h", 77, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
  <D.17652>:
  hp->hazard_pointers[1] = val;
  mono_memory_write_barrier ();
  D.17653 = val;
  return D.17653;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


sgen_os_init ()
{
  int suspend_signal_num.8;
  int D.17656;
  int restart_signal_num.9;
  int D.17660;
  struct sigaction sinfo;

  try
    {
      suspend_ack_semaphore_ptr = &suspend_ack_semaphore;
      sem_init (&suspend_ack_semaphore, 0, 0);
      sigfillset (&sinfo.sa_mask);
      sinfo.sa_flags = 268435460;
      sinfo.__sigaction_handler.sa_sigaction = suspend_handler;
      suspend_signal_num.8 = 30;
      D.17656 = sigaction (suspend_signal_num.8, &sinfo, 0B);
      if (D.17656 != 0) goto <D.17657>; else goto <D.17658>;
      <D.17657>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.17588>:
      goto <D.17588>;
      <D.17658>:
      sinfo.__sigaction_handler.sa_handler = restart_handler;
      restart_signal_num.9 = 24;
      D.17660 = sigaction (restart_signal_num.9, &sinfo, 0B);
      if (D.17660 != 0) goto <D.17661>; else goto <D.17662>;
      <D.17661>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.17589>:
      goto <D.17589>;
      <D.17662>:
      sigfillset (&suspend_signal_mask);
      restart_signal_num.9 = 24;
      sigdelset (&suspend_signal_mask, restart_signal_num.9);
      sigemptyset (&suspend_ack_signal_mask);
      restart_signal_num.9 = 24;
      sigaddset (&suspend_ack_signal_mask, restart_signal_num.9);
    }
  finally
    {
      sinfo = {CLOBBER};
    }
}


restart_handler (int sig)
{
  int * D.17663;
  long unsigned int D.17666;
  void * D.17667;
  struct FILE * gc_debug_file.10;
  struct SgenThreadInfo * info;
  int old_errno;

  D.17663 = __errno_location ();
  old_errno = *D.17663;
  info = mono_thread_info_current ();
  info->signal = 24;
  if (0 != 0) goto <D.17664>; else goto <D.17665>;
  <D.17664>:
  D.17666 = mono_native_thread_id_get ();
  D.17667 = (void *) D.17666;
  gc_debug_file.10 = gc_debug_file;
  fprintf (gc_debug_file.10, "Restart handler in %p %p\n", info, D.17667);
  gc_debug_file.10 = gc_debug_file;
  fflush (gc_debug_file.10);
  <D.17665>:
  D.17663 = __errno_location ();
  *D.17663 = old_errno;
}


suspend_handler (int sig, struct siginfo_t * siginfo, void * context)
{
  int * D.17669;
  struct SgenThreadInfo * info;
  int old_errno;

  D.17669 = __errno_location ();
  old_errno = *D.17669;
  info = mono_thread_info_current ();
  suspend_thread (info, context);
  D.17669 = __errno_location ();
  *D.17669 = old_errno;
}


suspend_thread (struct SgenThreadInfo * info, void * context)
{
  struct MonoDomain * D.17670;
  void * iftmp.11;
  greg_t * D.17674;
  long unsigned int D.17675;
  unsigned int sgen_global_stop_count.12;
  void * iftmp.13;
  greg_t * D.17683;
  long unsigned int D.17684;
  sizetype D.17685;
  void * D.17689;
  void * D.17691;
  void * D.17692;
  struct MonoContext * D.17696;
  _Bool D.17698;
  long int D.17699;
  long int D.17700;
  struct MonoGCCallbacks * D.17703;
  void (*<T2ab1>) (void *, void *, struct MonoContext *) D.17704;
  struct MonoGCCallbacks * D.17707;
  void (*<T2ab1>) (void *, void *, struct MonoContext *) D.17708;
  void * D.17709;
  long unsigned int D.17712;
  void * D.17713;
  struct FILE * gc_debug_file.14;
  union MonoSemType * suspend_ack_semaphore_ptr.15;
  unsigned int stop_count.16;
  int D.17717;
  long unsigned int D.17720;
  void * D.17721;
  int stop_count;
  void * stack_start;

  D.17670 = mono_domain_get ();
  info->stopped_domain = D.17670;
  if (context != 0B) goto <D.17672>; else goto <D.17673>;
  <D.17672>:
  D.17674 = &MEM[(struct ucontext_t *)context].uc_mcontext.gregs[16];
  D.17675 = MEM[(guint64 *)D.17674];
  iftmp.11 = (void *) D.17675;
  goto <D.17676>;
  <D.17673>:
  iftmp.11 = 0B;
  <D.17676>:
  info->stopped_ip = iftmp.11;
  info->signal = 0;
  sgen_global_stop_count.12 = sgen_global_stop_count;
  stop_count = (int) sgen_global_stop_count.12;
  if (0 != 0) goto <D.17678>; else goto <D.17679>;
  <D.17678>:
  return;
  <D.17679>:
  if (context != 0B) goto <D.17681>; else goto <D.17682>;
  <D.17681>:
  D.17683 = &MEM[(struct ucontext_t *)context].uc_mcontext.gregs[15];
  D.17684 = MEM[(guint64 *)D.17683];
  D.17685 = D.17684 + 18446744073709551488;
  iftmp.13 = (void *) D.17685;
  goto <D.17686>;
  <D.17682>:
  iftmp.13 = 0B;
  <D.17686>:
  stack_start = iftmp.13;
  D.17689 = info->stack_start_limit;
  if (D.17689 <= stack_start) goto <D.17690>; else goto <D.17687>;
  <D.17690>:
  D.17691 = info->stack_start;
  D.17692 = info->stack_end;
  if (D.17691 <= D.17692) goto <D.17693>; else goto <D.17687>;
  <D.17693>:
  info->stack_start = stack_start;
  if (context != 0B) goto <D.17694>; else goto <D.17695>;
  <D.17694>:
  D.17696 = &info->ctx;
  mono_sigctx_to_monoctx (context, D.17696);
  goto <D.17697>;
  <D.17695>:
  D.17696 = &info->ctx;
  memset (D.17696, 0, 136);
  <D.17697>:
  goto <D.17688>;
  <D.17687>:
  D.17691 = info->stack_start;
  D.17698 = D.17691 != 0B;
  D.17699 = (long int) D.17698;
  D.17700 = __builtin_expect (D.17699, 0);
  if (D.17700 != 0) goto <D.17701>; else goto <D.17702>;
  <D.17701>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 90, "!info->stack_start");
  <D.17702>:
  <D.17688>:
  D.17703 = mono_gc_get_gc_callbacks ();
  D.17704 = D.17703->thread_suspend_func;
  if (D.17704 != 0B) goto <D.17705>; else goto <D.17706>;
  <D.17705>:
  D.17707 = mono_gc_get_gc_callbacks ();
  D.17708 = D.17707->thread_suspend_func;
  D.17709 = info->runtime_data;
  D.17708 (D.17709, context, 0B);
  <D.17706>:
  if (0 != 0) goto <D.17710>; else goto <D.17711>;
  <D.17710>:
  D.17712 = mono_native_thread_id_get ();
  D.17713 = (void *) D.17712;
  gc_debug_file.14 = gc_debug_file;
  fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for suspend from %p %p\n", info, D.17713);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.17711>:
  pthread_sigmask (0, &suspend_ack_signal_mask, 0B);
  suspend_ack_semaphore_ptr.15 = suspend_ack_semaphore_ptr;
  mono_sem_post (suspend_ack_semaphore_ptr.15);
  stop_count.16 = (unsigned int) stop_count;
  info->stop_count = stop_count.16;
  <D.17537>:
  info->signal = 0;
  sigsuspend (&suspend_signal_mask);
  D.17717 = info->signal;
  if (D.17717 != 24) goto <D.17537>; else goto <D.17538>;
  <D.17538>:
  pthread_sigmask (1, &suspend_ack_signal_mask, 0B);
  if (0 != 0) goto <D.17718>; else goto <D.17719>;
  <D.17718>:
  D.17720 = mono_native_thread_id_get ();
  D.17721 = (void *) D.17720;
  gc_debug_file.14 = gc_debug_file;
  fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for resume from %p %p\n\n", info, D.17721);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.17719>:
  suspend_ack_semaphore_ptr.15 = suspend_ack_semaphore_ptr;
  mono_sem_post (suspend_ack_semaphore_ptr.15);
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.17725;
  int D.17730;
  void * D.17732;
  long unsigned int D.17733;

  D.17725 = __builtin_constant_p (__len);
  if (D.17725 != 0) goto <D.17726>; else goto <D.17727>;
  <D.17726>:
  if (__len == 0) goto <D.17728>; else goto <D.17729>;
  <D.17728>:
  D.17730 = __builtin_constant_p (__ch);
  if (D.17730 == 0) goto <D.17723>; else goto <D.17731>;
  <D.17731>:
  if (__ch != 0) goto <D.17723>; else goto <D.17724>;
  <D.17723>:
  __warn_memset_zero_len ();
  D.17732 = __dest;
  return D.17732;
  <D.17724>:
  <D.17729>:
  <D.17727>:
  D.17733 = __builtin_object_size (__dest, 0);
  D.17732 = __builtin___memset_chk (__dest, __ch, __len, D.17733);
  return D.17732;
}


mono_gc_get_suspend_signal ()
{
  int D.17735;

  D.17735 = 30;
  return D.17735;
}