sgen_resume_thread (struct SgenThreadInfo * info)
{
  gboolean D.18129;
  int restart_signal_num.0;
  int D.18131;
  _Bool D.18132;

  restart_signal_num.0 = 24;
  D.18131 = mono_threads_pthread_kill (info, restart_signal_num.0);
  D.18132 = D.18131 == 0;
  D.18129 = (gboolean) D.18132;
  return D.18129;
}


sgen_suspend_thread (struct SgenThreadInfo * info)
{
  gboolean D.18134;
  int suspend_signal_num.1;
  int D.18136;
  _Bool D.18137;

  suspend_signal_num.1 = 30;
  D.18136 = mono_threads_pthread_kill (info, suspend_signal_num.1);
  D.18137 = D.18136 == 0;
  D.18134 = (gboolean) D.18137;
  return D.18134;
}


sgen_wait_for_suspend_ack (int count)
{
  int * D.18139;
  int D.18140;
  char * D.18143;
  union MonoSemType * suspend_ack_semaphore_ptr.2;
  int i;
  int result;

  i = 0;
  goto <D.18102>;
  <D.18101>:
  goto <D.18099>;
  <D.18098>:
  D.18139 = __errno_location ();
  D.18140 = *D.18139;
  if (D.18140 != 4) goto <D.18141>; else goto <D.18142>;
  <D.18141>:
  D.18139 = __errno_location ();
  D.18140 = *D.18139;
  D.18139 = __errno_location ();
  D.18140 = *D.18139;
  D.18143 = strerror (D.18140);
  monoeg_g_log (0B, 4, "MONO_SEM_WAIT FAILED with %d errno %d (%s)", result, D.18140, D.18143);
  <D.18097>:
  goto <D.18097>;
  <D.18142>:
  <D.18099>:
  suspend_ack_semaphore_ptr.2 = suspend_ack_semaphore_ptr;
  result = mono_sem_wait (suspend_ack_semaphore_ptr.2, 0);
  if (result != 0) goto <D.18098>; else goto <D.18100>;
  <D.18100>:
  i = i + 1;
  <D.18102>:
  if (i < count) goto <D.18101>; else goto <D.18103>;
  <D.18103>:
}


sgen_thread_handshake (BOOL suspend)
{
  const int iftmp.3;
  struct MonoLinkedListSet * D.18149;
  struct MonoLinkedListSetNode * * D.18150;
  void * D.18151;
  struct MonoLinkedListSetNode * * D.18152;
  long unsigned int D.18153;
  long unsigned int D.18156;
  int D.18157;
  int D.18160;
  struct FILE * gc_debug_file.4;
  const char * iftmp.5;
  int D.18177;
  int count;
  int result;
  struct SgenThreadInfo * info;
  int signum;
  MonoNativeThreadId me;

  if (suspend != 0) goto <D.18146>; else goto <D.18147>;
  <D.18146>:
  iftmp.3 = 30;
  goto <D.18148>;
  <D.18147>:
  iftmp.3 = 24;
  <D.18148>:
  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.18149 = mono_thread_info_list_head ();
    D.18150 = &D.18149->head;
    D.18151 = get_hazardous_pointer (D.18150, __hp, 1);
    __cur = mono_lls_pointer_unmask (D.18151);
    goto <D.18117>;
    <D.18116>:
    D.18152 = &__cur->next;
    __next = get_hazardous_pointer_with_mask (D.18152, __hp, 0);
    D.18153 = mono_lls_pointer_get_mark (__next);
    if (D.18153 == 0) goto <D.18154>; else goto <D.18155>;
    <D.18154>:
    info = __cur;
    D.18156 = MEM[(struct MonoThreadInfo *)info].node.key;
    D.18157 = mono_native_thread_id_equals (D.18156, me);
    if (D.18157 != 0) goto <D.18158>; else goto <D.18159>;
    <D.18158>:
    // predicted unlikely by continue predictor.
    goto <D.18115>;
    <D.18159>:
    D.18160 = info->gc_disabled;
    if (D.18160 != 0) goto <D.18161>; else goto <D.18162>;
    <D.18161>:
    // predicted unlikely by continue predictor.
    goto <D.18115>;
    <D.18162>:
    result = mono_threads_pthread_kill (info, signum);
    if (result == 0) goto <D.18163>; else goto <D.18164>;
    <D.18163>:
    count = count + 1;
    goto <D.18165>;
    <D.18164>:
    info->skip = 1;
    <D.18165>:
    <D.18155>:
    <D.18115>:
    __cur = mono_lls_info_step (__next, __hp);
    <D.18117>:
    if (__cur != 0B) goto <D.18116>; else goto <D.18118>;
    <D.18118>:
    if (0 != 0) goto <D.18166>; else goto <D.18167>;
    <D.18166>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(0) >= 0 && (0) < HAZARD_POINTER_COUNT");
    <D.18167>:
    __hp->hazard_pointers[0] = 0B;
    if (0 != 0) goto <D.18168>; else goto <D.18169>;
    <D.18168>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 197, "(1) >= 0 && (1) < HAZARD_POINTER_COUNT");
    <D.18169>:
    __hp->hazard_pointers[1] = 0B;
  }
  sgen_wait_for_suspend_ack (count);
  if (0 != 0) goto <D.18170>; else goto <D.18171>;
  <D.18170>:
  gc_debug_file.4 = gc_debug_file;
  if (suspend != 0) goto <D.18174>; else goto <D.18175>;
  <D.18174>:
  iftmp.5 = "suspend";
  goto <D.18176>;
  <D.18175>:
  iftmp.5 = "resume";
  <D.18176>:
  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.18171>:
  D.18177 = count;
  return D.18177;
}


mono_lls_pointer_unmask (void * p)
{
  void * D.18179;
  long unsigned int p.6;
  long unsigned int D.18181;

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


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

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


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

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


mono_memory_write_barrier ()
{
  mono_memory_barrier ();
}


mono_memory_barrier ()
{
  __sync_synchronize ();
}


sgen_os_init ()
{
  int suspend_signal_num.8;
  int D.18191;
  int restart_signal_num.9;
  int D.18195;
  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.18191 = sigaction (suspend_signal_num.8, &sinfo, 0B);
      if (D.18191 != 0) goto <D.18192>; else goto <D.18193>;
      <D.18192>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.18123>:
      goto <D.18123>;
      <D.18193>:
      sinfo.__sigaction_handler.sa_handler = restart_handler;
      restart_signal_num.9 = 24;
      D.18195 = sigaction (restart_signal_num.9, &sinfo, 0B);
      if (D.18195 != 0) goto <D.18196>; else goto <D.18197>;
      <D.18196>:
      monoeg_g_log (0B, 4, "failed sigaction");
      <D.18124>:
      goto <D.18124>;
      <D.18197>:
      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.18198;
  struct FILE * gc_debug_file.10;
  long unsigned int D.18202;
  void * D.18203;
  struct SgenThreadInfo * info;
  int old_errno;

  D.18198 = __errno_location ();
  old_errno = *D.18198;
  info = mono_thread_info_current ();
  info->signal = 24;
  if (0 != 0) goto <D.18199>; else goto <D.18200>;
  <D.18199>:
  gc_debug_file.10 = gc_debug_file;
  D.18202 = mono_native_thread_id_get ();
  D.18203 = (void *) D.18202;
  fprintf (gc_debug_file.10, "Restart handler in %p %p\n", info, D.18203);
  gc_debug_file.10 = gc_debug_file;
  fflush (gc_debug_file.10);
  <D.18200>:
  D.18198 = __errno_location ();
  *D.18198 = old_errno;
}


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

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


suspend_thread (struct SgenThreadInfo * info, void * context)
{
  struct MonoDomain * D.18205;
  void * iftmp.11;
  long unsigned int D.18209;
  unsigned int sgen_global_stop_count.12;
  void * iftmp.13;
  long unsigned int D.18217;
  sizetype D.18218;
  void * D.18222;
  void * D.18224;
  void * D.18225;
  long unsigned int D.18229;
  void * D.18230;
  void *[32] * D.18231;
  _Bool D.18233;
  long int D.18234;
  long int D.18235;
  struct MonoGCCallbacks * D.18238;
  void (*<T2b39>) (void *, void *, struct MonoContext *) D.18239;
  struct MonoGCCallbacks * D.18242;
  void (*<T2b39>) (void *, void *, struct MonoContext *) D.18243;
  void * D.18244;
  struct FILE * gc_debug_file.14;
  long unsigned int D.18248;
  void * D.18249;
  union MonoSemType * suspend_ack_semaphore_ptr.15;
  unsigned int stop_count.16;
  int D.18252;
  long unsigned int D.18255;
  void * D.18256;
  int stop_count;
  void * regs[32];
  void * stack_start;

  try
    {
      D.18205 = mono_domain_get ();
      info->stopped_domain = D.18205;
      if (context != 0B) goto <D.18207>; else goto <D.18208>;
      <D.18207>:
      D.18209 = MEM[(struct os_ucontext *)context].uc_mcontext.gp_regs[32];
      iftmp.11 = (void *) D.18209;
      goto <D.18210>;
      <D.18208>:
      iftmp.11 = 0B;
      <D.18210>:
      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.18212>; else goto <D.18213>;
      <D.18212>:
      return;
      <D.18213>:
      if (context != 0B) goto <D.18215>; else goto <D.18216>;
      <D.18215>:
      D.18217 = MEM[(struct os_ucontext *)context].uc_mcontext.gp_regs[1];
      D.18218 = D.18217 + 18446744073709551392;
      iftmp.13 = (void *) D.18218;
      goto <D.18219>;
      <D.18216>:
      iftmp.13 = 0B;
      <D.18219>:
      stack_start = iftmp.13;
      D.18222 = info->stack_start_limit;
      if (D.18222 <= stack_start) goto <D.18223>; else goto <D.18220>;
      <D.18223>:
      D.18224 = info->stack_start;
      D.18225 = info->stack_end;
      if (D.18224 <= D.18225) goto <D.18226>; else goto <D.18220>;
      <D.18226>:
      info->stack_start = stack_start;
      if (context != 0B) goto <D.18227>; else goto <D.18228>;
      <D.18227>:
      {
        int __i;

        __i = 0;
        goto <D.18070>;
        <D.18069>:
        D.18229 = MEM[(struct os_ucontext *)context].uc_mcontext.gp_regs[__i];
        D.18230 = (void *) D.18229;
        regs[__i] = D.18230;
        __i = __i + 1;
        <D.18070>:
        if (__i <= 31) goto <D.18069>; else goto <D.18071>;
        <D.18071>:
      }
      D.18231 = &info->regs;
      memcpy (D.18231, &regs, 256);
      goto <D.18232>;
      <D.18228>:
      D.18231 = &info->regs;
      memset (D.18231, 0, 256);
      <D.18232>:
      goto <D.18221>;
      <D.18220>:
      D.18224 = info->stack_start;
      D.18233 = D.18224 != 0B;
      D.18234 = (long int) D.18233;
      D.18235 = __builtin_expect (D.18234, 0);
      if (D.18235 != 0) goto <D.18236>; else goto <D.18237>;
      <D.18236>:
      monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "sgen-os-posix.c", 90, "!info->stack_start");
      <D.18237>:
      <D.18221>:
      D.18238 = mono_gc_get_gc_callbacks ();
      D.18239 = D.18238->thread_suspend_func;
      if (D.18239 != 0B) goto <D.18240>; else goto <D.18241>;
      <D.18240>:
      D.18242 = mono_gc_get_gc_callbacks ();
      D.18243 = D.18242->thread_suspend_func;
      D.18244 = info->runtime_data;
      D.18243 (D.18244, context, 0B);
      <D.18241>:
      if (0 != 0) goto <D.18245>; else goto <D.18246>;
      <D.18245>:
      gc_debug_file.14 = gc_debug_file;
      D.18248 = mono_native_thread_id_get ();
      D.18249 = (void *) D.18248;
      fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for suspend from %p %p\n", info, D.18249);
      gc_debug_file.14 = gc_debug_file;
      fflush (gc_debug_file.14);
      <D.18246>:
      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.18072>:
      info->signal = 0;
      sigsuspend (&suspend_signal_mask);
      D.18252 = info->signal;
      if (D.18252 != 24) goto <D.18072>; else goto <D.18073>;
      <D.18073>:
      pthread_sigmask (1, &suspend_ack_signal_mask, 0B);
      if (0 != 0) goto <D.18253>; else goto <D.18254>;
      <D.18253>:
      gc_debug_file.14 = gc_debug_file;
      D.18255 = mono_native_thread_id_get ();
      D.18256 = (void *) D.18255;
      fprintf (gc_debug_file.14, "Posting suspend_ack_semaphore for resume from %p %p\n\n", info, D.18256);
      gc_debug_file.14 = gc_debug_file;
      fflush (gc_debug_file.14);
      <D.18254>:
      suspend_ack_semaphore_ptr.15 = suspend_ack_semaphore_ptr;
      mono_sem_post (suspend_ack_semaphore_ptr.15);
    }
  finally
    {
      regs = {CLOBBER};
    }
}


memcpy (void * restrict __dest, const void * restrict __src, size_t __len)
{
  void * D.18260;
  long unsigned int D.18261;

  D.18261 = __builtin_object_size (__dest, 0);
  D.18260 = __builtin___memcpy_chk (__dest, __src, __len, D.18261);
  return D.18260;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.18265;
  int D.18270;
  void * D.18272;
  long unsigned int D.18273;

  D.18265 = __builtin_constant_p (__len);
  if (D.18265 != 0) goto <D.18266>; else goto <D.18267>;
  <D.18266>:
  if (__len == 0) goto <D.18268>; else goto <D.18269>;
  <D.18268>:
  D.18270 = __builtin_constant_p (__ch);
  if (D.18270 == 0) goto <D.18263>; else goto <D.18271>;
  <D.18271>:
  if (__ch != 0) goto <D.18263>; else goto <D.18264>;
  <D.18263>:
  __warn_memset_zero_len ();
  D.18272 = __dest;
  return D.18272;
  <D.18264>:
  <D.18269>:
  <D.18267>:
  D.18273 = __builtin_object_size (__dest, 0);
  D.18272 = __builtin___memset_chk (__dest, __ch, __len, D.18273);
  return D.18272;
}


mono_gc_get_suspend_signal ()
{
  int D.18275;

  D.18275 = 30;
  return D.18275;
}