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