Changeset 390


Ignore:
Timestamp:
Jul 15, 2003, 9:09:02 PM (22 years ago)
Author:
bird
Message:

#456: Fixed the hashing?

File:
1 edited

Legend:

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

    • Property cvs2svn:cvs-rev changed from 1.13 to 1.14
    r389 r390  
    2020Boston, MA 02111-1307, USA.  */
    2121
     22#define HASH_DEBUG
    2223
    2324/*******************************************************************************
     
    298299static struct type *type_head;
    299300#define TYPE_HASH_MAX   128
    300 static struct type *atype_tag[TYPE_HASH_MAX + 1];
     301static struct type *atype_tag[TYPE_HASH_MAX];
    301302#ifdef HASH_DEBUG
    302303static int          ctypes = 0;
    303 static int          ctype_tag[TYPE_HASH_MAX + 1];
     304static int          ctype_tag[TYPE_HASH_MAX];
    304305#endif
    305306
     
    576577static unsigned type_hash (struct type *t)
    577578{
    578   unsigned uhash;
     579  unsigned uhash = 0;
    579580  switch (t->tag)
    580581    {
     
    590591      case ty_bits:         uhash = (unsigned)t->d.bits.type; break;
    591592      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     }
     593      case ty_types:        uhash = (unsigned)t->d.types.count  <<2; break;
     594      case ty_args:         uhash = (unsigned)t->d.args.count   <<2; break;
     595      case ty_fields:       uhash = (unsigned)t->d.fields.count <<2; break;
     596      case ty_member:       uhash = (unsigned)t->d.member.type; break;
     597      case ty_values:       uhash = (unsigned)t->d.values.count <<2; break;
     598      case ty_memfunc:      uhash = (unsigned)t->d.memfunc.type; break;
     599      case ty_baseclass:    uhash = (unsigned)t->d.baseclass.type; break;
     600    }
     601  uhash += t->tag;
    602602  return (uhash ^ (uhash >> 13)) & (TYPE_HASH_MAX - 1);
    603603}
     
    622622  ihash = type_hash(src);
    623623  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       }
     624    if (p->tag == src->tag)
     625      switch (p->tag)
     626        {
     627        case ty_alias:
     628          if (p->d.alias == src->d.alias)
     629            return p;
     630          break;
     631        case ty_stabs_ref:
     632          if (p->d.stabs_ref == src->d.stabs_ref)
     633            return p;
     634          break;
     635        case ty_prim:
     636          if (p->index == src->index)
     637            return p;
     638          break;
     639        case ty_pointer:
     640          if (p->d.pointer == src->d.pointer)
     641            return p;
     642          break;
     643        case ty_ref:
     644          if (p->d.ref == src->d.ref)
     645            return p;
     646          break;
     647        case ty_struc:
     648          if (p->d.struc.fields == src->d.struc.fields
     649              && p->d.struc.types == src->d.struc.types
     650              && p->d.struc.name == src->d.struc.name
     651              && p->d.struc.flags == src->d.struc.flags)
     652            return p;
     653          break;
     654        case ty_class:
     655          if (p->d.class.members == src->d.class.members
     656              && p->d.class.name == src->d.class.name)
     657            return p;
     658          break;
     659        case ty_enu:
     660          if (p->d.enu.type == src->d.enu.type
     661              && p->d.enu.values == src->d.enu.values
     662              && p->d.enu.name == src->d.enu.name)
     663            return p;
     664          break;
     665        case ty_array:
     666          if (p->d.array.etype == src->d.array.etype
     667              && p->d.array.itype == src->d.array.itype
     668              && p->d.array.first == src->d.array.first
     669              && p->d.array.last == src->d.array.last)
     670            return p;
     671          break;
     672        case ty_bits:
     673          if (p->d.bits.type == src->d.bits.type
     674              && p->d.bits.start == src->d.bits.start
     675              && p->d.bits.count == src->d.bits.count)
     676            return p;
     677          break;
     678        case ty_func:
     679          if (p->d.func.ret == src->d.func.ret
     680              && p->d.func.args == src->d.func.args
     681              && p->d.func.domain == src->d.func.domain
     682              && p->d.func.arg_count == src->d.func.arg_count)
     683            return p;
     684          break;
     685        case ty_args:
     686          if (p->d.args.count == src->d.args.count)
     687            {
     688              for (i = 0; i < p->d.args.count; ++i)
     689                if (p->d.args.list[i] != src->d.args.list[i])
     690                  break;
     691              if (i >= p->d.args.count)
     692                return p;
     693            }
     694          break;
     695        case ty_types:
     696          if (p->d.types.count == src->d.types.count)
     697            {
     698              for (i = 0; i < p->d.types.count; ++i)
     699                if (p->d.types.list[i] != src->d.types.list[i])
     700                  break;
     701              if (i >= p->d.types.count)
     702                return p;
     703            }
     704          break;
     705        case ty_fields:
     706          if (p->d.fields.count == src->d.fields.count)
     707            {
     708              for (i = 0; i < p->d.fields.count; ++i)
     709                if (p->d.fields.list[i].offset != src->d.fields.list[i].offset
     710                    || p->d.fields.list[i].name != src->d.fields.list[i].name)
     711                  break;
     712              if (i >= p->d.fields.count)
     713                return p;
     714            }
     715          break;
     716        case ty_member:
     717          if (p->d.member.type == src->d.member.type
     718              && p->d.member.offset == src->d.member.offset
     719              && p->d.member.flags == src->d.member.flags
     720              && p->d.member.name == src->d.member.name
     721              && p->d.member.sname == src->d.member.sname)
     722            return p;
     723          break;
     724        case ty_values:
     725          if (p->d.values.count == src->d.values.count)
     726            {
     727              for (i = 0; i < p->d.values.count; ++i)
     728                if (p->d.values.list[i].index != src->d.values.list[i].index
     729                    || p->d.values.list[i].name != src->d.values.list[i].name)
     730                  break;
     731              if (i >= p->d.values.count)
     732                return p;
     733            }
     734          break;
     735        case ty_memfunc:
     736          if (p->d.memfunc.type == src->d.memfunc.type
     737              && p->d.memfunc.offset == src->d.memfunc.offset
     738              && p->d.memfunc.flags == src->d.memfunc.flags
     739              && p->d.memfunc.name == src->d.memfunc.name
     740              && p->d.memfunc.mnglname == src->d.memfunc.mnglname)
     741            return p;
     742          break;
     743        case ty_baseclass:
     744          if (p->d.baseclass.type == src->d.baseclass.type
     745              && p->d.baseclass.offset == src->d.baseclass.offset
     746              && p->d.baseclass.flags == src->d.baseclass.flags)
     747            return p;
     748          break;
     749        default:
     750          abort ();
     751        }
    752752
    753753#ifdef HASH_DEBUG
     
    35923592
    35933593#ifdef HASH_DEBUG
    3594 fprintf(stderr, "ctypes=%d\n", ctypes);
    35953594for (i = 0; i < TYPE_HASH_MAX; i++)
    3596   fprintf(stderr, "%2d - %d\n", i, ctype_tag[i]);
     3595  if (i % 7 == 6)
     3596    fprintf(stderr, "%3d: %4d\n", i, ctype_tag[i]);
     3597  else
     3598    fprintf(stderr, "%3d: %4d   ", i, ctype_tag[i]);
     3599fprintf(stderr, "\nctypes=%d\n", ctypes);
    35973600#endif
    35983601
Note: See TracChangeset for help on using the changeset viewer.