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