Changeset 373


Ignore:
Timestamp:
Jul 15, 2003, 2:44:30 AM (22 years ago)
Author:
bird
Message:

#456: Optimizations of type_add(). Not stable yet. Will fix tomorrow.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/emx/src/emxomf/stabshll.c

    • Property cvs2svn:cvs-rev changed from 1.12 to 1.13
    r372 r373  
    110110  ty_class,                     /* A C++ class */
    111111  ty_memfunc,                   /* A C++ member function */
    112   ty_baseclass                  /* A C++ base class */
     112  ty_baseclass,                 /* A C++ base class */
     113  ty_max
    113114};
    114115
     
    149150  int index;                    /* The HLL index for this type */
    150151  struct type *next;            /* All types are chained in a single list */
     152  struct type *nexthash;        /* All types are chained in the hash list */
    151153  union
    152154    {
     
    295297
    296298static struct type *type_head;
     299#define TYPE_HASH_MAX   128
     300static struct type *atype_tag[TYPE_HASH_MAX + 1];
     301#ifdef HASH_DEBUG
     302static int          ctypes = 0;
     303static int          ctype_tag[TYPE_HASH_MAX + 1];
     304#endif
    297305
    298306/* This growing array keeps track of stabs vs. internal types.  It is
     
    560568}
    561569
     570/**
     571 * Try calculate a good hash (yeah sure).
     572 *
     573 * @returns hash index.
     574 * @param   t     type
     575 */
     576static unsigned type_hash (struct type *t)
     577{
     578  unsigned uhash;
     579  switch (t->tag)
     580    {
     581      case ty_alias:        uhash = (unsigned)t->d.alias; break;
     582      case ty_stabs_ref:    uhash = (unsigned)t->d.stabs_ref; break;
     583      case ty_prim:         uhash = (unsigned)t->index; break;
     584      case ty_pointer:      uhash = (unsigned)t->d.pointer; break;
     585      case ty_ref:          uhash = (unsigned)t->d.ref; break;
     586      case ty_struc:        uhash = (unsigned)t->d.struc.name; break;
     587      case ty_class:        uhash = (unsigned)t->d.class.name; break;
     588      case ty_enu:          uhash = (unsigned)t->d.enu.name; break;
     589      case ty_array:        uhash = (unsigned)t->d.array.etype; break;
     590      case ty_bits:         uhash = (unsigned)t->d.bits.type; break;
     591      case ty_func:         uhash = (unsigned)t->d.func.args; break;
     592      case ty_args:         uhash = (unsigned)t->d.args.list + t->d.args.count; break;
     593      case ty_types:        uhash = (unsigned)t->d.types.list + t->d.types.count; break;
     594      case ty_fields:       uhash = (unsigned)t->d.fields.list + t->d.fields.count; break;
     595      case ty_member:       uhash = (unsigned)t->d.member.type + t->d.member.offset + t->d.member.flags; break;
     596      case ty_values:       uhash = (unsigned)t->d.values.list + t->d.values.count; break;
     597      case ty_memfunc:      uhash = (unsigned)t->d.memfunc.name + t->d.memfunc.offset; break;
     598      case ty_baseclass:    uhash = (unsigned)t->d.baseclass.type + t->d.baseclass.offset; break;
     599      default:
     600        return 0;
     601    }
     602  return (uhash ^ (uhash >> 13)) & (TYPE_HASH_MAX - 1);
     603}
     604
    562605
    563606/* Add a new internal type to the list of internal types.  If an
     
    566609   pointer to that type is returned.  It isn't worth my while to
    567610   improve the speed of this function, for instance by using
    568    hashing. */
     611   hashing.
     612
     613   Actually it is worth while optimizing it as it takes 85% of the
     614   time here... or rather it was. */
    569615
    570616static struct type *type_add (struct type *src)
    571617{
     618  unsigned ihash;
    572619  struct type *p;
    573620  int i;
    574621
    575   for (p = type_head; p != NULL; p = p->next)
    576     if (p->tag == src->tag)
    577       switch (p->tag)
    578         {
    579         case ty_alias:
    580           if (p->d.alias == src->d.alias)
    581             return p;
    582           break;
    583         case ty_stabs_ref:
    584           if (p->d.stabs_ref == src->d.stabs_ref)
    585             return p;
    586           break;
    587         case ty_prim:
    588           if (p->index == src->index)
    589             return p;
    590           break;
    591         case ty_pointer:
    592           if (p->d.pointer == src->d.pointer)
    593             return p;
    594           break;
    595         case ty_ref:
    596           if (p->d.ref == src->d.ref)
    597             return p;
    598           break;
    599         case ty_struc:
    600           if (p->d.struc.fields == src->d.struc.fields
    601               && p->d.struc.types == src->d.struc.types
    602               && p->d.struc.name == src->d.struc.name
    603               && p->d.struc.flags == src->d.struc.flags)
    604             return p;
    605           break;
    606         case ty_class:
    607           if (p->d.class.members == src->d.class.members
    608               && p->d.class.name == src->d.class.name)
    609             return p;
    610           break;
    611         case ty_enu:
    612           if (p->d.enu.type == src->d.enu.type
    613               && p->d.enu.values == src->d.enu.values
    614               && p->d.enu.name == src->d.enu.name)
    615             return p;
    616           break;
    617         case ty_array:
    618           if (p->d.array.etype == src->d.array.etype
    619               && p->d.array.itype == src->d.array.itype
    620               && p->d.array.first == src->d.array.first
    621               && p->d.array.last == src->d.array.last)
    622             return p;
    623           break;
    624         case ty_bits:
    625           if (p->d.bits.type == src->d.bits.type
    626               && p->d.bits.start == src->d.bits.start
    627               && p->d.bits.count == src->d.bits.count)
    628             return p;
    629           break;
    630         case ty_func:
    631           if (p->d.func.ret == src->d.func.ret
    632               && p->d.func.args == src->d.func.args
    633               && p->d.func.domain == src->d.func.domain
    634               && p->d.func.arg_count == src->d.func.arg_count)
    635             return p;
    636           break;
    637         case ty_args:
    638           if (p->d.args.count == src->d.args.count)
    639             {
    640               for (i = 0; i < p->d.args.count; ++i)
    641                 if (p->d.args.list[i] != src->d.args.list[i])
    642                   break;
    643               if (i >= p->d.args.count)
    644                 return p;
    645             }
    646           break;
    647         case ty_types:
    648           if (p->d.types.count == src->d.types.count)
    649             {
    650               for (i = 0; i < p->d.types.count; ++i)
    651                 if (p->d.types.list[i] != src->d.types.list[i])
    652                   break;
    653               if (i >= p->d.types.count)
    654                 return p;
    655             }
    656           break;
    657         case ty_fields:
    658           if (p->d.fields.count == src->d.fields.count)
    659             {
    660               for (i = 0; i < p->d.fields.count; ++i)
    661                 if (p->d.fields.list[i].offset != src->d.fields.list[i].offset
    662                     || p->d.fields.list[i].name != src->d.fields.list[i].name)
    663                   break;
    664               if (i >= p->d.fields.count)
    665                 return p;
    666             }
    667           break;
    668         case ty_member:
    669           if (p->d.member.type == src->d.member.type
    670               && p->d.member.offset == src->d.member.offset
    671               && p->d.member.flags == src->d.member.flags
    672               && p->d.member.name == src->d.member.name
    673               && p->d.member.sname == src->d.member.sname)
    674             return p;
    675           break;
    676         case ty_values:
    677           if (p->d.values.count == src->d.values.count)
    678             {
    679               for (i = 0; i < p->d.values.count; ++i)
    680                 if (p->d.values.list[i].index != src->d.values.list[i].index
    681                     || p->d.values.list[i].name != src->d.values.list[i].name)
    682                   break;
    683               if (i >= p->d.values.count)
    684                 return p;
    685             }
    686           break;
    687         case ty_memfunc:
    688           if (p->d.memfunc.type == src->d.memfunc.type
    689               && p->d.memfunc.offset == src->d.memfunc.offset
    690               && p->d.memfunc.flags == src->d.memfunc.flags
    691               && p->d.memfunc.name == src->d.memfunc.name
    692               && p->d.memfunc.mnglname == src->d.memfunc.mnglname)
    693             return p;
    694           break;
    695         case ty_baseclass:
    696           if (p->d.baseclass.type == src->d.baseclass.type
    697               && p->d.baseclass.offset == src->d.baseclass.offset
    698               && p->d.baseclass.flags == src->d.baseclass.flags)
    699             return p;
    700           break;
    701         default:
    702           abort ();
    703         }
     622  ihash = type_hash(src);
     623  for (p = atype_tag[ihash]; p != NULL; p = p->nexthash)
     624    switch (src->tag)
     625      {
     626      case ty_alias:
     627        if (p->d.alias == src->d.alias)
     628          return p;
     629        break;
     630      case ty_stabs_ref:
     631        if (p->d.stabs_ref == src->d.stabs_ref)
     632          return p;
     633        break;
     634      case ty_prim:
     635        if (p->index == src->index)
     636          return p;
     637        break;
     638      case ty_pointer:
     639        if (p->d.pointer == src->d.pointer)
     640          return p;
     641        break;
     642      case ty_ref:
     643        if (p->d.ref == src->d.ref)
     644          return p;
     645        break;
     646      case ty_struc:
     647        if (p->d.struc.fields == src->d.struc.fields
     648            && p->d.struc.types == src->d.struc.types
     649            && p->d.struc.name == src->d.struc.name
     650            && p->d.struc.flags == src->d.struc.flags)
     651          return p;
     652        break;
     653      case ty_class:
     654        if (p->d.class.members == src->d.class.members
     655            && p->d.class.name == src->d.class.name)
     656          return p;
     657        break;
     658      case ty_enu:
     659        if (p->d.enu.type == src->d.enu.type
     660            && p->d.enu.values == src->d.enu.values
     661            && p->d.enu.name == src->d.enu.name)
     662          return p;
     663        break;
     664      case ty_array:
     665        if (p->d.array.etype == src->d.array.etype
     666            && p->d.array.itype == src->d.array.itype
     667            && p->d.array.first == src->d.array.first
     668            && p->d.array.last == src->d.array.last)
     669          return p;
     670        break;
     671      case ty_bits:
     672        if (p->d.bits.type == src->d.bits.type
     673            && p->d.bits.start == src->d.bits.start
     674            && p->d.bits.count == src->d.bits.count)
     675          return p;
     676        break;
     677      case ty_func:
     678        if (p->d.func.ret == src->d.func.ret
     679            && p->d.func.args == src->d.func.args
     680            && p->d.func.domain == src->d.func.domain
     681            && p->d.func.arg_count == src->d.func.arg_count)
     682          return p;
     683        break;
     684      case ty_args:
     685        if (p->d.args.count == src->d.args.count)
     686          {
     687            for (i = 0; i < p->d.args.count; ++i)
     688              if (p->d.args.list[i] != src->d.args.list[i])
     689                break;
     690            if (i >= p->d.args.count)
     691              return p;
     692          }
     693        break;
     694      case ty_types:
     695        if (p->d.types.count == src->d.types.count)
     696          {
     697            for (i = 0; i < p->d.types.count; ++i)
     698              if (p->d.types.list[i] != src->d.types.list[i])
     699                break;
     700            if (i >= p->d.types.count)
     701              return p;
     702          }
     703        break;
     704      case ty_fields:
     705        if (p->d.fields.count == src->d.fields.count)
     706          {
     707            for (i = 0; i < p->d.fields.count; ++i)
     708              if (p->d.fields.list[i].offset != src->d.fields.list[i].offset
     709                  || p->d.fields.list[i].name != src->d.fields.list[i].name)
     710                break;
     711            if (i >= p->d.fields.count)
     712              return p;
     713          }
     714        break;
     715      case ty_member:
     716        if (p->d.member.type == src->d.member.type
     717            && p->d.member.offset == src->d.member.offset
     718            && p->d.member.flags == src->d.member.flags
     719            && p->d.member.name == src->d.member.name
     720            && p->d.member.sname == src->d.member.sname)
     721          return p;
     722        break;
     723      case ty_values:
     724        if (p->d.values.count == src->d.values.count)
     725          {
     726            for (i = 0; i < p->d.values.count; ++i)
     727              if (p->d.values.list[i].index != src->d.values.list[i].index
     728                  || p->d.values.list[i].name != src->d.values.list[i].name)
     729                break;
     730            if (i >= p->d.values.count)
     731              return p;
     732          }
     733        break;
     734      case ty_memfunc:
     735        if (p->d.memfunc.type == src->d.memfunc.type
     736            && p->d.memfunc.offset == src->d.memfunc.offset
     737            && p->d.memfunc.flags == src->d.memfunc.flags
     738            && p->d.memfunc.name == src->d.memfunc.name
     739            && p->d.memfunc.mnglname == src->d.memfunc.mnglname)
     740          return p;
     741        break;
     742      case ty_baseclass:
     743        if (p->d.baseclass.type == src->d.baseclass.type
     744            && p->d.baseclass.offset == src->d.baseclass.offset
     745            && p->d.baseclass.flags == src->d.baseclass.flags)
     746          return p;
     747        break;
     748      default:
     749        fprintf (stderr, "borked!\n");
     750        abort ();
     751      }
     752
     753#ifdef HASH_DEBUG
     754  ctypes++;
     755  ctype_tag[ihash]++;
     756#endif
     757
    704758  p = xmalloc (sizeof (*p));
    705759  *p = *src;
    706760  p->next = type_head;
    707761  type_head = p;
     762  p->nexthash = atype_tag[ihash];
     763  atype_tag[ihash] = p;
    708764  switch (src->tag)
    709765    {
     
    35353591      }
    35363592
     3593#ifdef HASH_DEBUG
     3594fprintf(stderr, "ctypes=%d\n", ctypes);
     3595for (i = 0; i < TYPE_HASH_MAX; i++)
     3596  fprintf(stderr, "%2d - %d\n", i, ctype_tag[i]);
     3597#endif
     3598
    35373599  /* Create tags for structures, unions and classes. */
    35383600
     
    35983660    }
    35993661  type_head = NULL;
     3662  memset (&atype_tag, 0, sizeof(atype_tag));
    36003663  strpool_free (str_pool);
    36013664  str_pool = NULL;
Note: See TracChangeset for help on using the changeset viewer.