GC_print_static_roots ()
{
  char * D.6167;
  long int D.6168;
  char * D.6169;
  long int D.6170;
  int D.6171;
  long int D.6175;
  long int D.6176;
  long int D.6177;
  long unsigned int D.6178;
  int n_root_sets.0;
  long int total.1;
  long unsigned int GC_root_size.2;
  long int GC_root_size.3;
  register int i;
  size_t total;

  total = 0;
  i = 0;
  goto <D.6037>;
  <D.6036>:
  D.6167 = GC_arrays._static_roots[i].r_start;
  D.6168 = (long int) D.6167;
  D.6169 = GC_arrays._static_roots[i].r_end;
  D.6170 = (long int) D.6169;
  GC_printf ("From 0x%lx to 0x%lx ", D.6168, D.6170, 0, 0, 0, 0);
  D.6171 = GC_arrays._static_roots[i].r_tmp;
  if (D.6171 != 0) goto <D.6172>; else goto <D.6173>;
  <D.6172>:
  GC_printf (" (temporary)\n", 0, 0, 0, 0, 0, 0);
  goto <D.6174>;
  <D.6173>:
  GC_printf ("\n", 0, 0, 0, 0, 0, 0);
  <D.6174>:
  D.6169 = GC_arrays._static_roots[i].r_end;
  D.6175 = (long int) D.6169;
  D.6167 = GC_arrays._static_roots[i].r_start;
  D.6176 = (long int) D.6167;
  D.6177 = D.6175 - D.6176;
  D.6178 = (long unsigned int) D.6177;
  total = D.6178 + total;
  i = i + 1;
  <D.6037>:
  n_root_sets.0 = n_root_sets;
  if (i < n_root_sets.0) goto <D.6036>; else goto <D.6038>;
  <D.6038>:
  total.1 = (long int) total;
  GC_printf ("Total size: %ld\n", total.1, 0, 0, 0, 0, 0);
  GC_root_size.2 = GC_root_size;
  if (GC_root_size.2 != total) goto <D.6182>; else goto <D.6183>;
  <D.6182>:
  GC_root_size.2 = GC_root_size;
  GC_root_size.3 = (long int) GC_root_size.2;
  GC_printf ("GC_root_size incorrect: %ld!!\n", GC_root_size.3, 0, 0, 0, 0, 0);
  <D.6183>:
}


GC_is_static_root (char * p)
{
  int last_root_set.4;
  int n_root_sets.5;
  char * D.6189;
  char * D.6192;
  GC_bool D.6195;
  char * D.6196;
  char * D.6199;
  static int last_root_set = 1024;
  register int i;

  last_root_set.4 = last_root_set;
  n_root_sets.5 = n_root_sets;
  if (last_root_set.4 < n_root_sets.5) goto <D.6187>; else goto <D.6188>;
  <D.6187>:
  last_root_set.4 = last_root_set;
  D.6189 = GC_arrays._static_roots[last_root_set.4].r_start;
  if (D.6189 <= p) goto <D.6190>; else goto <D.6191>;
  <D.6190>:
  last_root_set.4 = last_root_set;
  D.6192 = GC_arrays._static_roots[last_root_set.4].r_end;
  if (D.6192 > p) goto <D.6193>; else goto <D.6194>;
  <D.6193>:
  D.6195 = 1;
  return D.6195;
  <D.6194>:
  <D.6191>:
  <D.6188>:
  i = 0;
  goto <D.6045>;
  <D.6044>:
  D.6196 = GC_arrays._static_roots[i].r_start;
  if (D.6196 <= p) goto <D.6197>; else goto <D.6198>;
  <D.6197>:
  D.6199 = GC_arrays._static_roots[i].r_end;
  if (D.6199 > p) goto <D.6200>; else goto <D.6201>;
  <D.6200>:
  last_root_set = i;
  D.6195 = 1;
  return D.6195;
  <D.6201>:
  <D.6198>:
  i = i + 1;
  <D.6045>:
  n_root_sets.5 = n_root_sets;
  if (i < n_root_sets.5) goto <D.6044>; else goto <D.6046>;
  <D.6046>:
  D.6195 = 0;
  return D.6195;
}


GC_roots_present (char * b)
{
  char * D.6203;
  struct roots * D.6206;
  register int h;
  register struct roots * p;

  h = rt_hash (b);
  p = GC_arrays._root_index[h];
  goto <D.6057>;
  <D.6056>:
  D.6203 = p->r_start;
  if (D.6203 == b) goto <D.6204>; else goto <D.6205>;
  <D.6204>:
  D.6206 = p;
  return D.6206;
  <D.6205>:
  p = p->r_next;
  <D.6057>:
  if (p != 0B) goto <D.6056>; else goto <D.6058>;
  <D.6058>:
  D.6206 = 0B;
  return D.6206;
}


rt_hash (char * addr)
{
  long unsigned int D.6208;
  long unsigned int D.6209;
  long unsigned int D.6210;
  long unsigned int D.6211;
  int D.6212;
  word result;

  result = (word) addr;
  D.6208 = result >> 48;
  result = D.6208 ^ result;
  D.6209 = result >> 24;
  result = D.6209 ^ result;
  D.6210 = result >> 12;
  result = D.6210 ^ result;
  D.6211 = result >> 6;
  result = D.6211 ^ result;
  result = result & 63;
  D.6212 = (int) result;
  return D.6212;
}


GC_add_roots (char * b, char * e)
{
  int D.6214;

  D.6214 = GC_test_and_set (&GC_allocate_lock);
  if (D.6214 != 0) goto <D.6215>; else goto <D.6216>;
  <D.6215>:
  GC_lock ();
  <D.6216>:
  GC_add_roots_inner (b, e, 0);
  GC_clear (&GC_allocate_lock);
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.6217;
  int oldval;
  int temp;

  temp = 1;
  __asm__ __volatile__("1:	lwarx %0,0,%1
	cmpwi %0, 0
	bne 2f
	stwcx. %2,0,%1
	bne- 1b
	sync
2:	
" : "=&r" oldval : "r" addr, "r" temp : "memory", "cr0");
  D.6217 = oldval;
  return D.6217;
}


GC_clear (volatile unsigned int * addr)
{
  __asm__ __volatile__("lwsync" :  :  : "memory");
  *addr = 0;
}


GC_add_roots_inner (char * b, char * e, GC_bool tmp)
{
  char * D.6221;
  long int e.6;
  long int D.6225;
  long int D.6226;
  long unsigned int D.6227;
  long unsigned int GC_root_size.7;
  long unsigned int GC_root_size.8;
  int n_root_sets.9;
  sizetype D.6233;
  struct roots * D.6234;
  long int b.10;
  long int D.6236;
  long unsigned int D.6237;
  long unsigned int GC_root_size.11;
  int n_root_sets.12;
  struct roots * old;

  old = GC_roots_present (b);
  if (old != 0B) goto <D.6219>; else goto <D.6220>;
  <D.6219>:
  D.6221 = old->r_end;
  if (D.6221 >= e) goto <D.6222>; else goto <D.6223>;
  <D.6222>:
  return;
  <D.6223>:
  e.6 = (long int) e;
  D.6221 = old->r_end;
  D.6225 = (long int) D.6221;
  D.6226 = e.6 - D.6225;
  D.6227 = (long unsigned int) D.6226;
  GC_root_size.7 = GC_root_size;
  GC_root_size.8 = D.6227 + GC_root_size.7;
  GC_root_size = GC_root_size.8;
  old->r_end = e;
  return;
  <D.6220>:
  n_root_sets.9 = n_root_sets;
  if (n_root_sets.9 == 1024) goto <D.6231>; else goto <D.6232>;
  <D.6231>:
  GC_abort ("Too many root sets\n");
  <D.6232>:
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_start = b;
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_end = e;
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_tmp = tmp;
  n_root_sets.9 = n_root_sets;
  GC_arrays._static_roots[n_root_sets.9].r_next = 0B;
  n_root_sets.9 = n_root_sets;
  D.6233 = (sizetype) n_root_sets.9;
  D.6234 = &GC_arrays._static_roots[D.6233];
  add_roots_to_index (D.6234);
  e.6 = (long int) e;
  b.10 = (long int) b;
  D.6236 = e.6 - b.10;
  D.6237 = (long unsigned int) D.6236;
  GC_root_size.7 = GC_root_size;
  GC_root_size.11 = D.6237 + GC_root_size.7;
  GC_root_size = GC_root_size.11;
  n_root_sets.9 = n_root_sets;
  n_root_sets.12 = n_root_sets.9 + 1;
  n_root_sets = n_root_sets.12;
}


add_roots_to_index (struct roots * p)
{
  char * D.6241;
  struct roots * D.6242;
  register int h;

  D.6241 = p->r_start;
  h = rt_hash (D.6241);
  D.6242 = GC_arrays._root_index[h];
  p->r_next = D.6242;
  GC_arrays._root_index[h] = p;
}


GC_clear_roots ()
{
  int D.6243;

  D.6243 = GC_test_and_set (&GC_allocate_lock);
  if (D.6243 != 0) goto <D.6244>; else goto <D.6245>;
  <D.6244>:
  GC_lock ();
  <D.6245>:
  roots_were_cleared = 1;
  n_root_sets = 0;
  GC_root_size = 0;
  {
    register int i;

    i = 0;
    goto <D.6080>;
    <D.6079>:
    GC_arrays._root_index[i] = 0B;
    i = i + 1;
    <D.6080>:
    if (i <= 63) goto <D.6079>; else goto <D.6081>;
    <D.6081>:
  }
  GC_clear (&GC_allocate_lock);
}


GC_remove_tmp_roots ()
{
  int D.6246;
  int n_root_sets.13;
  register int i;

  i = 0;
  goto <D.6098>;
  <D.6097>:
  D.6246 = GC_arrays._static_roots[i].r_tmp;
  if (D.6246 != 0) goto <D.6247>; else goto <D.6248>;
  <D.6247>:
  GC_remove_root_at_pos (i);
  goto <D.6249>;
  <D.6248>:
  i = i + 1;
  <D.6249>:
  <D.6098>:
  n_root_sets.13 = n_root_sets;
  if (i < n_root_sets.13) goto <D.6097>; else goto <D.6099>;
  <D.6099>:
  GC_rebuild_root_index ();
}


GC_remove_root_at_pos (int i)
{
  char * D.6251;
  long int D.6252;
  char * D.6253;
  long int D.6254;
  long int D.6255;
  long unsigned int D.6256;
  long unsigned int GC_root_size.14;
  long unsigned int GC_root_size.15;
  int n_root_sets.16;
  int n_root_sets.17;
  char * D.6261;
  char * D.6262;
  int D.6263;

  D.6251 = GC_arrays._static_roots[i].r_start;
  D.6252 = (long int) D.6251;
  D.6253 = GC_arrays._static_roots[i].r_end;
  D.6254 = (long int) D.6253;
  D.6255 = D.6252 - D.6254;
  D.6256 = (long unsigned int) D.6255;
  GC_root_size.14 = GC_root_size;
  GC_root_size.15 = D.6256 + GC_root_size.14;
  GC_root_size = GC_root_size.15;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  D.6261 = GC_arrays._static_roots[n_root_sets.17].r_start;
  GC_arrays._static_roots[i].r_start = D.6261;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  D.6262 = GC_arrays._static_roots[n_root_sets.17].r_end;
  GC_arrays._static_roots[i].r_end = D.6262;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  D.6263 = GC_arrays._static_roots[n_root_sets.17].r_tmp;
  GC_arrays._static_roots[i].r_tmp = D.6263;
  n_root_sets.16 = n_root_sets;
  n_root_sets.17 = n_root_sets.16 + -1;
  n_root_sets = n_root_sets.17;
}


GC_rebuild_root_index ()
{
  sizetype D.6264;
  struct roots * D.6265;
  int n_root_sets.18;
  register int i;

  i = 0;
  goto <D.6089>;
  <D.6088>:
  GC_arrays._root_index[i] = 0B;
  i = i + 1;
  <D.6089>:
  if (i <= 63) goto <D.6088>; else goto <D.6090>;
  <D.6090>:
  i = 0;
  goto <D.6092>;
  <D.6091>:
  D.6264 = (sizetype) i;
  D.6265 = &GC_arrays._static_roots[D.6264];
  add_roots_to_index (D.6265);
  i = i + 1;
  <D.6092>:
  n_root_sets.18 = n_root_sets;
  if (i < n_root_sets.18) goto <D.6091>; else goto <D.6093>;
  <D.6093>:
}


GC_remove_roots (char * b, char * e)
{
  int D.6267;

  D.6267 = GC_test_and_set (&GC_allocate_lock);
  if (D.6267 != 0) goto <D.6268>; else goto <D.6269>;
  <D.6268>:
  GC_lock ();
  <D.6269>:
  GC_remove_roots_inner (b, e);
  GC_clear (&GC_allocate_lock);
}


GC_remove_roots_inner (char * b, char * e)
{
  char * D.6272;
  char * D.6274;
  int n_root_sets.19;
  int i;

  i = 0;
  goto <D.6110>;
  <D.6109>:
  D.6272 = GC_arrays._static_roots[i].r_start;
  if (D.6272 >= b) goto <D.6273>; else goto <D.6270>;
  <D.6273>:
  D.6274 = GC_arrays._static_roots[i].r_end;
  if (D.6274 <= e) goto <D.6275>; else goto <D.6270>;
  <D.6275>:
  GC_remove_root_at_pos (i);
  goto <D.6271>;
  <D.6270>:
  i = i + 1;
  <D.6271>:
  <D.6110>:
  n_root_sets.19 = n_root_sets;
  if (i < n_root_sets.19) goto <D.6109>; else goto <D.6111>;
  <D.6111>:
  GC_rebuild_root_index ();
}


GC_approx_sp ()
{
  char * D.6277;
  volatile word dummy;

  dummy = 42;
  D.6277 = &dummy;
  return D.6277;
}


GC_next_exclusion (char * start_addr)
{
  long unsigned int GC_excl_table_entries.20;
  long unsigned int D.6280;
  char * D.6281;
  long unsigned int D.6282;
  long unsigned int start_addr.21;
  char * D.6287;
  long unsigned int D.6288;
  struct exclusion * D.6291;
  size_t low;
  size_t high;
  size_t mid;

  low = 0;
  GC_excl_table_entries.20 = GC_excl_table_entries;
  high = GC_excl_table_entries.20 + 18446744073709551615;
  goto <D.6123>;
  <D.6122>:
  D.6280 = low + high;
  mid = D.6280 >> 1;
  D.6281 = GC_arrays._excl_table[mid].e_end;
  D.6282 = (long unsigned int) D.6281;
  start_addr.21 = (long unsigned int) start_addr;
  if (D.6282 <= start_addr.21) goto <D.6284>; else goto <D.6285>;
  <D.6284>:
  low = mid + 1;
  goto <D.6286>;
  <D.6285>:
  high = mid;
  <D.6286>:
  <D.6123>:
  if (high > low) goto <D.6122>; else goto <D.6124>;
  <D.6124>:
  D.6287 = GC_arrays._excl_table[low].e_end;
  D.6288 = (long unsigned int) D.6287;
  start_addr.21 = (long unsigned int) start_addr;
  if (D.6288 <= start_addr.21) goto <D.6289>; else goto <D.6290>;
  <D.6289>:
  D.6291 = 0B;
  return D.6291;
  <D.6290>:
  D.6291 = &GC_arrays._excl_table[low];
  return D.6291;
}


GC_exclude_static_roots (void * start, void * finish)
{
  long unsigned int GC_excl_table_entries.22;
  char * D.6299;
  long unsigned int D.6300;
  long unsigned int finish.23;
  long int next.24;
  long int D.6307;
  long int D.6308;
  long int D.6309;
  long unsigned int D.6310;
  long unsigned int GC_excl_table_entries.25;
  struct exclusion * next;
  size_t next_index;
  size_t i;

  GC_excl_table_entries.22 = GC_excl_table_entries;
  if (GC_excl_table_entries.22 == 0) goto <D.6294>; else goto <D.6295>;
  <D.6294>:
  next = 0B;
  goto <D.6296>;
  <D.6295>:
  next = GC_next_exclusion (start);
  <D.6296>:
  if (next != 0B) goto <D.6297>; else goto <D.6298>;
  <D.6297>:
  D.6299 = next->e_start;
  D.6300 = (long unsigned int) D.6299;
  finish.23 = (long unsigned int) finish;
  if (D.6300 < finish.23) goto <D.6302>; else goto <D.6303>;
  <D.6302>:
  GC_abort ("exclusion ranges overlap");
  <D.6303>:
  D.6299 = next->e_start;
  D.6300 = (long unsigned int) D.6299;
  finish.23 = (long unsigned int) finish;
  if (D.6300 == finish.23) goto <D.6304>; else goto <D.6305>;
  <D.6304>:
  next->e_start = start;
  return;
  <D.6305>:
  next.24 = (long int) next;
  D.6307 = (long int) &GC_arrays._excl_table;
  D.6308 = next.24 - D.6307;
  D.6309 = D.6308 /[ex] 16;
  next_index = (size_t) D.6309;
  i = GC_excl_table_entries;
  goto <D.6133>;
  <D.6132>:
  D.6310 = i + 18446744073709551615;
  GC_arrays._excl_table[i] = GC_arrays._excl_table[D.6310];
  i = i + 18446744073709551615;
  <D.6133>:
  if (i > next_index) goto <D.6132>; else goto <D.6134>;
  <D.6134>:
  goto <D.6311>;
  <D.6298>:
  next_index = GC_excl_table_entries;
  <D.6311>:
  GC_excl_table_entries.22 = GC_excl_table_entries;
  if (GC_excl_table_entries.22 == 256) goto <D.6312>; else goto <D.6313>;
  <D.6312>:
  GC_abort ("Too many exclusions");
  <D.6313>:
  GC_arrays._excl_table[next_index].e_start = start;
  GC_arrays._excl_table[next_index].e_end = finish;
  GC_excl_table_entries.22 = GC_excl_table_entries;
  GC_excl_table_entries.25 = GC_excl_table_entries.22 + 1;
  GC_excl_table_entries = GC_excl_table_entries.25;
}


GC_push_conditional_with_exclusions (char * bottom, char * top, int all)
{
  struct exclusion * next;
  char * excl_start;

  goto <D.6143>;
  <D.6142>:
  next = GC_next_exclusion (bottom);
  if (next == 0B) goto <D.6316>; else goto <D.6318>;
  <D.6318>:
  excl_start = next->e_start;
  if (excl_start >= top) goto <D.6316>; else goto <D.6317>;
  <D.6316>:
  GC_push_conditional (bottom, top, all);
  return;
  <D.6317>:
  if (excl_start > bottom) goto <D.6319>; else goto <D.6320>;
  <D.6319>:
  GC_push_conditional (bottom, excl_start, all);
  <D.6320>:
  bottom = next->e_end;
  <D.6143>:
  if (bottom < top) goto <D.6142>; else goto <D.6144>;
  <D.6144>:
}


GC_push_current_stack (char * cold_gc_frame)
{
  char * D.6324;

  if (cold_gc_frame == 0B) goto <D.6322>; else goto <D.6323>;
  <D.6322>:
  return;
  <D.6323>:
  D.6324 = GC_approx_sp ();
  GC_push_all_eager (D.6324, cold_gc_frame);
}


GC_push_gc_structures ()
{
  GC_push_finalizer_structures ();
  GC_push_stubborn_structures ();
  GC_push_thread_structures ();
}


GC_cond_register_dynamic_libraries ()
{
  int GC_no_dls.26;

  GC_remove_tmp_roots ();
  GC_no_dls.26 = GC_no_dls;
  if (GC_no_dls.26 == 0) goto <D.6327>; else goto <D.6328>;
  <D.6327>:
  GC_register_dynamic_libraries ();
  <D.6328>:
}


GC_push_roots (GC_bool all, char * cold_gc_frame)
{
  char * D.6329;
  char * D.6330;
  int n_root_sets.27;
  char * * D.6332;
  int GC_n_kinds.28;
  int GC_no_dls.29;
  int roots_were_cleared.30;
  void (*<T714>) (void) GC_push_other_roots.31;
  int i;
  int kind;

  i = 0;
  goto <D.6160>;
  <D.6159>:
  D.6329 = GC_arrays._static_roots[i].r_start;
  D.6330 = GC_arrays._static_roots[i].r_end;
  GC_push_conditional_with_exclusions (D.6329, D.6330, all);
  i = i + 1;
  <D.6160>:
  n_root_sets.27 = n_root_sets;
  if (i < n_root_sets.27) goto <D.6159>; else goto <D.6161>;
  <D.6161>:
  kind = 0;
  goto <D.6164>;
  <D.6163>:
  {
    void * base;

    D.6332 = GC_obj_kinds[kind].ok_freelist;
    base = GC_base (D.6332);
    if (base != 0B) goto <D.6333>; else goto <D.6334>;
    <D.6333>:
    GC_set_mark_bit (base);
    <D.6334>:
  }
  kind = kind + 1;
  <D.6164>:
  GC_n_kinds.28 = GC_n_kinds;
  if (kind < GC_n_kinds.28) goto <D.6163>; else goto <D.6165>;
  <D.6165>:
  GC_no_dls.29 = GC_no_dls;
  if (GC_no_dls.29 != 0) goto <D.6336>; else goto <D.6339>;
  <D.6339>:
  roots_were_cleared.30 = roots_were_cleared;
  if (roots_were_cleared.30 != 0) goto <D.6336>; else goto <D.6337>;
  <D.6336>:
  GC_push_gc_structures ();
  <D.6337>:
  GC_generic_push_regs (cold_gc_frame);
  GC_push_other_roots.31 = GC_push_other_roots;
  if (GC_push_other_roots.31 != 0B) goto <D.6342>; else goto <D.6343>;
  <D.6342>:
  GC_push_other_roots.31 = GC_push_other_roots;
  GC_push_other_roots.31 ();
  <D.6343>:
}