mono_code_manager_init ()
{

}


mono_code_manager_cleanup ()
{
  codechunk_cleanup ();
}


codechunk_cleanup ()
{
  struct GHashTable * valloc_freelists.0;
  void * D.14870;
  void * key.1;
  long int key.2;
  unsigned int D.14873;
  long unsigned int D.14874;
  int D.14875;
  struct GHashTableIter iter;
  void * key;
  void * value;

  try
    {
      valloc_freelists.0 = valloc_freelists;
      if (valloc_freelists.0 == 0B) goto <D.14868>; else goto <D.14869>;
      <D.14868>:
      return;
      <D.14869>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_iter_init (&iter, valloc_freelists.0);
      goto <D.14764>;
      <D.14763>:
      {
        struct GSList * freelist;
        struct GSList * l;

        freelist = value;
        l = freelist;
        goto <D.14761>;
        <D.14760>:
        D.14870 = l->data;
        key.1 = key;
        key.2 = (long int) key.1;
        D.14873 = (unsigned int) key.2;
        D.14874 = (long unsigned int) D.14873;
        mono_vfree (D.14870, D.14874);
        l = l->next;
        <D.14761>:
        if (l != 0B) goto <D.14760>; else goto <D.14762>;
        <D.14762>:
        monoeg_g_slist_free (freelist);
      }
      <D.14764>:
      D.14875 = monoeg_g_hash_table_iter_next (&iter, &key, &value);
      if (D.14875 != 0) goto <D.14763>; else goto <D.14765>;
      <D.14765>:
      valloc_freelists.0 = valloc_freelists;
      monoeg_g_hash_table_destroy (valloc_freelists.0);
    }
  finally
    {
      iter = {CLOBBER};
      key = {CLOBBER};
      value = {CLOBBER};
    }
}


mono_code_manager_new ()
{
  struct MonoCodeManager * D.14881;
  struct MonoCodeManager * cman;

  cman = malloc (24);
  if (cman == 0B) goto <D.14879>; else goto <D.14880>;
  <D.14879>:
  D.14881 = 0B;
  return D.14881;
  <D.14880>:
  cman->current = 0B;
  cman->full = 0B;
  cman->dynamic = 0;
  cman->read_only = 0;
  D.14881 = cman;
  return D.14881;
}


mono_code_manager_new_dynamic ()
{
  struct MonoCodeManager * D.14883;
  struct MonoCodeManager * cman;

  cman = mono_code_manager_new ();
  cman->dynamic = 1;
  D.14883 = cman;
  return D.14883;
}


mono_code_manager_destroy (struct MonoCodeManager * cman)
{
  struct CodeChunk * D.14885;
  struct CodeChunk * D.14886;

  D.14885 = cman->full;
  free_chunklist (D.14885);
  D.14886 = cman->current;
  free_chunklist (D.14886);
  free (cman);
}


free_chunklist (struct CodeChunk * chunk)
{
  char * D.14887;
  unsigned char D.14888;
  int D.14891;
  unsigned int D.14892;
  long unsigned int code_memory_used.3;
  long unsigned int D.14897;
  long unsigned int code_memory_used.4;
  struct CodeChunk * dead;

  goto <D.14785>;
  <D.14784>:
  dead = chunk;
  D.14887 = dead->data;
  mono_profiler_code_chunk_destroy (D.14887);
  chunk = chunk->next;
  D.14888 = dead->flags;
  if (D.14888 == 0) goto <D.14889>; else goto <D.14890>;
  <D.14889>:
  D.14887 = dead->data;
  D.14891 = dead->size;
  D.14892 = (unsigned int) D.14891;
  codechunk_vfree (D.14887, D.14892);
  goto <D.14893>;
  <D.14890>:
  D.14888 = dead->flags;
  if (D.14888 == 1) goto <D.14894>; else goto <D.14895>;
  <D.14894>:
  D.14887 = dead->data;
  dlfree (D.14887);
  <D.14895>:
  <D.14893>:
  code_memory_used.3 = code_memory_used;
  D.14891 = dead->size;
  D.14897 = (long unsigned int) D.14891;
  code_memory_used.4 = code_memory_used.3 - D.14897;
  code_memory_used = code_memory_used.4;
  free (dead);
  <D.14785>:
  if (chunk != 0B) goto <D.14784>; else goto <D.14786>;
  <D.14786>:
}


codechunk_vfree (void * ptr, guint32 size)
{
  _Bool D.14901;
  long int D.14902;
  long int D.14903;
  struct GHashTable * valloc_freelists.5;
  long unsigned int D.14907;
  const void * D.14908;
  unsigned int D.14913;
  void * D.14914;
  long unsigned int D.14915;
  _Bool D.14918;
  long int D.14919;
  long int D.14920;
  struct GSList * freelist;

  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14899>; else goto <D.14900>;
    <D.14899>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.14900>:
    D.14901 = ret != 0;
    D.14902 = (long int) D.14901;
    D.14903 = __builtin_expect (D.14902, 0);
    if (D.14903 != 0) goto <D.14904>; else goto <D.14905>;
    <D.14904>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 266, "ret == 0");
    <D.14905>:
  }
  valloc_freelists.5 = valloc_freelists;
  D.14907 = (long unsigned int) size;
  D.14908 = (const void *) D.14907;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.5, D.14908);
  if (freelist == 0B) goto <D.14909>; else goto <D.14912>;
  <D.14912>:
  D.14913 = monoeg_g_slist_length (freelist);
  if (D.14913 <= 15) goto <D.14909>; else goto <D.14910>;
  <D.14909>:
  freelist = monoeg_g_slist_prepend (freelist, ptr);
  valloc_freelists.5 = valloc_freelists;
  D.14907 = (long unsigned int) size;
  D.14914 = (void *) D.14907;
  monoeg_g_hash_table_insert_replace (valloc_freelists.5, D.14914, freelist, 0);
  goto <D.14911>;
  <D.14910>:
  D.14915 = (long unsigned int) size;
  mono_vfree (ptr, D.14915);
  <D.14911>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.14916>; else goto <D.14917>;
    <D.14916>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.14917>:
    D.14918 = ret != 0;
    D.14919 = (long int) D.14918;
    D.14920 = __builtin_expect (D.14919, 0);
    if (D.14920 != 0) goto <D.14921>; else goto <D.14922>;
    <D.14921>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 274, "ret == 0");
    <D.14922>:
  }
}


mono_code_manager_invalidate (struct MonoCodeManager * cman)
{
  char * D.14923;
  int D.14924;
  long unsigned int D.14925;
  struct CodeChunk * chunk;
  int fill_value;

  fill_value = 42;
  chunk = cman->current;
  goto <D.14796>;
  <D.14795>:
  D.14923 = chunk->data;
  D.14924 = chunk->size;
  D.14925 = (long unsigned int) D.14924;
  memset (D.14923, fill_value, D.14925);
  chunk = chunk->next;
  <D.14796>:
  if (chunk != 0B) goto <D.14795>; else goto <D.14797>;
  <D.14797>:
  chunk = cman->full;
  goto <D.14799>;
  <D.14798>:
  D.14923 = chunk->data;
  D.14924 = chunk->size;
  D.14925 = (long unsigned int) D.14924;
  memset (D.14923, fill_value, D.14925);
  chunk = chunk->next;
  <D.14799>:
  if (chunk != 0B) goto <D.14798>; else goto <D.14800>;
  <D.14800>:
}


memset (void * __dest, int __ch, size_t __len)
{
  int D.14928;
  int D.14933;
  void * D.14935;
  long unsigned int D.14936;

  D.14928 = __builtin_constant_p (__len);
  if (D.14928 != 0) goto <D.14929>; else goto <D.14930>;
  <D.14929>:
  if (__len == 0) goto <D.14931>; else goto <D.14932>;
  <D.14931>:
  D.14933 = __builtin_constant_p (__ch);
  if (D.14933 == 0) goto <D.14926>; else goto <D.14934>;
  <D.14934>:
  if (__ch != 0) goto <D.14926>; else goto <D.14927>;
  <D.14926>:
  __warn_memset_zero_len ();
  D.14935 = __dest;
  return D.14935;
  <D.14927>:
  <D.14932>:
  <D.14930>:
  D.14936 = __builtin_object_size (__dest, 0);
  D.14935 = __builtin___memset_chk (__dest, __ch, __len, D.14936);
  return D.14935;
}


mono_code_manager_set_read_only (struct MonoCodeManager * cman)
{
  cman->read_only = 1;
}


mono_code_manager_foreach (struct MonoCodeManager * cman, int (*MonoCodeManagerFunc) (void *, int, int, void *) func, void * user_data)
{
  char * D.14938;
  int D.14939;
  <unnamed-unsigned:24> D.14940;
  int D.14941;
  int D.14942;
  int D.14945;
  struct CodeChunk * chunk;

  chunk = cman->current;
  goto <D.14811>;
  <D.14810>:
  D.14938 = chunk->data;
  D.14939 = chunk->size;
  D.14940 = chunk->bsize;
  D.14941 = (int) D.14940;
  D.14942 = func (D.14938, D.14939, D.14941, user_data);
  if (D.14942 != 0) goto <D.14943>; else goto <D.14944>;
  <D.14943>:
  return;
  <D.14944>:
  chunk = chunk->next;
  <D.14811>:
  if (chunk != 0B) goto <D.14810>; else goto <D.14812>;
  <D.14812>:
  chunk = cman->full;
  goto <D.14814>;
  <D.14813>:
  D.14938 = chunk->data;
  D.14939 = chunk->size;
  D.14940 = chunk->bsize;
  D.14941 = (int) D.14940;
  D.14945 = func (D.14938, D.14939, D.14941, user_data);
  if (D.14945 != 0) goto <D.14946>; else goto <D.14947>;
  <D.14946>:
  return;
  <D.14947>:
  chunk = chunk->next;
  <D.14814>:
  if (chunk != 0B) goto <D.14813>; else goto <D.14815>;
  <D.14815>:
}


mono_code_manager_reserve_align (struct MonoCodeManager * cman, int size, int alignment)
{
  int D.14949;
  int D.14950;
  _Bool D.14951;
  long int D.14952;
  long int D.14953;
  _Bool D.14956;
  long int D.14957;
  long int D.14958;
  int D.14961;
  long unsigned int D.14964;
  long unsigned int D.14965;
  long unsigned int D.14966;
  long unsigned int D.14967;
  long unsigned int D.14968;
  struct CodeChunk * D.14969;
  struct CodeChunk * D.14972;
  void * D.14975;
  int D.14976;
  int D.14977;
  int D.14978;
  int D.14979;
  int D.14980;
  int D.14981;
  char * D.14984;
  long unsigned int D.14985;
  long unsigned int D.14986;
  long unsigned int D.14987;
  long unsigned int D.14988;
  long unsigned int D.14989;
  long unsigned int D.14990;
  long unsigned int D.14991;
  long int ptr.6;
  long int D.14993;
  long int D.14994;
  unsigned int D.14995;
  unsigned int size.7;
  unsigned int D.14997;
  int D.14998;
  int D.14999;
  struct CodeChunk * D.15004;
  struct CodeChunk * D.15006;
  struct CodeChunk * chunk;
  struct CodeChunk * prev;
  void * ptr;
  guint32 align_mask;

  D.14949 = alignment + -1;
  align_mask = (guint32) D.14949;
  D.14950 = cman->read_only;
  D.14951 = D.14950 != 0;
  D.14952 = (long int) D.14951;
  D.14953 = __builtin_expect (D.14952, 0);
  if (D.14953 != 0) goto <D.14954>; else goto <D.14955>;
  <D.14954>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 589, "!cman->read_only");
  <D.14955>:
  D.14956 = alignment > 8;
  D.14957 = (long int) D.14956;
  D.14958 = __builtin_expect (D.14957, 0);
  if (D.14958 != 0) goto <D.14959>; else goto <D.14960>;
  <D.14959>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 594, "alignment <= MIN_ALIGN");
  <D.14960>:
  D.14961 = cman->dynamic;
  if (D.14961 != 0) goto <D.14962>; else goto <D.14963>;
  <D.14962>:
  D.14964 = mono_stats.dynamic_code_alloc_count;
  D.14965 = D.14964 + 1;
  mono_stats.dynamic_code_alloc_count = D.14965;
  D.14966 = mono_stats.dynamic_code_bytes_count;
  D.14967 = (long unsigned int) size;
  D.14968 = D.14966 + D.14967;
  mono_stats.dynamic_code_bytes_count = D.14968;
  <D.14963>:
  D.14969 = cman->current;
  if (D.14969 == 0B) goto <D.14970>; else goto <D.14971>;
  <D.14970>:
  D.14961 = cman->dynamic;
  D.14972 = new_codechunk (D.14961, size);
  cman->current = D.14972;
  D.14969 = cman->current;
  if (D.14969 == 0B) goto <D.14973>; else goto <D.14974>;
  <D.14973>:
  D.14975 = 0B;
  return D.14975;
  <D.14974>:
  <D.14971>:
  chunk = cman->current;
  goto <D.14837>;
  <D.14836>:
  D.14976 = chunk->pos;
  D.14949 = alignment + -1;
  D.14977 = D.14976 + D.14949;
  D.14978 = -alignment;
  D.14979 = D.14977 & D.14978;
  D.14980 = D.14979 + size;
  D.14981 = chunk->size;
  if (D.14980 <= D.14981) goto <D.14982>; else goto <D.14983>;
  <D.14982>:
  D.14976 = chunk->pos;
  D.14949 = alignment + -1;
  D.14977 = D.14976 + D.14949;
  D.14978 = -alignment;
  D.14979 = D.14977 & D.14978;
  chunk->pos = D.14979;
  D.14984 = chunk->data;
  D.14985 = (long unsigned int) D.14984;
  D.14986 = (long unsigned int) align_mask;
  D.14987 = D.14985 + D.14986;
  D.14986 = (long unsigned int) align_mask;
  D.14988 = ~D.14986;
  D.14989 = D.14987 & D.14988;
  D.14976 = chunk->pos;
  D.14990 = (long unsigned int) D.14976;
  D.14991 = D.14989 + D.14990;
  ptr = (void *) D.14991;
  ptr.6 = (long int) ptr;
  D.14984 = chunk->data;
  D.14993 = (long int) D.14984;
  D.14994 = ptr.6 - D.14993;
  D.14995 = (unsigned int) D.14994;
  size.7 = (unsigned int) size;
  D.14997 = D.14995 + size.7;
  D.14998 = (int) D.14997;
  chunk->pos = D.14998;
  D.14975 = ptr;
  return D.14975;
  <D.14983>:
  chunk = chunk->next;
  <D.14837>:
  if (chunk != 0B) goto <D.14836>; else goto <D.14838>;
  <D.14838>:
  prev = 0B;
  chunk = cman->current;
  goto <D.14842>;
  <D.14841>:
  D.14976 = chunk->pos;
  D.14999 = D.14976 + 31;
  D.14981 = chunk->size;
  if (D.14999 < D.14981) goto <D.15000>; else goto <D.15001>;
  <D.15000>:
  // predicted unlikely by continue predictor.
  goto <D.14839>;
  <D.15001>:
  if (prev != 0B) goto <D.15002>; else goto <D.15003>;
  <D.15002>:
  D.15004 = chunk->next;
  prev->next = D.15004;
  goto <D.15005>;
  <D.15003>:
  D.15004 = chunk->next;
  cman->current = D.15004;
  <D.15005>:
  D.15006 = cman->full;
  chunk->next = D.15006;
  cman->full = chunk;
  goto <D.14840>;
  <D.14839>:
  prev = chunk;
  chunk = chunk->next;
  <D.14842>:
  if (chunk != 0B) goto <D.14841>; else goto <D.14840>;
  <D.14840>:
  D.14961 = cman->dynamic;
  chunk = new_codechunk (D.14961, size);
  if (chunk == 0B) goto <D.15007>; else goto <D.15008>;
  <D.15007>:
  D.14975 = 0B;
  return D.14975;
  <D.15008>:
  D.14969 = cman->current;
  chunk->next = D.14969;
  cman->current = chunk;
  D.14976 = chunk->pos;
  D.14949 = alignment + -1;
  D.14977 = D.14976 + D.14949;
  D.14978 = -alignment;
  D.14979 = D.14977 & D.14978;
  chunk->pos = D.14979;
  D.14984 = chunk->data;
  D.14985 = (long unsigned int) D.14984;
  D.14986 = (long unsigned int) align_mask;
  D.14987 = D.14985 + D.14986;
  D.14986 = (long unsigned int) align_mask;
  D.14988 = ~D.14986;
  D.14989 = D.14987 & D.14988;
  D.14976 = chunk->pos;
  D.14990 = (long unsigned int) D.14976;
  D.14991 = D.14989 + D.14990;
  ptr = (void *) D.14991;
  ptr.6 = (long int) ptr;
  D.14984 = chunk->data;
  D.14993 = (long int) D.14984;
  D.14994 = ptr.6 - D.14993;
  D.14995 = (unsigned int) D.14994;
  size.7 = (unsigned int) size;
  D.14997 = D.14995 + size.7;
  D.14998 = (int) D.14997;
  chunk->pos = D.14998;
  D.14975 = ptr;
  return D.14975;
}


new_codechunk (int dynamic, int size)
{
  int D.15016;
  int D.15017;
  int D.15020;
  int D.15025;
  long unsigned int D.15026;
  struct CodeChunk * D.15029;
  unsigned int chunk_size.8;
  long unsigned int D.15036;
  long unsigned int D.15042;
  unsigned char D.15043;
  unsigned int bsize.9;
  <unnamed-unsigned:24> D.15045;
  char * D.15046;
  int D.15047;
  long unsigned int D.15048;
  long unsigned int code_memory_used.10;
  long unsigned int code_memory_used.11;
  int minsize;
  int flags;
  int chunk_size;
  int bsize;
  int pagesize;
  struct CodeChunk * chunk;
  void * ptr;

  flags = 0;
  bsize = 0;
  pagesize = mono_pagesize ();
  if (dynamic != 0) goto <D.15010>; else goto <D.15011>;
  <D.15010>:
  chunk_size = size;
  flags = 1;
  goto <D.15012>;
  <D.15011>:
  minsize = pagesize * 16;
  if (size < minsize) goto <D.15013>; else goto <D.15014>;
  <D.15013>:
  chunk_size = minsize;
  goto <D.15015>;
  <D.15014>:
  chunk_size = size;
  D.15016 = pagesize + -1;
  chunk_size = D.15016 + chunk_size;
  D.15017 = -pagesize;
  chunk_size = D.15017 & chunk_size;
  <D.15015>:
  <D.15012>:
  bsize = chunk_size / 4;
  if (bsize <= 31) goto <D.15018>; else goto <D.15019>;
  <D.15018>:
  bsize = 32;
  <D.15019>:
  bsize = bsize + 7;
  bsize = bsize & -8;
  D.15020 = chunk_size - size;
  if (D.15020 < bsize) goto <D.15021>; else goto <D.15022>;
  <D.15021>:
  chunk_size = size + bsize;
  D.15016 = pagesize + -1;
  chunk_size = D.15016 + chunk_size;
  D.15017 = -pagesize;
  chunk_size = D.15017 & chunk_size;
  <D.15022>:
  if (flags == 1) goto <D.15023>; else goto <D.15024>;
  <D.15023>:
  D.15025 = chunk_size + 7;
  D.15026 = (long unsigned int) D.15025;
  ptr = dlmemalign (8, D.15026);
  if (ptr == 0B) goto <D.15027>; else goto <D.15028>;
  <D.15027>:
  D.15029 = 0B;
  return D.15029;
  <D.15028>:
  goto <D.15030>;
  <D.15024>:
  chunk_size.8 = (unsigned int) chunk_size;
  ptr = codechunk_valloc (chunk_size.8);
  if (ptr == 0B) goto <D.15032>; else goto <D.15033>;
  <D.15032>:
  D.15029 = 0B;
  return D.15029;
  <D.15033>:
  <D.15030>:
  if (flags == 1) goto <D.15034>; else goto <D.15035>;
  <D.15034>:
  D.15036 = (long unsigned int) bsize;
  memset (ptr, 0, D.15036);
  <D.15035>:
  chunk = malloc (32);
  if (chunk == 0B) goto <D.15037>; else goto <D.15038>;
  <D.15037>:
  if (flags == 1) goto <D.15039>; else goto <D.15040>;
  <D.15039>:
  dlfree (ptr);
  goto <D.15041>;
  <D.15040>:
  D.15042 = (long unsigned int) chunk_size;
  mono_vfree (ptr, D.15042);
  <D.15041>:
  D.15029 = 0B;
  return D.15029;
  <D.15038>:
  chunk->next = 0B;
  chunk->size = chunk_size;
  chunk->data = ptr;
  D.15043 = (unsigned char) flags;
  chunk->flags = D.15043;
  chunk->pos = bsize;
  bsize.9 = (unsigned int) bsize;
  D.15045 = (<unnamed-unsigned:24>) bsize.9;
  chunk->bsize = D.15045;
  D.15046 = chunk->data;
  D.15047 = chunk->size;
  mono_profiler_code_chunk_new (D.15046, D.15047);
  D.15048 = (long unsigned int) chunk_size;
  code_memory_used.10 = code_memory_used;
  code_memory_used.11 = D.15048 + code_memory_used.10;
  code_memory_used = code_memory_used.11;
  code_memory_used.10 = code_memory_used;
  mono_runtime_resource_check_limit (0, code_memory_used.10);
  D.15029 = chunk;
  return D.15029;
}


codechunk_valloc (guint32 size)
{
  struct GHashTable * valloc_freelists.12;
  struct GHashTable * valloc_freelists.13;
  _Bool D.15058;
  long int D.15059;
  long int D.15060;
  long unsigned int D.15063;
  const void * D.15064;
  long unsigned int D.15067;
  void * D.15068;
  unsigned int D.15070;
  long unsigned int D.15071;
  _Bool D.15074;
  long int D.15075;
  long int D.15076;
  void * D.15079;
  void * ptr;
  struct GSList * freelist;

  valloc_freelists.12 = valloc_freelists;
  if (valloc_freelists.12 == 0B) goto <D.15053>; else goto <D.15054>;
  <D.15053>:
  InitializeCriticalSection (&valloc_mutex);
  valloc_freelists.13 = monoeg_g_hash_table_new (0B, 0B);
  valloc_freelists = valloc_freelists.13;
  <D.15054>:
  {
    int ret;

    ret = pthread_mutex_lock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.15056>; else goto <D.15057>;
    <D.15056>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_lock result %d", ret);
    <D.15057>:
    D.15058 = ret != 0;
    D.15059 = (long int) D.15058;
    D.15060 = __builtin_expect (D.15059, 0);
    if (D.15060 != 0) goto <D.15061>; else goto <D.15062>;
    <D.15061>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 247, "ret == 0");
    <D.15062>:
  }
  valloc_freelists.12 = valloc_freelists;
  D.15063 = (long unsigned int) size;
  D.15064 = (const void *) D.15063;
  freelist = monoeg_g_hash_table_lookup (valloc_freelists.12, D.15064);
  if (freelist != 0B) goto <D.15065>; else goto <D.15066>;
  <D.15065>:
  ptr = freelist->data;
  D.15067 = (long unsigned int) size;
  memset (ptr, 0, D.15067);
  freelist = monoeg_g_slist_remove_link (freelist, freelist);
  valloc_freelists.12 = valloc_freelists;
  D.15063 = (long unsigned int) size;
  D.15068 = (void *) D.15063;
  monoeg_g_hash_table_insert_replace (valloc_freelists.12, D.15068, freelist, 0);
  goto <D.15069>;
  <D.15066>:
  D.15070 = size + 7;
  D.15071 = (long unsigned int) D.15070;
  ptr = mono_valloc (0B, D.15071, 7);
  <D.15069>:
  {
    int ret;

    ret = pthread_mutex_unlock (&valloc_mutex.mutex);
    if (ret != 0) goto <D.15072>; else goto <D.15073>;
    <D.15072>:
    monoeg_g_log (0B, 16, "Bad call to mono_mutex_unlock result %d", ret);
    <D.15073>:
    D.15074 = ret != 0;
    D.15075 = (long int) D.15074;
    D.15076 = __builtin_expect (D.15075, 0);
    if (D.15076 != 0) goto <D.15077>; else goto <D.15078>;
    <D.15077>:
    monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 257, "ret == 0");
    <D.15078>:
  }
  D.15079 = ptr;
  return D.15079;
}


mono_code_manager_reserve (struct MonoCodeManager * cman, int size)
{
  void * D.15081;

  D.15081 = mono_code_manager_reserve_align (cman, size, 8);
  return D.15081;
}


mono_code_manager_commit (struct MonoCodeManager * cman, void * data, int size, int newsize)
{
  _Bool D.15083;
  long int D.15084;
  long int D.15085;
  struct CodeChunk * D.15088;
  char * D.15093;
  int D.15094;
  sizetype D.15095;
  sizetype D.15096;
  sizetype D.15097;
  char * D.15098;
  int D.15101;
  int D.15102;

  D.15083 = newsize > size;
  D.15084 = (long int) D.15083;
  D.15085 = __builtin_expect (D.15084, 0);
  if (D.15085 != 0) goto <D.15086>; else goto <D.15087>;
  <D.15086>:
  monoeg_assertion_message ("* Assertion at %s:%d, condition `%s\' not met\n", "mono-codeman.c", 702, "newsize <= size");
  <D.15087>:
  D.15088 = cman->current;
  if (D.15088 != 0B) goto <D.15089>; else goto <D.15090>;
  <D.15089>:
  if (size != newsize) goto <D.15091>; else goto <D.15092>;
  <D.15091>:
  D.15088 = cman->current;
  D.15093 = D.15088->data;
  D.15088 = cman->current;
  D.15094 = D.15088->pos;
  D.15095 = (sizetype) D.15094;
  D.15096 = (sizetype) size;
  D.15097 = D.15095 - D.15096;
  D.15098 = D.15093 + D.15097;
  if (D.15098 == data) goto <D.15099>; else goto <D.15100>;
  <D.15099>:
  D.15088 = cman->current;
  D.15088 = cman->current;
  D.15094 = D.15088->pos;
  D.15101 = newsize - size;
  D.15102 = D.15094 + D.15101;
  D.15088->pos = D.15102;
  <D.15100>:
  <D.15092>:
  <D.15090>:
}


mono_code_manager_size (struct MonoCodeManager * cman, int * used_size)
{
  int D.15103;
  unsigned int D.15104;
  int D.15105;
  unsigned int D.15106;
  int used.14;
  int D.15110;
  struct CodeChunk * chunk;
  guint32 size;
  guint32 used;

  size = 0;
  used = 0;
  chunk = cman->current;
  goto <D.14861>;
  <D.14860>:
  D.15103 = chunk->size;
  D.15104 = (unsigned int) D.15103;
  size = D.15104 + size;
  D.15105 = chunk->pos;
  D.15106 = (unsigned int) D.15105;
  used = D.15106 + used;
  chunk = chunk->next;
  <D.14861>:
  if (chunk != 0B) goto <D.14860>; else goto <D.14862>;
  <D.14862>:
  chunk = cman->full;
  goto <D.14864>;
  <D.14863>:
  D.15103 = chunk->size;
  D.15104 = (unsigned int) D.15103;
  size = D.15104 + size;
  D.15105 = chunk->pos;
  D.15106 = (unsigned int) D.15105;
  used = D.15106 + used;
  chunk = chunk->next;
  <D.14864>:
  if (chunk != 0B) goto <D.14863>; else goto <D.14865>;
  <D.14865>:
  if (used_size != 0B) goto <D.15107>; else goto <D.15108>;
  <D.15107>:
  used.14 = (int) used;
  *used_size = used.14;
  <D.15108>:
  D.15110 = (int) size;
  return D.15110;
}