debugger/hash.c

   1 /*
   2  * File hash.c - generate hash tables for Wine debugger symbols
   3  *
   4  * Copyright (C) 1993, Eric Youngdale.
   5  */
   6
   7
   8 #include "config.h"
   9 #include <stdlib.h>
  10 #include <stdio.h>
  11 #include <string.h>
  12 #include <limits.h>
  13 #include <sys/types.h>
  14 #include "neexe.h"
  15 #include "module.h"
  16 #include "process.h"
  17 #include "selectors.h"
  18 #include "debugger.h"
  19 #include "toolhelp.h"
  20 #include "xmalloc.h"
  21
  22 #define NR_NAME_HASH 16384
  23 #ifndef PATH_MAX
  24 #define PATH_MAX _MAX_PATH
  25 #endif
  26
  27 static char * reg_name[] =
  28 {
  29   "eax", "ecx", "edx", "ebx", "esp", "ebp", "esi", "edi"
  30 };
  31
  32 static unsigned reg_ofs[] =
  33 {
  34   FIELD_OFFSET(CONTEXT, Eax), FIELD_OFFSET(CONTEXT, Ecx),
  35   FIELD_OFFSET(CONTEXT, Edx), FIELD_OFFSET(CONTEXT, Ebx),
  36   FIELD_OFFSET(CONTEXT, Esp), FIELD_OFFSET(CONTEXT, Ebp),
  37   FIELD_OFFSET(CONTEXT, Esi), FIELD_OFFSET(CONTEXT, Edi)
  38 };
  39
  40
  41 struct name_hash
  42 {
  43     struct name_hash * next;            /* Used to look up within name hash */
  44     char *             name;
  45     char *             sourcefile;
  46
  47     int                n_locals;
  48     int                locals_alloc;
  49     WineLocals       * local_vars;
  50
  51     int                n_lines;
  52     int                lines_alloc;
  53     WineLineNo       * linetab;
  54
  55     DBG_ADDR           addr;
  56     unsigned short     flags;
  57     unsigned short     breakpoint_offset;
  58     unsigned int       symbol_size;
  59 };
  60
  61
  62 static BOOL DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr );
  63 static int sortlist_valid = FALSE;
  64
  65 static int sorttab_nsym;
  66 static struct name_hash ** addr_sorttab = NULL;
  67
  68 static struct name_hash * name_hash_table[NR_NAME_HASH];
  69
  70 static unsigned int name_hash( const char * name )
  71 {
  72     unsigned int hash = 0;
  73     unsigned int tmp;
  74     const char * p;
  75
  76     p = name;
  77
  78     while (*p)
  79       {
  80         hash = (hash << 4) + *p++;
  81
  82         if( (tmp = (hash & 0xf0000000)) )
  83           {
  84             hash ^= tmp >> 24;
  85           }
  86         hash &= ~tmp;
  87       }
  88     return hash % NR_NAME_HASH;
  89 }
  90
  91 int
  92 DEBUG_cmp_sym(const void * p1, const void * p2)
  93 {
  94   struct name_hash ** name1 = (struct name_hash **) p1;
  95   struct name_hash ** name2 = (struct name_hash **) p2;
  96
  97   if( ((*name1)->flags & SYM_INVALID) != 0 )
  98     {
  99       return -1;
 100     }
 101
 102   if( ((*name2)->flags & SYM_INVALID) != 0 )
 103     {
 104       return 1;
 105     }
 106
 107   if( (*name1)->addr.seg > (*name2)->addr.seg )
 108     {
 109       return 1;
 110     }
 111
 112   if( (*name1)->addr.seg < (*name2)->addr.seg )
 113     {
 114       return -1;
 115     }
 116
 117   if( (*name1)->addr.off > (*name2)->addr.off )
 118     {
 119       return 1;
 120     }
 121
 122   if( (*name1)->addr.off < (*name2)->addr.off )
 123     {
 124       return -1;
 125     }
 126
 127   return 0;
 128 }
 129
 130 /***********************************************************************
 131  *           DEBUG_ResortSymbols
 132  *
 133  * Rebuild sorted list of symbols.
 134  */
 135 static
 136 void
 137 DEBUG_ResortSymbols()
 138 {
 139     struct name_hash *nh;
 140     int         nsym = 0;
 141     int         i;
 142
 143     for(i=0; i<NR_NAME_HASH; i++)
 144     {
 145         for (nh = name_hash_table[i]; nh; nh = nh->next)
 146           {
 147             nsym++;
 148           }
 149     }
 150
 151     sorttab_nsym = nsym;
 152     if( nsym == 0 )
 153       {
 154         return;
 155       }
 156
 157     addr_sorttab = (struct name_hash **) xrealloc(addr_sorttab,
 158                                          nsym * sizeof(struct name_hash *));
 159
 160     nsym = 0;
 161     for(i=0; i<NR_NAME_HASH; i++)
 162     {
 163         for (nh = name_hash_table[i]; nh; nh = nh->next)
 164           {
 165             addr_sorttab[nsym++] = nh;
 166           }
 167     }
 168
 169     qsort(addr_sorttab, nsym,
 170           sizeof(struct name_hash *), DEBUG_cmp_sym);
 171     sortlist_valid = TRUE;
 172
 173 }
 174
 175 /***********************************************************************
 176  *           DEBUG_AddSymbol
 177  *
 178  * Add a symbol to the table.
 179  */
 180 struct name_hash *
 181 DEBUG_AddSymbol( const char * name, const DBG_ADDR *addr, const char * source,
 182                  int flags)
 183 {
 184     struct name_hash  * new;
 185     struct name_hash *nh;
 186     static char  prev_source[PATH_MAX] = {'\0', };
 187     static char * prev_duped_source = NULL;
 188     char * c;
 189     int hash;
 190
 191     hash = name_hash(name);
 192     for (nh = name_hash_table[hash]; nh; nh = nh->next)
 193     {
 194         if( ((nh->flags & SYM_INVALID) != 0) && strcmp(name, nh->name) == 0 )
 195         {
 196             nh->addr.off = addr->off;
 197             nh->addr.seg = addr->seg;
 198             if( nh->addr.type == NULL && addr->type != NULL )
 199             {
 200                 nh->addr.type = addr->type;
 201             }
 202             nh->flags &= ~SYM_INVALID;
 203             return nh;
 204         }
 205         if (nh->addr.seg == addr->seg &&
 206             nh->addr.off == addr->off &&
 207             strcmp(name, nh->name) == 0 )
 208         {
 209             return nh;
 210         }
 211     }
 212
 213     /*
 214      * First see if we already have an entry for this symbol.  If so
 215      * return it, so we don't end up with duplicates.
 216      */
 217
 218     new = (struct name_hash *) xmalloc(sizeof(struct name_hash));
 219     new->addr = *addr;
 220     new->name = xstrdup(name);
 221
 222     if( source != NULL )
 223       {
 224         /*
 225          * This is an enhancement to reduce memory consumption.  The idea
 226          * is that we duplicate a given string only once.  This is a big
 227          * win if there are lots of symbols defined in a given source file.
 228          */
 229         if( strcmp(source, prev_source) == 0 )
 230           {
 231             new->sourcefile = prev_duped_source;
 232           }
 233         else
 234           {
 235             strcpy(prev_source, source);
 236             prev_duped_source = new->sourcefile = xstrdup(source);
 237           }
 238       }
 239     else
 240       {
 241         new->sourcefile = NULL;
 242       }
 243
 244     new->n_lines        = 0;
 245     new->lines_alloc    = 0;
 246     new->linetab        = NULL;
 247
 248     new->n_locals       = 0;
 249     new->locals_alloc   = 0;
 250     new->local_vars     = NULL;
 251
 252     new->flags          = flags;
 253     new->next           = NULL;
 254
 255     /* Now insert into the hash table */
 256     new->next = name_hash_table[hash];
 257     name_hash_table[hash] = new;
 258
 259     /*
 260      * Check some heuristics based upon the file name to see whether
 261      * we want to step through this guy or not.  These are machine generated
 262      * assembly files that are used to translate between the MS way of
 263      * calling things and the GCC way of calling things.  In general we
 264      * always want to step through.
 265      */
 266     if( source != NULL )
 267       {
 268         c = strrchr(source, '.');
 269         if( c != NULL && strcmp(c, ".s") == 0 )
 270           {
 271             c = strrchr(source, '/');
 272             if( c != NULL )
 273               {
 274                 c++;
 275                 if(    (strcmp(c, "callfrom16.s") == 0)
 276                     || (strcmp(c, "callto16.s") == 0)
 277                     || (strcmp(c, "call32.s") == 0) )
 278                   {
 279                     new->flags |= SYM_TRAMPOLINE;
 280                   }
 281               }
 282           }
 283       }
 284
 285     sortlist_valid = FALSE;
 286     return new;
 287 }
 288
 289 BOOL DEBUG_Normalize(struct name_hash * nh )
 290 {
 291
 292   /*
 293    * We aren't adding any more locals or linenumbers to this function.
 294    * Free any spare memory that we might have allocated.
 295    */
 296   if( nh == NULL )
 297     {
 298       return TRUE;
 299     }
 300
 301   if( nh->n_locals != nh->locals_alloc )
 302     {
 303       nh->locals_alloc = nh->n_locals;
 304       nh->local_vars = xrealloc(nh->local_vars,
 305                                   nh->locals_alloc * sizeof(WineLocals));
 306     }
 307
 308   if( nh->n_lines != nh->lines_alloc )
 309     {
 310       nh->lines_alloc = nh->n_lines;
 311       nh->linetab = xrealloc(nh->linetab,
 312                               nh->lines_alloc * sizeof(WineLineNo));
 313     }
 314
 315   return TRUE;
 316 }
 317
 318 /***********************************************************************
 319  *           DEBUG_GetSymbolValue
 320  *
 321  * Get the address of a named symbol.
 322  */
 323 BOOL DEBUG_GetSymbolValue( const char * name, const int lineno,
 324                              DBG_ADDR *addr, int bp_flag )
 325 {
 326     char buffer[256];
 327     struct name_hash *nh;
 328
 329     for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
 330       {
 331         if( (nh->flags & SYM_INVALID) != 0 )
 332           {
 333             continue;
 334           }
 335
 336         if (!strcmp(nh->name, name)) break;
 337       }
 338
 339     if (!nh && (name[0] != '_'))
 340     {
 341         buffer[0] = '_';
 342         strcpy(buffer+1, name);
 343         for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next)
 344           {
 345             if( (nh->flags & SYM_INVALID) != 0 )
 346               {
 347                 continue;
 348               }
 349             if (!strcmp(nh->name, buffer)) break;
 350           }
 351     }
 352
 353     /*
 354      * If we don't have anything here, then try and see if this
 355      * is a local symbol to the current stack frame.  No matter
 356      * what, we have nothing more to do, so we let that function
 357      * decide what we ultimately return.
 358      */
 359     if (!nh)
 360       {
 361         return DEBUG_GetStackSymbolValue(name, addr);
 362       }
 363
 364     return DEBUG_GetLineNumberAddr( nh, lineno, addr, bp_flag );
 365 }
 366
 367 /***********************************************************************
 368  *           DEBUG_GetLineNumberAddr
 369  *
 370  * Get the address of a named symbol.
 371  */
 372 BOOL DEBUG_GetLineNumberAddr( struct name_hash * nh, const int lineno,
 373                                 DBG_ADDR *addr, int bp_flag )
 374 {
 375     int i;
 376
 377     if( lineno == -1 )
 378       {
 379         *addr = nh->addr;
 380         if( bp_flag )
 381           {
 382             addr->off += nh->breakpoint_offset;
 383           }
 384       }
 385     else
 386       {
 387         /*
 388          * Search for the specific line number.  If we don't find it,
 389          * then return FALSE.
 390          */
 391         if( nh->linetab == NULL )
 392           {
 393             return FALSE;
 394           }
 395
 396         for(i=0; i < nh->n_lines; i++ )
 397           {
 398             if( nh->linetab[i].line_number == lineno )
 399               {
 400                 *addr = nh->linetab[i].pc_offset;
 401                 return TRUE;
 402               }
 403           }
 404
 405         /*
 406          * This specific line number not found.
 407          */
 408         return FALSE;
 409       }
 410
 411     return TRUE;
 412 }
 413
 414
 415 /***********************************************************************
 416  *           DEBUG_SetSymbolValue
 417  *
 418  * Set the address of a named symbol.
 419  */
 420 BOOL DEBUG_SetSymbolValue( const char * name, const DBG_ADDR *addr )
 421 {
 422     char buffer[256];
 423     struct name_hash *nh;
 424
 425     for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
 426         if (!strcmp(nh->name, name)) break;
 427
 428     if (!nh && (name[0] != '_'))
 429     {
 430         buffer[0] = '_';
 431         strcpy(buffer+1, name);
 432         for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next)
 433             if (!strcmp(nh->name, buffer)) break;
 434     }
 435
 436     if (!nh) return FALSE;
 437     nh->addr = *addr;
 438     nh->flags &= SYM_INVALID;
 439     DBG_FIX_ADDR_SEG( &nh->addr, DS_reg(&DEBUG_context) );
 440     return TRUE;
 441 }
 442
 443
 444 /***********************************************************************
 445  *           DEBUG_FindNearestSymbol
 446  *
 447  * Find the symbol nearest to a given address.
 448  * If ebp is specified as non-zero, it means we should dump the argument
 449  * list into the string we return as well.
 450  */
 451 const char * DEBUG_FindNearestSymbol( const DBG_ADDR *addr, int flag,
 452                                       struct name_hash ** rtn,
 453                                       unsigned int ebp,
 454                                       struct list_id * source)
 455 {
 456     static char name_buffer[MAX_PATH + 256];
 457     static char arglist[1024];
 458     static char argtmp[256];
 459     struct name_hash * nearest = NULL;
 460     int mid, high, low;
 461     unsigned    int * ptr;
 462     int lineno;
 463     char * lineinfo, *sourcefile;
 464     int i;
 465     char linebuff[16];
 466
 467     if( rtn != NULL )
 468       {
 469         *rtn = NULL;
 470       }
 471
 472     if( source != NULL )
 473       {
 474         source->sourcefile = NULL;
 475         source->line = -1;
 476       }
 477
 478     if( sortlist_valid == FALSE )
 479       {
 480         DEBUG_ResortSymbols();
 481       }
 482
 483     if( sortlist_valid == FALSE )
 484       {
 485         return NULL;
 486       }
 487
 488     /*
 489      * FIXME  - use the binary search that we added to
 490      * the function DEBUG_CheckLinenoStatus.  Better yet, we should
 491      * probably keep some notion of the current function so we don't
 492      * have to search every time.
 493      */
 494     /*
 495      * Binary search to find closest symbol.
 496      */
 497     low = 0;
 498     high = sorttab_nsym;
 499     if( addr_sorttab[0]->addr.seg > addr->seg
 500         || (   addr_sorttab[0]->addr.seg == addr->seg
 501             && addr_sorttab[0]->addr.off > addr->off) )
 502       {
 503         nearest = NULL;
 504       }
 505     else if( addr_sorttab[high - 1]->addr.seg < addr->seg
 506         || (   addr_sorttab[high - 1]->addr.seg == addr->seg
 507             && addr_sorttab[high - 1]->addr.off < addr->off) )
 508       {
 509         nearest = addr_sorttab[high - 1];
 510       }
 511     else
 512       {
 513         while(1==1)
 514           {
 515             mid = (high + low)/2;
 516             if( mid == low )
 517               {
 518                 /*
 519                  * See if there are any other entries that might also
 520                  * have the same address, and would also have a line
 521                  * number table.
 522                  */
 523                 if( mid > 0 && addr_sorttab[mid]->linetab == NULL )
 524                   {
 525                     if(    (addr_sorttab[mid - 1]->addr.seg ==
 526                             addr_sorttab[mid]->addr.seg)
 527                         && (addr_sorttab[mid - 1]->addr.off ==
 528                             addr_sorttab[mid]->addr.off)
 529                         && (addr_sorttab[mid - 1]->linetab != NULL) )
 530                       {
 531                         mid--;
 532                       }
 533                   }
 534
 535                 if(    (mid < sorttab_nsym - 1)
 536                     && (addr_sorttab[mid]->linetab == NULL) )
 537                   {
 538                     if(    (addr_sorttab[mid + 1]->addr.seg ==
 539                             addr_sorttab[mid]->addr.seg)
 540                         && (addr_sorttab[mid + 1]->addr.off ==
 541                             addr_sorttab[mid]->addr.off)
 542                         && (addr_sorttab[mid + 1]->linetab != NULL) )
 543                       {
 544                         mid++;
 545                       }
 546                   }
 547                 nearest = addr_sorttab[mid];
 548 #if 0
 549                 fprintf(stderr, "Found %x:%x when looking for %x:%x %x %s\n",
 550                         addr_sorttab[mid ]->addr.seg,
 551                         addr_sorttab[mid ]->addr.off,
 552                         addr->seg, addr->off,
 553                         addr_sorttab[mid ]->linetab,
 554                         addr_sorttab[mid ]->name);
 555 #endif
 556                 break;
 557               }
 558             if(    (addr_sorttab[mid]->addr.seg < addr->seg)
 559                 || (   addr_sorttab[mid]->addr.seg == addr->seg
 560                     && addr_sorttab[mid]->addr.off <= addr->off) )
 561               {
 562                 low = mid;
 563               }
 564             else
 565               {
 566                 high = mid;
 567               }
 568           }
 569       }
 570
 571     if (!nearest) return NULL;
 572
 573     if( rtn != NULL )
 574       {
 575         *rtn = nearest;
 576       }
 577
 578     /*
 579      * Fill in the relevant bits to the structure so that we can
 580      * locate the source and line for this bit of code.
 581      */
 582     if( source != NULL )
 583       {
 584         source->sourcefile = nearest->sourcefile;
 585         if( nearest->linetab == NULL )
 586           {
 587             source->line = -1;
 588           }
 589         else
 590           {
 591             source->line = nearest->linetab[0].line_number;
 592           }
 593       }
 594
 595     lineinfo = "";
 596     lineno = -1;
 597
 598     /*
 599      * Prepare to display the argument list.  If ebp is specified, it is
 600      * the framepointer for the function in question.  If not specified,
 601      * we don't want the arglist.
 602      */
 603     memset(arglist, '\0', sizeof(arglist));
 604     if( ebp != 0 )
 605       {
 606         for(i=0; i < nearest->n_locals; i++ )
 607           {
 608             /*
 609              * If this is a register (offset == 0) or a local
 610              * variable, we don't want to know about it.
 611              */
 612             if( nearest->local_vars[i].offset <= 0 )
 613               {
 614                 continue;
 615               }
 616
 617             ptr = (unsigned int *) (ebp + nearest->local_vars[i].offset);
 618             if( arglist[0] == '\0' )
 619               {
 620                 arglist[0] = '(';
 621               }
 622             else
 623               {
 624                 strcat(arglist, ", ");
 625               }
 626
 627             sprintf(argtmp, "%s=0x%x", nearest->local_vars[i].name,
 628                     *ptr);
 629             strcat(arglist, argtmp);
 630           }
 631         if( arglist[0] == '(' )
 632           {
 633             strcat(arglist, ")");
 634           }
 635       }
 636
 637     if( (nearest->sourcefile != NULL) && (flag == TRUE)
 638         && (addr->off - nearest->addr.off < 0x100000) )
 639       {
 640
 641         /*
 642          * Try and find the nearest line number to the current offset.
 643          */
 644         if( nearest->linetab != NULL )
 645         {
 646             low = 0;
 647             high = nearest->n_lines;
 648             while ((high - low) > 1)
 649             {
 650                 mid = (high + low) / 2;
 651                 if (addr->off < nearest->linetab[mid].pc_offset.off)
 652                     high = mid;
 653                 else
 654                     low = mid;
 655             }
 656             lineno = nearest->linetab[low].line_number;
 657         }
 658
 659         if( lineno != -1 )
 660           {
 661             sprintf(linebuff, ":%d", lineno);
 662             lineinfo = linebuff;
 663             if( source != NULL )
 664               {
 665                 source->line = lineno;
 666               }
 667           }
 668
 669         /* Remove the path from the file name */
 670         sourcefile = strrchr( nearest->sourcefile, '/' );
 671         if (!sourcefile) sourcefile = nearest->sourcefile;
 672         else sourcefile++;
 673
 674         if (addr->off == nearest->addr.off)
 675           sprintf( name_buffer, "%s%s [%s%s]", nearest->name,
 676                    arglist, sourcefile, lineinfo);
 677         else
 678           sprintf( name_buffer, "%s+0x%lx%s [%s%s]", nearest->name,
 679                    addr->off - nearest->addr.off,
 680                    arglist, sourcefile, lineinfo );
 681       }
 682     else
 683       {
 684         if (addr->off == nearest->addr.off)
 685           sprintf( name_buffer, "%s%s", nearest->name, arglist);
 686         else {
 687           if (addr->seg && (nearest->addr.seg!=addr->seg))
 688               return NULL;
 689           else
 690               sprintf( name_buffer, "%s+0x%lx%s", nearest->name,
 691                        addr->off - nearest->addr.off, arglist);
 692         }
 693       }
 694     return name_buffer;
 695 }
 696
 697
 698 /***********************************************************************
 699  *           DEBUG_ReadSymbolTable
 700  *
 701  * Read a symbol file into the hash table.
 702  */
 703 void DEBUG_ReadSymbolTable( const char * filename )
 704 {
 705     FILE * symbolfile;
 706     DBG_ADDR addr = { 0, 0 };
 707     int nargs;
 708     char type;
 709     char * cpnt;
 710     char buffer[256];
 711     char name[256];
 712
 713     if (!(symbolfile = fopen(filename, "r")))
 714     {
 715         fprintf( stderr, "Unable to open symbol table %s\n", filename );
 716         return;
 717     }
 718
 719     fprintf( stderr, "Reading symbols from file %s\n", filename );
 720
 721     while (1)
 722     {
 723         fgets( buffer, sizeof(buffer), symbolfile );
 724         if (feof(symbolfile)) break;
 725
 726         /* Strip any text after a # sign (i.e. comments) */
 727         cpnt = buffer;
 728         while (*cpnt)
 729             if(*cpnt++ == '#') { *cpnt = 0; break; }
 730
 731         /* Quietly ignore any lines that have just whitespace */
 732         cpnt = buffer;
 733         while(*cpnt)
 734         {
 735             if(*cpnt != ' ' && *cpnt != '\t') break;
 736             cpnt++;
 737         }
 738         if (!(*cpnt) || *cpnt == '\n') continue;
 739
 740         nargs = sscanf(buffer, "%lx %c %s", &addr.off, &type, name);
 741         DEBUG_AddSymbol( name, &addr, NULL, SYM_WINE );
 742     }
 743     fclose(symbolfile);
 744 }
 745
 746
 747 /***********************************************************************
 748  *           DEBUG_LoadEntryPoints16
 749  *
 750  * Load the entry points of a Win16 module into the hash table.
 751  */
 752 static void DEBUG_LoadEntryPoints16( HMODULE16 hModule, NE_MODULE *pModule,
 753                                      const char *name )
 754 {
 755     DBG_ADDR addr;
 756     char buffer[256];
 757     FARPROC16 address;
 758
 759     /* First search the resident names */
 760
 761     unsigned char *cpnt = (unsigned char *)pModule + pModule->name_table;
 762     while (*cpnt)
 763     {
 764         cpnt += *cpnt + 1 + sizeof(WORD);
 765         sprintf( buffer, "%s.%.*s", name, *cpnt, cpnt + 1 );
 766         if ((address = NE_GetEntryPoint(hModule, *(WORD *)(cpnt + *cpnt + 1))))
 767         {
 768             addr.seg = HIWORD(address);
 769             addr.off = LOWORD(address);
 770             addr.type = NULL;
 771             DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 772         }
 773     }
 774
 775     /* Now search the non-resident names table */
 776
 777     if (!pModule->nrname_handle) return;  /* No non-resident table */
 778     cpnt = (char *)GlobalLock16( pModule->nrname_handle );
 779     while (*cpnt)
 780     {
 781         cpnt += *cpnt + 1 + sizeof(WORD);
 782         sprintf( buffer, "%s.%.*s", name, *cpnt, cpnt + 1 );
 783         if ((address = NE_GetEntryPoint(hModule, *(WORD *)(cpnt + *cpnt + 1))))
 784         {
 785             addr.seg = HIWORD(address);
 786             addr.off = LOWORD(address);
 787             addr.type = NULL;
 788             DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 789         }
 790     }
 791 }
 792
 793
 794 /***********************************************************************
 795  *           DEBUG_LoadEntryPoints32
 796  *
 797  * Load the entry points of a Win32 module into the hash table.
 798  */
 799 static void DEBUG_LoadEntryPoints32( HMODULE hModule, const char *name )
 800 {
 801 #define RVA(x) (hModule+(DWORD)(x))
 802
 803     DBG_ADDR addr;
 804     char buffer[256];
 805     int i, j;
 806     IMAGE_SECTION_HEADER *pe_seg;
 807     IMAGE_EXPORT_DIRECTORY *exports;
 808     IMAGE_DATA_DIRECTORY *dir;
 809     WORD *ordinals;
 810     void **functions;
 811     const char **names;
 812
 813     addr.seg = 0;
 814     addr.type = NULL;
 815
 816     /* Add start of DLL */
 817
 818     addr.off = hModule;
 819     DEBUG_AddSymbol( name, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 820
 821     /* Add entry point */
 822
 823     sprintf( buffer, "%s.EntryPoint", name );
 824     addr.off = (DWORD)RVA_PTR( hModule, OptionalHeader.AddressOfEntryPoint );
 825     DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 826
 827     /* Add start of sections */
 828
 829     pe_seg = PE_SECTIONS(hModule);
 830     for (i = 0; i < PE_HEADER(hModule)->FileHeader.NumberOfSections; i++)
 831     {
 832         sprintf( buffer, "%s.%s", name, pe_seg->Name );
 833         addr.off = RVA(pe_seg->VirtualAddress );
 834         DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 835         pe_seg++;
 836     }
 837
 838     /* Add exported functions */
 839
 840     dir = &PE_HEADER(hModule)->OptionalHeader.
 841                                    DataDirectory[IMAGE_DIRECTORY_ENTRY_EXPORT];
 842     if (dir->Size)
 843     {
 844       exports   = (IMAGE_EXPORT_DIRECTORY *)RVA( dir->VirtualAddress );
 845       ordinals  = (WORD *)RVA( exports->AddressOfNameOrdinals );
 846       names     = (const char **)RVA( exports->AddressOfNames );
 847       functions = (void **)RVA( exports->AddressOfFunctions );
 848
 849       for (i = 0; i < exports->NumberOfNames; i++)
 850       {
 851           if (!names[i]) continue;
 852           sprintf( buffer, "%s.%s", name, (char *)RVA(names[i]) );
 853           addr.off = RVA( functions[ordinals[i]] );
 854         DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 855       }
 856
 857       for (i = 0; i < exports->NumberOfFunctions; i++)
 858       {
 859           if (!functions[i]) continue;
 860           /* Check if we already added it with a name */
 861           for (j = 0; j < exports->NumberOfNames; j++)
 862             if ((ordinals[j] == i) && names[j]) break;
 863           if (j < exports->NumberOfNames) continue;
 864           sprintf( buffer, "%s.%ld", name, i + exports->Base );
 865           addr.off = (DWORD)RVA( functions[i] );
 866           DEBUG_AddSymbol( buffer, &addr, NULL, SYM_WIN32 | SYM_FUNC );
 867       }
 868     }
 869     DEBUG_RegisterDebugInfo(hModule, name);
 870 #undef RVA
 871 }
 872
 873
 874 /***********************************************************************
 875  *           DEBUG_LoadEntryPoints
 876  *
 877  * Load the entry points of all the modules into the hash table.
 878  */
 879 void DEBUG_LoadEntryPoints(void)
 880 {
 881     MODULEENTRY entry;
 882     NE_MODULE *pModule;
 883     BOOL ok;
 884     WINE_MODREF *wm;
 885     int rowcount = 3;
 886
 887     fprintf( stderr, "   " );
 888     for (ok = ModuleFirst16(&entry); ok; ok = ModuleNext16(&entry))
 889     {
 890         if (!(pModule = NE_GetPtr( entry.hModule ))) continue;
 891         if (!(pModule->flags & NE_FFLAGS_WIN32))  /* NE module */
 892           {
 893         if ((rowcount + strlen(entry.szModule)) > 76)
 894         {
 895             fprintf( stderr,"\n   ");
 896             rowcount = 3;
 897         }
 898         fprintf( stderr, " %s", entry.szModule );
 899         rowcount += strlen(entry.szModule) + 1;
 900
 901             DEBUG_LoadEntryPoints16( entry.hModule, pModule, entry.szModule );
 902           }
 903     }
 904     for (wm=PROCESS_Current()->modref_list;wm;wm=wm->next)
 905     {
 906         if ((rowcount + strlen(wm->modname)) > 76)
 907         {
 908             fprintf( stderr,"\n   ");
 909             rowcount = 3;
 910         }
 911         fprintf( stderr, " %s", wm->modname );
 912         rowcount += strlen(wm->modname) + 1;
 913         DEBUG_LoadEntryPoints32( wm->module, wm->modname );
 914     }
 915     fprintf( stderr, "\n" );
 916 }
 917
 918
 919 void
 920 DEBUG_AddLineNumber( struct name_hash * func, int line_num,
 921                      unsigned long offset )
 922 {
 923   if( func == NULL )
 924     {
 925       return;
 926     }
 927
 928   if( func->n_lines + 1 >= func->lines_alloc )
 929     {
 930       func->lines_alloc += 64;
 931       func->linetab = xrealloc(func->linetab,
 932                               func->lines_alloc * sizeof(WineLineNo));
 933     }
 934
 935   func->linetab[func->n_lines].line_number = line_num;
 936   func->linetab[func->n_lines].pc_offset.seg = func->addr.seg;
 937   func->linetab[func->n_lines].pc_offset.off = func->addr.off + offset;
 938   func->linetab[func->n_lines].pc_offset.type = NULL;
 939   func->n_lines++;
 940 }
 941
 942
 943 struct wine_locals *
 944 DEBUG_AddLocal( struct name_hash * func, int regno,
 945                 int offset,
 946                 int pc_start,
 947                 int pc_end,
 948                 char * name)
 949 {
 950   if( func == NULL )
 951     {
 952       return NULL;
 953     }
 954
 955   if( func->n_locals + 1 >= func->locals_alloc )
 956     {
 957       func->locals_alloc += 32;
 958       func->local_vars = xrealloc(func->local_vars,
 959                               func->locals_alloc * sizeof(WineLocals));
 960     }
 961
 962   func->local_vars[func->n_locals].regno = regno;
 963   func->local_vars[func->n_locals].offset = offset;
 964   func->local_vars[func->n_locals].pc_start = pc_start;
 965   func->local_vars[func->n_locals].pc_end = pc_end;
 966   func->local_vars[func->n_locals].name = xstrdup(name);
 967   func->local_vars[func->n_locals].type = NULL;
 968   func->n_locals++;
 969
 970   return &func->local_vars[func->n_locals - 1];
 971 }
 972
 973 void
 974 DEBUG_DumpHashInfo()
 975 {
 976   int i;
 977   int depth;
 978   struct name_hash *nh;
 979
 980   /*
 981    * Utility function to dump stats about the hash table.
 982    */
 983     for(i=0; i<NR_NAME_HASH; i++)
 984     {
 985       depth = 0;
 986       for (nh = name_hash_table[i]; nh; nh = nh->next)
 987         {
 988           depth++;
 989         }
 990       fprintf(stderr, "Bucket %d: %d\n", i, depth);
 991     }
 992 }
 993
 994 /***********************************************************************
 995  *           DEBUG_CheckLinenoStatus
 996  *
 997  * Find the symbol nearest to a given address.
 998  * If ebp is specified as non-zero, it means we should dump the argument
 999  * list into the string we return as well.
1000  */
1001 int DEBUG_CheckLinenoStatus( const DBG_ADDR *addr)
1002 {
1003     struct name_hash * nearest = NULL;
1004     int mid, high, low;
1005
1006     if( sortlist_valid == FALSE )
1007       {
1008         DEBUG_ResortSymbols();
1009       }
1010
1011     /*
1012      * Binary search to find closest symbol.
1013      */
1014     low = 0;
1015     high = sorttab_nsym;
1016     if( addr_sorttab[0]->addr.seg > addr->seg
1017         || (   addr_sorttab[0]->addr.seg == addr->seg
1018             && addr_sorttab[0]->addr.off > addr->off) )
1019       {
1020         nearest = NULL;
1021       }
1022     else if( addr_sorttab[high - 1]->addr.seg < addr->seg
1023         || (   addr_sorttab[high - 1]->addr.seg == addr->seg
1024             && addr_sorttab[high - 1]->addr.off < addr->off) )
1025       {
1026         nearest = addr_sorttab[high - 1];
1027       }
1028     else
1029       {
1030         while(1==1)
1031           {
1032             mid = (high + low)/2;
1033             if( mid == low )
1034               {
1035                 /*
1036                  * See if there are any other entries that might also
1037                  * have the same address, and would also have a line
1038                  * number table.
1039                  */
1040                 if( mid > 0 && addr_sorttab[mid]->linetab == NULL )
1041                   {
1042                     if(    (addr_sorttab[mid - 1]->addr.seg ==
1043                             addr_sorttab[mid]->addr.seg)
1044                         && (addr_sorttab[mid - 1]->addr.off ==
1045                             addr_sorttab[mid]->addr.off)
1046                         && (addr_sorttab[mid - 1]->linetab != NULL) )
1047                       {
1048                         mid--;
1049                       }
1050                   }
1051
1052                 if(    (mid < sorttab_nsym - 1)
1053                     && (addr_sorttab[mid]->linetab == NULL) )
1054                   {
1055                     if(    (addr_sorttab[mid + 1]->addr.seg ==
1056                             addr_sorttab[mid]->addr.seg)
1057                         && (addr_sorttab[mid + 1]->addr.off ==
1058                             addr_sorttab[mid]->addr.off)
1059                         && (addr_sorttab[mid + 1]->linetab != NULL) )
1060                       {
1061                         mid++;
1062                       }
1063                   }
1064                 nearest = addr_sorttab[mid];
1065 #if 0
1066                 fprintf(stderr, "Found %x:%x when looking for %x:%x %x %s\n",
1067                         addr_sorttab[mid ]->addr.seg,
1068                         addr_sorttab[mid ]->addr.off,
1069                         addr->seg, addr->off,
1070                         addr_sorttab[mid ]->linetab,
1071                         addr_sorttab[mid ]->name);
1072 #endif
1073                 break;
1074               }
1075             if(    (addr_sorttab[mid]->addr.seg < addr->seg)
1076                 || (   addr_sorttab[mid]->addr.seg == addr->seg
1077                     && addr_sorttab[mid]->addr.off <= addr->off) )
1078               {
1079                 low = mid;
1080               }
1081             else
1082               {
1083                 high = mid;
1084               }
1085           }
1086       }
1087
1088     if (!nearest) return FUNC_HAS_NO_LINES;
1089
1090     if( nearest->flags & SYM_STEP_THROUGH )
1091       {
1092         /*
1093          * This will cause us to keep single stepping until
1094          * we get to the other side somewhere.
1095          */
1096         return NOT_ON_LINENUMBER;
1097       }
1098
1099     if( (nearest->flags & SYM_TRAMPOLINE) )
1100       {
1101         /*
1102          * This will cause us to keep single stepping until
1103          * we get to the other side somewhere.
1104          */
1105         return FUNC_IS_TRAMPOLINE;
1106       }
1107
1108     if( nearest->linetab == NULL )
1109       {
1110         return FUNC_HAS_NO_LINES;
1111       }
1112
1113
1114     /*
1115      * We never want to stop on the first instruction of a function
1116      * even if it has it's own linenumber.  Let the thing keep running
1117      * until it gets past the function prologue.  We only do this if there
1118      * is more than one line number for the function, of course.
1119      */
1120     if( nearest->addr.off == addr->off && nearest->n_lines > 1 )
1121       {
1122         return NOT_ON_LINENUMBER;
1123       }
1124
1125     if( (nearest->sourcefile != NULL)
1126         && (addr->off - nearest->addr.off < 0x100000) )
1127       {
1128           low = 0;
1129           high = nearest->n_lines;
1130           while ((high - low) > 1)
1131           {
1132               mid = (high + low) / 2;
1133               if (addr->off < nearest->linetab[mid].pc_offset.off) high = mid;
1134               else low = mid;
1135           }
1136           if (addr->off == nearest->linetab[low].pc_offset.off)
1137               return AT_LINENUMBER;
1138           else
1139               return NOT_ON_LINENUMBER;
1140       }
1141
1142     return FUNC_HAS_NO_LINES;
1143 }
1144
1145 /***********************************************************************
1146  *           DEBUG_GetFuncInfo
1147  *
1148  * Find the symbol nearest to a given address.
1149  * Returns sourcefile name and line number in a format that the listing
1150  * handler can deal with.
1151  */
1152 void
1153 DEBUG_GetFuncInfo( struct list_id * ret, const char * filename,
1154                    const char * name)
1155 {
1156     char buffer[256];
1157     char * pnt;
1158     struct name_hash *nh;
1159
1160     for(nh = name_hash_table[name_hash(name)]; nh; nh = nh->next)
1161       {
1162         if( filename != NULL )
1163           {
1164
1165             if( nh->sourcefile == NULL )
1166               {
1167                 continue;
1168               }
1169
1170             pnt = strrchr(nh->sourcefile, '/');
1171             if( strcmp(nh->sourcefile, filename) != 0
1172                 && (pnt == NULL || strcmp(pnt + 1, filename) != 0) )
1173               {
1174                 continue;
1175               }
1176           }
1177         if (!strcmp(nh->name, name)) break;
1178       }
1179
1180     if (!nh && (name[0] != '_'))
1181     {
1182         buffer[0] = '_';
1183         strcpy(buffer+1, name);
1184         for(nh = name_hash_table[name_hash(buffer)]; nh; nh = nh->next)
1185           {
1186             if( filename != NULL )
1187               {
1188                 if( nh->sourcefile == NULL )
1189                   {
1190                     continue;
1191                   }
1192
1193                 pnt = strrchr(nh->sourcefile, '/');
1194                 if( strcmp(nh->sourcefile, filename) != 0
1195                     && (pnt == NULL || strcmp(pnt + 1, filename) != 0) )
1196                   {
1197                     continue;
1198                   }
1199               }
1200             if (!strcmp(nh->name, buffer)) break;
1201           }
1202     }
1203
1204     if( !nh )
1205       {
1206         if( filename != NULL )
1207           {
1208             fprintf(stderr, "No such function %s in %s\n", name, filename);
1209           }
1210         else
1211           {
1212             fprintf(stderr, "No such function %s\n", name);
1213           }
1214         ret->sourcefile = NULL;
1215         ret->line = -1;
1216         return;
1217       }
1218
1219     ret->sourcefile = nh->sourcefile;
1220
1221     /*
1222      * Search for the specific line number.  If we don't find it,
1223      * then return FALSE.
1224      */
1225     if( nh->linetab == NULL )
1226       {
1227         ret->line = -1;
1228       }
1229     else
1230       {
1231         ret->line = nh->linetab[0].line_number;
1232       }
1233 }
1234
1235 /***********************************************************************
1236  *           DEBUG_GetStackSymbolValue
1237  *
1238  * Get the address of a named symbol from the current stack frame.
1239  */
1240 static
1241 BOOL DEBUG_GetStackSymbolValue( const char * name, DBG_ADDR *addr )
1242 {
1243   struct name_hash * curr_func;
1244   unsigned int       ebp;
1245   unsigned int       eip;
1246   int                i;
1247
1248   if( DEBUG_GetCurrentFrame(&curr_func, &eip, &ebp) == FALSE )
1249     {
1250       return FALSE;
1251     }
1252
1253   for(i=0; i < curr_func->n_locals; i++ )
1254     {
1255       /*
1256        * Test the range of validity of the local variable.  This
1257        * comes up with RBRAC/LBRAC stabs in particular.
1258        */
1259       if(    (curr_func->local_vars[i].pc_start != 0)
1260           && ((eip - curr_func->addr.off)
1261               < curr_func->local_vars[i].pc_start) )
1262         {
1263           continue;
1264         }
1265
1266       if(    (curr_func->local_vars[i].pc_end != 0)
1267           && ((eip - curr_func->addr.off)
1268               > curr_func->local_vars[i].pc_end) )
1269         {
1270           continue;
1271         }
1272
1273       if( strcmp(name, curr_func->local_vars[i].name) == 0 )
1274         {
1275           /*
1276            * OK, we found it.  Now figure out what to do with this.
1277            */
1278           /* FIXME: what if regno == 0 ($eax) */
1279           if( curr_func->local_vars[i].regno != 0 )
1280             {
1281               /*
1282                * Register variable.  Point to DEBUG_context field.
1283                */
1284               addr->seg = 0;
1285               addr->off = ((DWORD)&DEBUG_context) + reg_ofs[curr_func->local_vars[i].regno];
1286               addr->type = curr_func->local_vars[i].type;
1287
1288               return TRUE;
1289             }
1290
1291           addr->seg = 0;
1292           addr->off = ebp + curr_func->local_vars[i].offset;
1293           addr->type = curr_func->local_vars[i].type;
1294
1295           return TRUE;
1296         }
1297     }
1298   return FALSE;
1299 }
1300
1301 int
1302 DEBUG_InfoLocals()
1303 {
1304   struct name_hash  * curr_func;
1305   unsigned int        ebp;
1306   unsigned int        eip;
1307   int                 i;
1308   unsigned int      * ptr;
1309   int                 rtn = FALSE;
1310
1311   if( DEBUG_GetCurrentFrame(&curr_func, &eip, &ebp) == FALSE )
1312     {
1313       return FALSE;
1314     }
1315
1316   for(i=0; i < curr_func->n_locals; i++ )
1317     {
1318       /*
1319        * Test the range of validity of the local variable.  This
1320        * comes up with RBRAC/LBRAC stabs in particular.
1321        */
1322       if(    (curr_func->local_vars[i].pc_start != 0)
1323           && ((eip - curr_func->addr.off)
1324               < curr_func->local_vars[i].pc_start) )
1325         {
1326           continue;
1327         }
1328
1329       if(    (curr_func->local_vars[i].pc_end != 0)
1330           && ((eip - curr_func->addr.off)
1331               > curr_func->local_vars[i].pc_end) )
1332         {
1333           continue;
1334         }
1335
1336       if( curr_func->local_vars[i].offset == 0 )
1337         {
1338           ptr = (unsigned int *) (((DWORD)&DEBUG_context)
1339                 + reg_ofs[curr_func->local_vars[i].regno]);
1340           fprintf(stderr, "%s:%s (optimized into register $%s) == 0x%8.8x\n",
1341                   curr_func->name, curr_func->local_vars[i].name,
1342                   reg_name[curr_func->local_vars[i].regno],
1343                   *ptr);
1344         }
1345       else
1346         {
1347           ptr = (unsigned int *) (ebp + curr_func->local_vars[i].offset);
1348           fprintf(stderr, "%s:%s == 0x%8.8x\n",
1349                   curr_func->name, curr_func->local_vars[i].name,
1350                   *ptr);
1351         }
1352     }
1353
1354   rtn = TRUE;
1355
1356   return (rtn);
1357 }
1358
1359 int
1360 DEBUG_SetSymbolSize(struct name_hash * sym, unsigned int len)
1361 {
1362   sym->symbol_size = len;
1363
1364   return TRUE;
1365 }
1366
1367 int
1368 DEBUG_SetSymbolBPOff(struct name_hash * sym, unsigned int off)
1369 {
1370   sym->breakpoint_offset = off;
1371
1372   return TRUE;
1373 }
1374
1375 int
1376 DEBUG_GetSymbolAddr(struct name_hash * sym, DBG_ADDR * addr)
1377 {
1378
1379   *addr = sym->addr;
1380
1381   return TRUE;
1382 }
1383
1384 int DEBUG_SetLocalSymbolType(struct wine_locals * sym, struct datatype * type)
1385 {
1386   sym->type = type;
1387
1388   return TRUE;
1389 }