GC_invalidate_map (struct hdr * hhdr)
{
  map_entry_type * GC_invalid_map.0;
  char * GC_invalid_map.1;
  sizetype D.5366;
  map_entry_type * D.5367;
  unsigned int displ.2;
  register int displ;

  GC_invalid_map.0 = GC_invalid_map;
  if (GC_invalid_map.0 == 0B) goto <D.5361>; else goto <D.5362>;
  <D.5361>:
  GC_invalid_map.1 = GC_scratch_alloc (4096);
  GC_invalid_map = GC_invalid_map.1;
  GC_invalid_map.0 = GC_invalid_map;
  if (GC_invalid_map.0 == 0B) goto <D.5364>; else goto <D.5365>;
  <D.5364>:
  GC_err_puts ("Cant initialize GC_invalid_map: insufficient memory\n");
  exit (1);
  <D.5365>:
  displ = 0;
  goto <D.5325>;
  <D.5324>:
  GC_invalid_map.0 = GC_invalid_map;
  D.5366 = (sizetype) displ;
  D.5367 = GC_invalid_map.0 + D.5366;
  *D.5367 = 255;
  displ = displ + 1;
  <D.5325>:
  displ.2 = (unsigned int) displ;
  if (displ.2 <= 4095) goto <D.5324>; else goto <D.5326>;
  <D.5326>:
  <D.5362>:
  GC_invalid_map.0 = GC_invalid_map;
  hhdr->hb_map = GC_invalid_map.0;
}


GC_register_displacement (GC_word offset)
{
  int D.5369;

  D.5369 = GC_test_and_set (&GC_allocate_lock);
  if (D.5369 != 0) goto <D.5370>; else goto <D.5371>;
  <D.5370>:
  GC_lock ();
  <D.5371>:
  GC_register_displacement_inner (offset);
  GC_clear (&GC_allocate_lock);
}


GC_test_and_set (volatile unsigned int * addr)
{
  int D.5372;
  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.5372 = oldval;
  return D.5372;
}


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


GC_register_displacement_inner (word offset)
{
  char D.5378;
  long unsigned int D.5381;
  long unsigned int max_valid_offset.3;
  int GC_all_interior_pointers.4;
  map_entry_type * D.5388;
  map_entry_type * D.5393;
  unsigned char D.5394;
  long unsigned int D.5396;
  sizetype D.5399;
  map_entry_type * D.5400;
  register unsigned int i;
  word map_entry;

  map_entry = offset >> 3;
  if (offset > 2048) goto <D.5374>; else goto <D.5375>;
  <D.5374>:
  GC_abort ("Bad argument to GC_register_displacement");
  <D.5375>:
  if (map_entry > 253) goto <D.5376>; else goto <D.5377>;
  <D.5376>:
  map_entry = 254;
  <D.5377>:
  D.5378 = GC_arrays._valid_offsets[offset];
  if (D.5378 == 0) goto <D.5379>; else goto <D.5380>;
  <D.5379>:
  GC_arrays._valid_offsets[offset] = 1;
  D.5381 = offset & 7;
  GC_arrays._modws_valid_offsets[D.5381] = 1;
  max_valid_offset.3 = max_valid_offset;
  if (offset > max_valid_offset.3) goto <D.5383>; else goto <D.5384>;
  <D.5383>:
  max_valid_offset = offset;
  <D.5384>:
  GC_all_interior_pointers.4 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.4 == 0) goto <D.5386>; else goto <D.5387>;
  <D.5386>:
  i = 0;
  goto <D.5341>;
  <D.5340>:
  D.5388 = GC_arrays._obj_map[i];
  if (D.5388 != 0B) goto <D.5389>; else goto <D.5390>;
  <D.5389>:
  if (i == 0) goto <D.5391>; else goto <D.5392>;
  <D.5391>:
  D.5388 = GC_arrays._obj_map[i];
  D.5393 = D.5388 + offset;
  D.5394 = (unsigned char) map_entry;
  *D.5393 = D.5394;
  goto <D.5395>;
  <D.5392>:
  {
    register unsigned int j;
    register unsigned int lb;

    lb = i << 3;
    D.5396 = (long unsigned int) lb;
    if (D.5396 > offset) goto <D.5397>; else goto <D.5398>;
    <D.5397>:
    j = (unsigned int) offset;
    goto <D.5338>;
    <D.5337>:
    D.5388 = GC_arrays._obj_map[i];
    D.5399 = (sizetype) j;
    D.5400 = D.5388 + D.5399;
    D.5394 = (unsigned char) map_entry;
    *D.5400 = D.5394;
    j = j + lb;
    <D.5338>:
    if (j <= 4095) goto <D.5337>; else goto <D.5339>;
    <D.5339>:
    <D.5398>:
  }
  <D.5395>:
  <D.5390>:
  i = i + 1;
  <D.5341>:
  if (i <= 256) goto <D.5340>; else goto <D.5342>;
  <D.5342>:
  <D.5387>:
  <D.5380>:
}


GC_add_map_entry (word sz)
{
  map_entry_type * D.5403;
  GC_bool D.5406;
  int GC_all_interior_pointers.5;
  char D.5415;
  unsigned int D.5416;
  sizetype D.5419;
  map_entry_type * D.5420;
  unsigned char D.5421;
  long unsigned int D.5422;
  long unsigned int max_valid_offset.6;
  unsigned int D.5430;
  sizetype D.5431;
  map_entry_type * D.5432;
  unsigned int D.5433;
  unsigned int D.5434;
  long unsigned int D.5435;
  long unsigned int D.5436;
  long unsigned int D.5437;
  register unsigned int obj_start;
  register unsigned int displ;
  register map_entry_type * new_map;
  word map_entry;

  if (sz > 256) goto <D.5401>; else goto <D.5402>;
  <D.5401>:
  sz = 0;
  <D.5402>:
  D.5403 = GC_arrays._obj_map[sz];
  if (D.5403 != 0B) goto <D.5404>; else goto <D.5405>;
  <D.5404>:
  D.5406 = 1;
  return D.5406;
  <D.5405>:
  new_map = GC_scratch_alloc (4096);
  if (new_map == 0B) goto <D.5407>; else goto <D.5408>;
  <D.5407>:
  D.5406 = 0;
  return D.5406;
  <D.5408>:
  memset (new_map, 255, 4096);
  if (sz == 0) goto <D.5409>; else goto <D.5410>;
  <D.5409>:
  displ = 0;
  goto <D.5351>;
  <D.5350>:
  GC_all_interior_pointers.5 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.5 != 0) goto <D.5411>; else goto <D.5414>;
  <D.5414>:
  D.5415 = GC_arrays._valid_offsets[displ];
  if (D.5415 != 0) goto <D.5411>; else goto <D.5412>;
  <D.5411>:
  D.5416 = displ >> 3;
  map_entry = (word) D.5416;
  if (map_entry > 253) goto <D.5417>; else goto <D.5418>;
  <D.5417>:
  map_entry = 254;
  <D.5418>:
  D.5419 = (sizetype) displ;
  D.5420 = new_map + D.5419;
  D.5421 = (unsigned char) map_entry;
  *D.5420 = D.5421;
  <D.5412>:
  displ = displ + 1;
  <D.5351>:
  D.5422 = (long unsigned int) displ;
  max_valid_offset.6 = max_valid_offset;
  if (D.5422 <= max_valid_offset.6) goto <D.5350>; else goto <D.5352>;
  <D.5352>:
  goto <D.5424>;
  <D.5410>:
  obj_start = 0;
  goto <D.5357>;
  <D.5356>:
  displ = 0;
  goto <D.5354>;
  <D.5353>:
  GC_all_interior_pointers.5 = GC_all_interior_pointers;
  if (GC_all_interior_pointers.5 != 0) goto <D.5425>; else goto <D.5427>;
  <D.5427>:
  D.5415 = GC_arrays._valid_offsets[displ];
  if (D.5415 != 0) goto <D.5425>; else goto <D.5426>;
  <D.5425>:
  D.5416 = displ >> 3;
  map_entry = (word) D.5416;
  if (map_entry > 253) goto <D.5428>; else goto <D.5429>;
  <D.5428>:
  map_entry = 254;
  <D.5429>:
  D.5430 = obj_start + displ;
  D.5431 = (sizetype) D.5430;
  D.5432 = new_map + D.5431;
  D.5421 = (unsigned char) map_entry;
  *D.5432 = D.5421;
  <D.5426>:
  displ = displ + 1;
  <D.5354>:
  D.5422 = (long unsigned int) displ;
  max_valid_offset.6 = max_valid_offset;
  if (D.5422 <= max_valid_offset.6) goto <D.5353>; else goto <D.5355>;
  <D.5355>:
  D.5433 = (unsigned int) sz;
  D.5434 = D.5433 << 3;
  obj_start = D.5434 + obj_start;
  <D.5357>:
  D.5435 = (long unsigned int) obj_start;
  D.5436 = sz << 3;
  D.5437 = D.5435 + D.5436;
  if (D.5437 <= 4096) goto <D.5356>; else goto <D.5358>;
  <D.5358>:
  <D.5424>:
  GC_arrays._obj_map[sz] = new_map;
  D.5406 = 1;
  return D.5406;
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.5441;
  int D.5446;
  void * D.5448;
  long unsigned int D.5449;

  D.5441 = __builtin_constant_p (__len);
  if (D.5441 != 0) goto <D.5442>; else goto <D.5443>;
  <D.5442>:
  if (__len == 0) goto <D.5444>; else goto <D.5445>;
  <D.5444>:
  D.5446 = __builtin_constant_p (__ch);
  if (D.5446 == 0) goto <D.5439>; else goto <D.5447>;
  <D.5447>:
  if (__ch != 0) goto <D.5439>; else goto <D.5440>;
  <D.5439>:
  __warn_memset_zero_len ();
  D.5448 = __dest;
  return D.5448;
  <D.5440>:
  <D.5445>:
  <D.5443>:
  D.5449 = __builtin_object_size (__dest, 0);
  D.5448 = __builtin___memset_chk (__dest, __ch, __len, D.5449);
  return D.5448;
}