sgen_resume_thread (struct SgenThreadInfo * info)
{
  gboolean D.19796;
  int restart_signal_num.0;
  int D.19798;
  _Bool D.19799;

  restart_signal_num.0 = 24;
  D.19798 = mono_threads_pthread_kill (info, restart_signal_num.0);
  D.19799 = D.19798 == 0;
  D.19796 = (gboolean) D.19799;
  return D.19796;
}


sgen_suspend_thread (struct SgenThreadInfo * info)
{
  gboolean D.19801;
  int suspend_signal_num.1;
  int D.19803;
  _Bool D.19804;

  suspend_signal_num.1 = 30;
  D.19803 = mono_threads_pthread_kill (info, suspend_signal_num.1);
  D.19804 = D.19803 == 0;
  D.19801 = (gboolean) D.19804;
  return D.19801;
}


sgen_wait_for_suspend_ack (int count)
{
  int * D.19806;
  int D.19807;
  char * D.19810;
  union MonoSemType * suspend_ack_semaphore_ptr.2;
  int i;
  int result;

  i = 0;
  goto <D.19767>;
  <D.19766>:
  goto <D.19764>;
  <D.19763>:
  D.19806 = __errno_location ();
  D.19807 = *D.19806;
  if (D.19807 != 4) goto <D.19808>; else goto <D.19809>;
  <D.19808>:
  D.19806 = __errno_location ();
  D.19807 = *D.19806;
  D.19806 = __errno_location ();
  D.19807 = *D.19806;
  D.19810 = strerror (D.19807);
  monoeg_g_log (0B, 4, "MONO_SEM_WAIT FAILED with %d errno %d (%s)", result, D.19807, D.19810);
  <D.19762>:
  goto <D.19762>;
  <D.19809>:
  <D.19764>:
  suspend_ack_semaphore_ptr.2 = suspend_ack_semaphore_ptr;
  result = mono_sem_wait (suspend_ack_semaphore_ptr.2, 0);
  if (result != 0) goto <D.19763>; else goto <D.19765>;
  <D.19765>:
  i = i + 1;
  <D.19767>:
  if (i < count) goto <D.19766>; else goto <D.19768>;
  <D.19768>:
}


sgen_thread_handshake (BOOL suspend)
{
  const int iftmp.3;
  struct MonoLinkedListSet * D.19816;
  struct MonoLinkedListSetNode * * D.19817;
  void * D.19818;
  struct MonoLinkedListSetNode * * D.19819;
  unsigned int D.19820;
  unsigned int D.19823;
  int D.19824;
  int D.19827;
  struct FILE * gc_debug_file.4;
  const char * iftmp.5;
  int D.19844;
  int count;
  int result;
  struct SgenThreadInfo * info;
  int signum;
  MonoNativeThreadId me;

  if (suspend != 0) goto <D.19813>; else goto <D.19814>;
  <D.19813>:
  iftmp.3 = 30;
  goto <D.19815>;
  <D.19814>:
  iftmp.3 = 24;
  <D.19815>:
  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.19816 = mono_thread_info_list_head ();
    D.19817 = &D.19816->head;
    D.19818 = get_hazardous_pointer (D.19817, __hp, 1);
    __cur = mono_lls_pointer_unmask (D.19818);
    goto <D.19782>;
    <D.19781>:
    D.19819 = &__cur->next;
    __next = get_hazardous_pointer_with_mask (D.19819, __hp, 0);
    D.19820 = mono_lls_pointer_get_mark (__next);
    if (D.19820 == 0) goto <D.19821>; else goto <D.19822>;
    <D.19821>:
    info = __cur;
    D.19823 = MEM[(struct MonoThreadInfo *)info].node.key;
    D.19824 = mono_native_thread_id_equals (D.19823, me);
    if (D.19824 != 0) goto <D.19825>; else goto <D.19826>;
    <D.19825>:
    // predicted unlikely by continue predictor.
    goto <D.19780>;
    <D.19826>:
    D.19827 = info->gc_disabled;
    if (D.19827 != 0) goto <D.19828>; else goto <D.19829>;
    <D.19828>:
    // predicted unlikely by continue predictor.
    goto <D.19780>;
    <D.19829>:
    result = mono_threads_pthread_kill (info, signum);
    if (result == 0) goto <D.19830>; else goto <D.19831>;
    <D.19830>:
    count = count + 1;
    goto <D.19832>;
    <D.19831>:
    info->skip = 1;
    <D.19832>:
    <D.19822>:
    <D.19780>:
    __cur = mono_lls_info_step (__next, __hp);
    <D.19782>:
    if (__cur != 0B) goto <D.19781>; else goto <D.19783>;
    <D.19783>:
    if (0 != 0) goto <D.19833>; else goto <D.19834>;
    <D.19833>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.19834>:
    __hp->hazard_pointers[0] = 0B;
    if (0 != 0) goto <D.19835>; else goto <D.19836>;
    <D.19835>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.19836>:
    __hp->hazard_pointers[1] = 0B;
  }
  sgen_wait_for_suspend_ack (count);
  if (0 != 0) goto <D.19837>; else goto <D.19838>;
  <D.19837>:
  gc_debug_file.4 = gc_debug_file;
  if (suspend != 0) goto <D.19841>; else goto <D.19842>;
  <D.19841>:
  iftmp.5 = "suspend";
  goto <D.19843>;
  <D.19842>:
  iftmp.5 = "resume";
  <D.19843>:
  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.19838>:
  D.19844 = count;
  return D.19844;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.19846;
  unsigned int p.6;
  unsigned int D.19848;

  p.6 = (unsigned int) p;
  D.19848 = p.6 & 4294967292;
  D.19846 = (void *) D.19848;
  return D.19846;
}


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

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


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

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


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


sgen_os_init ()
{
  int suspend_signal_num.8;
  int D.19858;
  int restart_signal_num.9;
  int D.19862;
  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.19858 = sigaction (suspend_signal_num.8, &sinfo, 0B);
      if (D.19858 != 0) goto <D.19859>; else goto <D.19860>;
      <D.19859>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.19788>:
      goto <D.19788>;
      <D.19860>:
      sinfo.__sigaction_handler.sa_handler = restart_handler;
      restart_signal_num.9 = 24;
      D.19862 = sigaction (restart_signal_num.9, &sinfo, 0B);
      if (D.19862 != 0) goto <D.19863>; else goto <D.19864>;
      <D.19863>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.19789>:
      goto <D.19789>;
      <D.19864>:
      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.19865;
  struct FILE * gc_debug_file.10;
  long unsigned int D.19869;
  void * D.19870;
  struct SgenThreadInfo * info;
  int old_errno;

  D.19865 = __errno_location ();
  old_errno = *D.19865;
  info = mono_thread_info_current ();
  info->signal = 24;
  if (0 != 0) goto <D.19866>; else goto <D.19867>;
  <D.19866>:
  gc_debug_file.10 = gc_debug_file;
  D.19869 = mono_native_thread_id_get ();
  D.19870 = (void *) D.19869;
  fprintf (gc_debug_file.10, "Restart handler in %p %p\n", info, D.19870);
  gc_debug_file.10 = gc_debug_file;
  fflush (gc_debug_file.10);
  <D.19867>:
  D.19865 = __errno_location ();
  *D.19865 = old_errno;
}


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

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


suspend_thread (struct SgenThreadInfo * info, void * context)
{
  struct MonoDomain * D.19872;
  void * iftmp.11;
  long unsigned int D.19876;
  unsigned int sgen_global_stop_count.12;
  void * iftmp.13;
  long unsigned int D.19884;
  void * D.19888;
  void * D.19890;
  void * D.19891;
  struct MonoContext * D.19895;
  _Bool D.19897;
  long int D.19898;
  long int D.19899;
  struct MonoGCCallbacks * D.19902;
  void (*<T3470>) (void *, void *, struct MonoContext *) D.19903;
  struct MonoGCCallbacks * D.19906;
  void (*<T3470>) (void *, void *, struct MonoContext *) D.19907;
  void * D.19908;
  struct FILE * gc_debug_file.14;
  long unsigned int D.19912;
  void * D.19913;
  union MonoSemType * suspend_ack_semaphore_ptr.15;
  unsigned int stop_count.16;
  int D.19916;
  long unsigned int D.19919;
  void * D.19920;
  int stop_count;
  void * stack_start;

  D.19872 = mono_domain_get ();
  info->stopped_domain = D.19872;
  if (context != 0B) goto <D.19874>; else goto <D.19875>;
  <D.19874>:
  D.19876 = MEM[(struct arm_ucontext *)context].sig_ctx.arm_pc;
  iftmp.11 = (void *) D.19876;
  goto <D.19877>;
  <D.19875>:
  iftmp.11 = 0B;
  <D.19877>:
  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.19879>; else goto <D.19880>;
  <D.19879>:
  return;
  <D.19880>:
  if (context != 0B) goto <D.19882>; else goto <D.19883>;
  <D.19882>:
  D.19884 = MEM[(struct arm_ucontext *)context].sig_ctx.arm_sp;
  iftmp.13 = (void *) D.19884;
  goto <D.19885>;
  <D.19883>:
  iftmp.13 = 0B;
  <D.19885>:
  stack_start = iftmp.13;
  D.19888 = info->stack_start_limit;
  if (D.19888 <= stack_start) goto <D.19889>; else goto <D.19886>;
  <D.19889>:
  D.19890 = info->stack_start;
  D.19891 = info->stack_end;
  if (D.19890 <= D.19891) goto <D.19892>; else goto <D.19886>;
  <D.19892>:
  info->stack_start = stack_start;
  if (context != 0B) goto <D.19893>; else goto <D.19894>;
  <D.19893>:
  D.19895 = &info->ctx;
  mono_sigctx_to_monoctx (context, D.19895);
  goto <D.19896>;
  <D.19894>:
  D.19895 = &info->ctx;
  memset (D.19895, 0, 208);
  <D.19896>:
  goto <D.19887>;
  <D.19886>:
  D.19890 = info->stack_start;
  D.19897 = D.19890 != 0B;
  D.19898 = (long int) D.19897;
  D.19899 = __builtin_expect (D.19898, 0);
  if (D.19899 != 0) goto <D.19900>; else goto <D.19901>;
  <D.19900>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 90, "!info->stack_start");
  <D.19901>:
  <D.19887>:
  D.19902 = mono_gc_get_gc_callbacks ();
  D.19903 = D.19902->thread_suspend_func;
  if (D.19903 != 0B) goto <D.19904>; else goto <D.19905>;
  <D.19904>:
  D.19906 = mono_gc_get_gc_callbacks ();
  D.19907 = D.19906->thread_suspend_func;
  D.19908 = info->runtime_data;
  D.19907 (D.19908, context, 0B);
  <D.19905>:
  if (0 != 0) goto <D.19909>; else goto <D.19910>;
  <D.19909>:
  gc_debug_file.14 = gc_debug_file;
  D.19912 = mono_native_thread_id_get ();
  D.19913 = (void *) D.19912;
  fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for suspend from %p %p\n", info, D.19913);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.19910>:
  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.19737>:
  info->signal = 0;
  sigsuspend (&suspend_signal_mask);
  D.19916 = info->signal;
  if (D.19916 != 24) goto <D.19737>; else goto <D.19738>;
  <D.19738>:
  pthread_sigmask (1, &suspend_ack_signal_mask, 0B);
  if (0 != 0) goto <D.19917>; else goto <D.19918>;
  <D.19917>:
  gc_debug_file.14 = gc_debug_file;
  D.19919 = mono_native_thread_id_get ();
  D.19920 = (void *) D.19919;
  fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for resume from %p %p\n\n", info, D.19920);
  gc_debug_file.14 = gc_debug_file;
  fflush (gc_debug_file.14);
  <D.19918>:
  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.19924;
  int D.19929;
  void * D.19931;
  unsigned int D.19932;

  D.19924 = __builtin_constant_p (__len);
  if (D.19924 != 0) goto <D.19925>; else goto <D.19926>;
  <D.19925>:
  if (__len == 0) goto <D.19927>; else goto <D.19928>;
  <D.19927>:
  D.19929 = __builtin_constant_p (__ch);
  if (D.19929 == 0) goto <D.19922>; else goto <D.19930>;
  <D.19930>:
  if (__ch != 0) goto <D.19922>; else goto <D.19923>;
  <D.19922>:
  __warn_memset_zero_len ();
  D.19931 = __dest;
  return D.19931;
  <D.19923>:
  <D.19928>:
  <D.19926>:
  D.19932 = __builtin_object_size (__dest, 0);
  D.19931 = __builtin___memset_chk (__dest, __ch, __len, D.19932);
  return D.19931;
}


mono_gc_get_suspend_signal ()
{
  int D.19934;

  D.19934 = 30;
  return D.19934;
}