__attribute__((visibility ("hidden")))
sgen_resume_thread (struct SgenThreadInfo * info)
{
  gboolean D.17738;
  int restart_signal_num.0;
  int D.17740;
  _Bool D.17741;

  restart_signal_num.0 = 24;
  D.17740 = mono_threads_pthread_kill (info, restart_signal_num.0);
  D.17741 = D.17740 == 0;
  D.17738 = (gboolean) D.17741;
  return D.17738;
}


__attribute__((visibility ("hidden")))
sgen_suspend_thread (struct SgenThreadInfo * info)
{
  gboolean D.17743;
  int suspend_signal_num.1;
  int D.17745;
  _Bool D.17746;

  suspend_signal_num.1 = 30;
  D.17745 = mono_threads_pthread_kill (info, suspend_signal_num.1);
  D.17746 = D.17745 == 0;
  D.17743 = (gboolean) D.17746;
  return D.17743;
}


__attribute__((visibility ("hidden")))
sgen_wait_for_suspend_ack (int count)
{
  int * D.17748;
  int D.17749;
  char * D.17752;
  union MonoSemType * suspend_ack_semaphore_ptr.2;
  int i;
  int result;

  i = 0;
  goto <D.17711>;
  <D.17710>:
  goto <D.17708>;
  <D.17707>:
  D.17748 = __errno_location ();
  D.17749 = *D.17748;
  if (D.17749 != 4) goto <D.17750>; else goto <D.17751>;
  <D.17750>:
  D.17748 = __errno_location ();
  D.17749 = *D.17748;
  D.17748 = __errno_location ();
  D.17749 = *D.17748;
  D.17752 = strerror (D.17749);
  monoeg_g_log (0B, 4, "MONO_SEM_WAIT FAILED with %d errno %d (%s)", result, D.17749, D.17752);
  <D.17706>:
  goto <D.17706>;
  <D.17751>:
  <D.17708>:
  suspend_ack_semaphore_ptr.2 = suspend_ack_semaphore_ptr;
  result = mono_sem_wait (suspend_ack_semaphore_ptr.2, 0);
  if (result != 0) goto <D.17707>; else goto <D.17709>;
  <D.17709>:
  i = i + 1;
  <D.17711>:
  if (i < count) goto <D.17710>; else goto <D.17712>;
  <D.17712>:
}


__attribute__((visibility ("hidden")))
sgen_thread_handshake (BOOL suspend)
{
  const int iftmp.3;
  struct MonoLinkedListSet * D.17758;
  struct MonoLinkedListSetNode * * D.17759;
  void * D.17760;
  struct MonoLinkedListSetNode * * D.17761;
  long unsigned int D.17762;
  long unsigned int D.17765;
  int D.17766;
  int D.17769;
  struct FILE * gc_debug_file.4;
  const char * iftmp.5;
  int D.17786;
  int count;
  int result;
  struct SgenThreadInfo * info;
  int signum;
  MonoNativeThreadId me;

  if (suspend != 0) goto <D.17755>; else goto <D.17756>;
  <D.17755>:
  iftmp.3 = 30;
  goto <D.17757>;
  <D.17756>:
  iftmp.3 = 24;
  <D.17757>:
  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.17758 = mono_thread_info_list_head ();
    D.17759 = &D.17758->head;
    D.17760 = get_hazardous_pointer (D.17759, __hp, 1);
    __cur = mono_lls_pointer_unmask (D.17760);
    goto <D.17726>;
    <D.17725>:
    D.17761 = &__cur->next;
    __next = get_hazardous_pointer_with_mask (D.17761, __hp, 0);
    D.17762 = mono_lls_pointer_get_mark (__next);
    if (D.17762 == 0) goto <D.17763>; else goto <D.17764>;
    <D.17763>:
    info = __cur;
    D.17765 = MEM[(struct MonoThreadInfo *)info].node.key;
    D.17766 = mono_native_thread_id_equals (D.17765, me);
    if (D.17766 != 0) goto <D.17767>; else goto <D.17768>;
    <D.17767>:
    // predicted unlikely by continue predictor.
    goto <D.17724>;
    <D.17768>:
    D.17769 = info->gc_disabled;
    if (D.17769 != 0) goto <D.17770>; else goto <D.17771>;
    <D.17770>:
    // predicted unlikely by continue predictor.
    goto <D.17724>;
    <D.17771>:
    result = mono_threads_pthread_kill (info, signum);
    if (result == 0) goto <D.17772>; else goto <D.17773>;
    <D.17772>:
    count = count + 1;
    goto <D.17774>;
    <D.17773>:
    info->skip = 1;
    <D.17774>:
    <D.17764>:
    <D.17724>:
    __cur = mono_lls_info_step (__next, __hp);
    <D.17726>:
    if (__cur != 0B) goto <D.17725>; else goto <D.17727>;
    <D.17727>:
    if (0 != 0) goto <D.17775>; else goto <D.17776>;
    <D.17775>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.17776>:
    __hp->hazard_pointers[0] = 0B;
    if (0 != 0) goto <D.17777>; else goto <D.17778>;
    <D.17777>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.17778>:
    __hp->hazard_pointers[1] = 0B;
  }
  sgen_wait_for_suspend_ack (count);
  if (0 != 0) goto <D.17779>; else goto <D.17780>;
  <D.17779>:
  gc_debug_file.4 = gc_debug_file;
  if (suspend != 0) goto <D.17783>; else goto <D.17784>;
  <D.17783>:
  iftmp.5 = "suspend";
  goto <D.17785>;
  <D.17784>:
  iftmp.5 = "resume";
  <D.17785>:
  fprintf (gc_debug_file.4, "%s handshake for %d threads\n\n", iftmp.5, count);
  gc_debug_file.4 = gc_debug_file;
  fflush (gc_debug_file.4);
  <D.17780>:
  D.17786 = count;
  return D.17786;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.17788;
  long unsigned int p.6;
  long unsigned int D.17790;

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


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

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


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

  val = mono_lls_pointer_unmask (val);
  if (0 != 0) goto <D.17795>; else goto <D.17796>;
  <D.17795>:
  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.17796>:
  hp->hazard_pointers[1] = val;
  mono_memory_write_barrier ();
  D.17797 = val;
  return D.17797;
}


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


__attribute__((visibility ("hidden")))
sgen_os_init ()
{
  int suspend_signal_num.8;
  int D.17800;
  int restart_signal_num.9;
  int D.17804;
  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.17800 = sigaction (suspend_signal_num.8, &sinfo, 0B);
      if (D.17800 != 0) goto <D.17801>; else goto <D.17802>;
      <D.17801>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.17732>:
      goto <D.17732>;
      <D.17802>:
      sinfo.__sigaction_handler.sa_handler = restart_handler;
      restart_signal_num.9 = 24;
      D.17804 = sigaction (restart_signal_num.9, &sinfo, 0B);
      if (D.17804 != 0) goto <D.17805>; else goto <D.17806>;
      <D.17805>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.17733>:
      goto <D.17733>;
      <D.17806>:
      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.17807;
  struct FILE * gc_debug_file.10;
  long unsigned int D.17811;
  void * D.17812;
  struct SgenThreadInfo * info;
  int old_errno;

  D.17807 = __errno_location ();
  old_errno = *D.17807;
  info = mono_thread_info_current ();
  info->signal = 24;
  if (0 != 0) goto <D.17808>; else goto <D.17809>;
  <D.17808>:
  gc_debug_file.10 = gc_debug_file;
  D.17811 = mono_native_thread_id_get ();
  D.17812 = (void *) D.17811;
  fprintf (gc_debug_file.10, "Restart handler in %p %p\n", info, D.17812);
  gc_debug_file.10 = gc_debug_file;
  fflush (gc_debug_file.10);
  <D.17809>:
  D.17807 = __errno_location ();
  *D.17807 = old_errno;
}


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

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


suspend_thread (struct SgenThreadInfo * info, void * context)
{
  struct MonoDomain * D.17814;
  void * iftmp.11;
  long unsigned int D.17818;
  unsigned int sgen_global_stop_count.12;
  void * iftmp.13;
  long unsigned int D.17826;
  void * D.17830;
  void * D.17832;
  void * D.17833;
  struct MonoContext * D.17837;
  _Bool D.17839;
  long int D.17840;
  long int D.17841;
  struct MonoGCCallbacks * D.17844;
  void (*<T2bf5>) (void *, void *, struct MonoContext *) D.17845;
  struct MonoGCCallbacks * D.17848;
  void (*<T2bf5>) (void *, void *, struct MonoContext *) D.17849;
  void * D.17850;
  struct FILE * gc_debug_file.14;
  long unsigned int D.17854;
  void * D.17855;
  union MonoSemType * suspend_ack_semaphore_ptr.15;
  unsigned int stop_count.16;
  int D.17858;
  long unsigned int D.17861;
  void * D.17862;
  int stop_count;
  void * stack_start;

  D.17814 = mono_domain_get ();
  info->stopped_domain = D.17814;
  if (context != 0B) goto <D.17816>; else goto <D.17817>;
  <D.17816>:
  D.17818 = MEM[(struct ucontext_t *)context].uc_mcontext.psw.addr;
  iftmp.11 = (void *) D.17818;
  goto <D.17819>;
  <D.17817>:
  iftmp.11 = 0B;
  <D.17819>:
  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.17821>; else goto <D.17822>;
  <D.17821>:
  return;
  <D.17822>:
  if (context != 0B) goto <D.17824>; else goto <D.17825>;
  <D.17824>:
  D.17826 = MEM[(struct ucontext_t *)context].uc_mcontext.gregs[15];
  iftmp.13 = (void *) D.17826;
  goto <D.17827>;
  <D.17825>:
  iftmp.13 = 0B;
  <D.17827>:
  stack_start = iftmp.13;
  D.17830 = info->stack_start_limit;
  if (D.17830 <= stack_start) goto <D.17831>; else goto <D.17828>;
  <D.17831>:
  D.17832 = info->stack_start;
  D.17833 = info->stack_end;
  if (D.17832 <= D.17833) goto <D.17834>; else goto <D.17828>;
  <D.17834>:
  info->stack_start = stack_start;
  if (context != 0B) goto <D.17835>; else goto <D.17836>;
  <D.17835>:
  D.17837 = &info->ctx;
  mono_sigctx_to_monoctx (context, D.17837);
  goto <D.17838>;
  <D.17836>:
  D.17837 = &info->ctx;
  memset (D.17837, 0, 512);
  <D.17838>:
  goto <D.17829>;
  <D.17828>:
  D.17832 = info->stack_start;
  D.17839 = D.17832 != 0B;
  D.17840 = (long int) D.17839;
  D.17841 = __builtin_expect (D.17840, 0);
  if (D.17841 != 0) goto <D.17842>; else goto <D.17843>;
  <D.17842>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 90, "!info->stack_start");
  <D.17843>:
  <D.17829>:
  D.17844 = mono_gc_get_gc_callbacks ();
  D.17845 = D.17844->thread_suspend_func;
  if (D.17845 != 0B) goto <D.17846>; else goto <D.17847>;
  <D.17846>:
  D.17848 = mono_gc_get_gc_callbacks ();
  D.17849 = D.17848->thread_suspend_func;
  D.17850 = info->runtime_data;
  D.17849 (D.17850, context, 0B);
  <D.17847>:
  if (0 != 0) goto <D.17851>; else goto <D.17852>;
  <D.17851>:
  gc_debug_file.14 = gc_debug_file;
  D.17854 = mono_native_thread_id_get ();
  D.17855 = (void *) D.17854;
  fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for suspend from %p %p\n", info, D.17855);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.17852>:
  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.17681>:
  info->signal = 0;
  sigsuspend (&suspend_signal_mask);
  D.17858 = info->signal;
  if (D.17858 != 24) goto <D.17681>; else goto <D.17682>;
  <D.17682>:
  pthread_sigmask (1, &suspend_ack_signal_mask, 0B);
  if (0 != 0) goto <D.17859>; else goto <D.17860>;
  <D.17859>:
  gc_debug_file.14 = gc_debug_file;
  D.17861 = mono_native_thread_id_get ();
  D.17862 = (void *) D.17861;
  fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for resume from %p %p\n\n", info, D.17862);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.17860>:
  suspend_ack_semaphore_ptr.15 = suspend_ack_semaphore_ptr;
  mono_sem_post (suspend_ack_semaphore_ptr.15);
}


__attribute__((__artificial__, __gnu_inline__, __always_inline__, __nothrow__, __leaf__))
memset (void * __dest, int __ch, size_t __len)
{
  void * D.17864;
  long unsigned int D.17865;

  D.17865 = __builtin_object_size (__dest, 0);
  D.17864 = __builtin___memset_chk (__dest, __ch, __len, D.17865);
  return D.17864;
}


__attribute__((visibility ("hidden")))
mono_gc_get_suspend_signal ()
{
  int D.17867;

  D.17867 = 30;
  return D.17867;
}